chore(deps): update dependency @ts-runtypes/devtools to v0.12.2

[renovate]

This PR contains the following updates:

Package	Change	Age	Confidence
@ts-runtypes/devtools (source)	0.10.0 → 0.12.2

---

Release Notes

MionKit/ts-run-types (@​ts-runtypes/devtools)

v0.12.2

Compare Source

Next.js joins the supported bundlers, and the rest of the release is about a dev
server telling the truth. Turbopack has no plugin API at all, so the adapter takes
another route: next.config starts a single broker that owns the resolver and each of
Turbopack's ephemeral loader workers connects to it, rather than four workers each
starting their own whole-program build. Alongside it, three staleness bugs are fixed —
a type edit that invalidated nothing and left a dev server serving a validator for the
old shape, an incremental update that collapsed the resolver's program down to the
edited files, and a multi-function call site whose bindings all went to the first
family's bundle. The release plumbing gets the same treatment: the pre-publish image
is buildable again, and both container images now refuse to run once what they baked
has drifted.

Features

• devtools: A Next.js / Turbopack adapter — the first host reached with no plugin
  API at all. Turbopack runs no webpack plugins, but it does run webpack-style
  loaders, and files-mode makes that enough: the generated modules are real files it
  resolves natively. Loaders run in a pool of ephemeral worker processes, so a loader
  that started the resolver itself started one per worker (measured: four resolvers,
  four whole-program builds). Instead next.config starts one broker owning the
  single resolver and each worker connects over a socket, with ownership decided by an
  atomic socket bind keyed per invocation — otherwise Next's detached telemetry flush,
  which also loads the config, would leave a stale resolver behind to poison every
  later run.

Bug Fixes

• devtools: A rewrite reports the type files it depends on, so a type edit is
  never stale. Those edges are invisible to every bundler — a type-only import is
  erased, and an ambient .d.ts type never had one — so editing the type invalidated
  nothing and a dev server kept serving a validator built for the old shape. Silently,
  since a validator accepts data rather than erroring. The resolver now reports the
  declaring files per rewrite and every host declares them through one mechanism.
• devtools: An incremental update pushes the whole source overlay. setSources
  replaces the resolver's overlay and rebuilds the program against exactly what it
  receives, so sending only the edited files collapsed the program to those files: the
  following generate emitted only their demand and deleted every other entry's module
  from disk, and any other marker file then failed with "source file not in program".
  Measured on a 62-module project, one two-file edit took it to 2. A host that
  resolves lazily re-transforms its way out of that; one that resolves eagerly cannot.
• devtools: A virtual source is never declared as a bundler watch dependency. A
  host may register sources that exist nowhere on disk (a Vue SFC script as
  Comp.vue.ts), and Vite's dev-mode addWatchFile records what it is given as an
  extra import of the module being transformed, so declaring one failed the request
  with "Failed to resolve import ./Comp.vue.ts". The index still records them; only
  the bundler declaration is filtered.
• resolver: Under moduleMode: 'allSingle' each fnId of a multi-function site is
  imported from its own family bundle. Every family is its own bundle there, but the
  site carried a single basename matched against the scalar fnId, so a multi-function
  site sent all its bindings to the first fnId's bundle and the rest were
  unresolvable.
• e2e: The pre-publish image is buildable with the Next app, so rtx release e2e
  stops failing on a pulled image that has no next. Three independent blockers, none
  of which a throwaway-container check hits: next was younger than the workspace's own
  30-day minimumReleaseAge; next pulls sharp, whose install script the allowBuilds
  allowlist rejects; and with no @types/react baked, next build auto-ran pnpm add inside the image, re-resolving and pruning the baked toolchains mid-build.
• compile: ts-runtypes compile no longer crashes at random on a larger project.
  The compiler emits files in parallel, and the step that collected them was not
  safe to run from several threads at once, so two files finishing together could
  kill the whole command. It showed up as a build that failed once and then
  succeeded on a retry, with nothing in the project to explain it.
• sidecar: A pattern that backtracks catastrophically can no longer wedge the
  pattern checker. (x|y)+.*.* against a long run of x never returns from the
  match, and the checker is single-threaded, so the build stalled for five seconds
  and then gave up on every later pattern check. Matching is now bounded, and a
  pattern that outruns the budget is reported against that one format instead of
  taking the rest of the build down with it.
• container: Both baked images stamp a content hash of everything they bake, so a
  stale image cannot be run. A _deps change never forced a republish and the image
  helper prefers the published image, so CI silently ran a drifted toolchain while a
  local build quietly got a correct one. A run that would have used a drifted image
  now builds locally instead, and a missing stamp counts as unknown rather than drift,
  so images built before this keep working.

Testing

• cli: A crash in a spawned ts-runtypes process now leaves a full report behind
  instead of a truncated one. The failure message keeps the first, most useful part
  (what went wrong and where), and the complete output is saved to a file that CI
  keeps, so one failed run is enough to work out the cause.
• e2e: The pre-publish matrix covers the Next.js adapter with a real next build,
  which is the only place that path can be exercised.
• devtools: A test pins that the Next invalidation stamp moves on a type change,
  so the staleness fix cannot silently regress.

Documentation

• The Next.js adapter is documented on the website and in the architecture notes,
  including the invariants that look like cleanups but are not.
• website: The JSON Schema JS page is folded into the schema generation guide, and
  a duplicated union explanation is dropped.

v0.12.1

Compare Source

This release is mostly about what the build reports and what it leaves out.
Build-time diagnostics turned out to be quietly unreliable in three separate ways: a
warm cache hit dropped every finding, nested and union-member types raised nothing at
all, and a type demanded by several families reported the same finding once per
family. All three are fixed, and on a real consumer (mion's router suite) the net
effect is broader coverage with five times less noise. On the output side, a
value-first builder const whose only use is typeof in type position no longer emits
a reflection graph at all, so a schema written to recover its type costs nothing at
runtime, and registerClassSerializer stops dragging a class's whole type graph into
the bundle just to read one name. Bun becomes a first-party target, with an adapter
covering both of Bun's plugin hosts.

Features

• devtools: @ts-runtypes/devtools/bun, a first-party Bun adapter for both of
  Bun's plugin hosts — Bun.build and the runtime loader (Bun.plugin from a
  preload). The runtime host is a strict subset that needed three gaps bridged,
  including a readiness gate, so a host that registers the plugin without await is
  still correct instead of silently passing files through untransformed. A new
  detachResolver option unrefs the resolver child on that host, so a preloaded
  process can still exit.
• go: Reflection graphs are elided for unused builder consts. A value-first
  builder call whose result is provably unused in its own file — discarded, or bound
  to a non-exported const referenced only via typeof in type position (the
  InferType pattern) — emits no runtype graph. Always on, and default-deny: any
  value use, export, let binding or unrecognized position keeps the graph.
• core: registerClassSerializer demands a small csr name card instead of the
  reflection graph. The registration site used to read one string off the runtype
  cache, forcing the class's whole type graph into the bundle; it now reads id and
  name with zero reflection payload, and legacy tuples and manual string ids keep
  resolving.
• runtypes: getRT(rtFnHash).binarySizeEstimate exposes the compile-time
  cold-start buffer estimate the Go emitter already bakes into every tb entry.

Bug Fixes

• cache: Build diagnostics survive a warm cache hit. The walker produces the
  findings and a disk-cache hit skips the walker, so every warning a project had
  appeared on the first build and then vanished on every build after it — it came
  back only when someone wiped the cache, which made a cached build look like a clean
  one. Entries now persist the findings their walk produced and a hit re-emits them,
  always attributed to the current build's call sites.
• diagnostics: Findings are surfaced for nested types, not just root ones. A child
  type gets its own cache entry keyed by its own structural id, which no marker call
  ever named, so it carried no provenance and anything unattributable was dropped. A
  class warned at the root of an encoder but said nothing when nested or reached
  through a union, which is how people normally write types. Provenance is now
  inherited by every type a call site reaches.
• diagnostics: Each diagnostic is reported once per call site, not once per
  family. A type demanded by several cache families is walked once per family, and
  each walk's dedupe was blind to its siblings, so one class touched by the JSON
  encoder and decoder reported the same finding four times.
• mock: createMockDataFn sites demand the format-transform entry, so mocks apply
  declared format transforms. A Lowercase pool sample like 'MiXeD' used to ship
  as-is unless some other call site happened to compile the transform.
• convert: convert --to builders refuses embedded type references whose cycle
  needs an escape, rather than emitting a spelling it cannot make good on.
• cachegen: The CodeNS sentinel propagates through validate's structural-format
  splices.
• bench: gen-docs reads results/ by shape instead of a per-reader blocklist.
  The stale copy of that list did not know about the audit lane's output and took the
  whole website build, and with it the deploy, down on the first one.
• repo: Embedded NUL characters are spelled as escapes, not raw bytes, so git
  stops classifying two runtime sources as binary and they can be diffed and merged
  again.

Refactoring

• runtime: The compiled-fn cache degrade-vs-throw decision is based on
  knowsType, which counts registered fn entries, so a createX-only type no longer
  flips behaviour depending on whether an unrelated file happened to reflect it.

Testing

• fuzz: An elision lane generates builder schemas through the real converter and
  compiles both spellings through the real resolver — fixture integrity,
  byte-identical shared entries, the emission split, and a behaviour floor on the
  static form, with negative controls proving every oracle fires.
• fuzz: Crash capture becomes a shared guard wrapped around every lane's loop, and
  resolver errors are captured as replayable findings.

CI

• fuzz: The rtx registry is the one lane list (the workflows derive their
  matrices from it) and every lane runs a quick tier on every PR, so findings arrive
  while their cause is still in context instead of only at release time.

Documentation

• fuzz: The three fuzz budget tiers and the scheduling rule are written down.
• Builder examples lead with the static InferType form, which is the shape the new
  elision rewards.
• A finding must be solved, not just recorded: filing a spec stays available for what
  genuinely cannot land in the task, but fixing it in the current PR is now the
  documented default.

Miscellaneous

• lint: oxlint's type-aware rules are enabled, and everything they flagged is
  resolved.

v0.12.0

Compare Source

This release settles what JSON Schema means for RunTypes: it is an output, never an
input. createJsonSchemaFn<T>() emits a per-type JSON Schema document from the same
reflection graph every other family reads, and createStandardSchema serves the
identical document through Standard Schema's ~standard.jsonSchema converter. A
first-class JSON Schema authoring door was prototyped, taken through the official
test suite, and then deliberately removed before ever shipping — types stay the
single source of truth. What survives from that detour is the part that made
validation better regardless: a much larger named-format roster with spec-grade
engines, JSON Schema keyword aliases on the formats, and regex pattern support
whose mock samples are generated from the pattern itself and verified on a real JS
engine. Around that: the value-first surface is renamed Type Builders and its
tuple/func builders move to named slot groups (breaking); a new ts-runtypes convert verb rewrites marker call sites between the two authoring forms, and CI
converts the whole test-suite tree and re-runs it to prove the forms agree;
structural type IDs become canonical for recursive graphs, so equivalent recursive
types converge on one cache entry (hashes reshuffle once — caches regenerate on the
next build, no action needed).

Features

• standard: createJsonSchemaFn<T>() returns a per-type JSON Schema document
  fn, backed by a new jsc cache family that emits schema documents only for the
  types its call sites demand. createStandardSchema's ~standard.jsonSchema
  serves the same document, stripDialect / buildJsonSchemaConverter are
  exported for consumers that post-process, and a document's
  additionalProperties is derived from the declared encoder strategy, so the
  schema says what the wire actually does with unknown keys.
• schemadoc: Union documents describe the encoder's flat-union envelope — the
  schema documents what the JSON encoder emits, not an idealized union.
• types: JSONShape<T>, the JSON wire twin of DataOnly<T>: what T looks
  like after a JSON round-trip (dates as strings, maps as arrays, functions gone).
• convert: A new ts-runtypes convert --to type|builders CLI verb rewrites
  marker call sites between the two authoring forms over the canonical reflection
  graph — atomics through circular types, enums, classes, temporal, formats and
  brand metadata — refusing with pointed CNV diagnostics anything it cannot
  spell losslessly instead of guessing.
• builders: [breaking] rt.tuple and rt.func take named slot groups —
  tuple({required, optional, rest}), func({params, ret}) — and the positional
  spelling is dropped; slots can carry labels that converge with type-first
  labels, so a converted builder round-trips byte-identically.
• formats: Spec-grade format engines: RFC 5321 email (dotted TLD required),
  RFC 3339 date/time layouts, IDNA / RFC 1123 hostnames, strict IPv4/IPv6 parsing
  with localhost off by default, plus eight JSON Schema named formats.
• formats: JSON Schema keyword aliases land on the existing surface: bound
  keywords on numeric/date formats, contentEncoding / contentMediaType in
  value-first spelling, and array/object keywords unified into FormattedArray /
  FormattedObject.
• formats: Regex pattern support that stays honest: patterns are validated
  on a real JS engine via an embedded sidecar, mock samples are auto-generated
  from the regex at build time, and a literal mock.seed makes the generated
  pool deterministic.
• marker: The marker package is configurable (markers.packages), so wrappers
  and internal republishes can carry the markers; a marker-named type from an
  untrusted package reports MKR012 instead of silently resolving, and a marker
  type that resolved to the checker's error type refuses with MKR013 instead of
  hashing garbage.
• typeid: Structural type identity is canonical for recursive graphs: cycle
  ids are emitted from a bisimulation quotient, shared recursive containers
  converge on one entry, a walk that latched the depth cap is never cached, and
  mockSamples no longer participate in format hashing (same shape, different
  samples — one cache entry). Existing __runtypes caches regenerate on the next
  build.
• runtypes: rt::countEnumKeys picks its key counter per engine — for-in on
  V8, Object.keys on JavaScriptCore — and the benchmark suite now runs under
  node AND bun with a tripwire asserting the per-engine branch actually fired.
• diagnostics: Two call sites declaring different mockSamples for the same
  cache entry fail the build instead of last-write-wins.

Bug Fixes

• program: Inferred Programs root the tsconfig's file list, and virtual
  node_modules sources stay out of program roots — fixing marker resolution in
  projects that rely on ambient declarations.
• types: Branded literals and branded tuples are recovered in the clean type
  (inference-based brand subtraction), and the DataOnly Temporal augmentation
  no longer collapses to never when the Temporal lib is absent.
• runtypes: defaultParamValues carries JS source, not runtime values,
  matching its own CompiledFnArgs contract (#​299).
• typeid: Non-serialisable globals are keyed by constructor, not lib members,
  so their ids no longer depend on which lib declaration supplied them.
• typeid: A total-expansion budget bounds the structural-id walk, so a type
  the compiler error-recovered from unparseable source can no longer spin
  forever — the build reports the type as unresolvable instead of hanging.
• serialization: A declared property whose value is a function is dropped by
  every wire when the object also has an index signature. Its key stayed in the
  index signature's sweep, so the index value's encoder ran over the function:
  binary threw an uncontrolled TypeError and JSON silently emitted the
  function's source text.
• resolver: The shipped DataOnly ladder alias is recognised when composing
  TypeName.
• purefns: Call/new type arguments are stripped from extracted pure-fn
  bodies, so a generic call inside a pure fn no longer leaks TS syntax into the
  emitted JS.
• playground: The test suites gate on a WASM cache that matches the tree, and
  the sample input resyncs when the type is edited.

Performance

• formats: Single-pass engines for time layouts, IPv6 and length bounds.
• runtime: findRTForType is memoized, so mocking is no longer O(registry)
  per format node; hoisted key sweeps and a pure-fn uniqueItems cut repeated
  scans in emitted validators.

Refactoring

• builders: The value-first surface is renamed Type Builders:
  @ts-runtypes/core/builders is canonical and ./schema stays as a deprecated
  alias to the same module until 1.0.
• config: [breaking] The size config object is renamed binarySizing
  (tsconfig plugin block and bundler options), matching the binary family it
  configures.
• go: The reflection model moves into internal/reflection and the schema
  vocabulary into internal/schemadoc — the canonical model every pipeline stage
  now shares.

Documentation

• website: The guides lead with validation: the serialization guide is split,
  JSON Schema generation gets its own guide, source conversion gets a page, and
  the JSON Schema keyword tables document the output mapping.
• website: Homepage test counts are generated from the suites instead of
  hand-typed.

Testing

• convert: The whole suite tree is converted into each authoring form and
  re-run against identical assertions in the release gate, so a failure
  can only mean the conversion changed behaviour; a printer slot-coverage
  tripwire and two convert fuzz lanes (declaration sweep + CLI round-trip over
  the real binary) guard the printers between releases.
• runtypes: Per-rule dialect-spec conformance runs via the schema generator,
  and the schema-doc corpus is pinned as a golden.
• serialization: StringTime and StringDateTime round-trip cases.
• fuzz: Every lane derives its entry seed from the package version instead
  of a pinned constant, and prints it with the command that replays it, so a run
  is reproducible within a release and each version bump rotates the ground the
  lanes explore.

CI

• release-gate: Every fuzz lane's --soak budget runs in the gate, one
  runner per lane, seeded from the run id so each gate explores new ground (the
  seed is echoed for verbatim replay).
• fuzz-soak: The same lanes also run on demand outside the release path, so
  draining a finding costs twelve short jobs rather than a whole gate, and the
  lane lists in both workflows and the rtx registry are pinned equal by a
  contract test.

v0.11.0

Compare Source

This release renames the public factory surface and reshapes the CLI, both breaking.
Every factory that returns a callable now ends in Fn — createValidateFn,
createJsonEncoderFn, createMockDataFn and nine others — so the name says the
two-step "factory returns a callable you call later" shape out loud; factories that
return an object keep their names. The binary answers to tsgo-style subcommands
(serve, compile, enrich) instead of mixed flags and bare defaults, gen and
check collapse into a single enrich verb with a uniform --no-emit, and
describe is gone. Around that, enrichment becomes something the bundler plugin can
drive: an opt-in enrich option scaffolds and syncs the friendly / mock / i18n
mirrors on source change, and the production build gate now enforces completeness, so
a release can no longer ship blank labels or mocks. tsconfig handling is TypeScript's
on every lane (one upward discovery from cwd, threaded everywhere), and every
project-semantic option is settable from both the tsconfig plugin entry and the
bundler options with a codegen'd drift guard. New on top: a numberMode validation
option for migrating off looser validators, seeded repeatable mock data, exported
compiled-fn structs for consumers that ship compiled functions over the wire, and a
generics-rejection model that says why a type cannot resolve instead of overflowing
the stack.

Features

• core: [breaking] The twelve callable-returning factories gain a uniform Fn
  suffix: createValidateFn, createGetValidationErrorsFn, createHasUnknownKeysFn,
  createCloneExactShapeFn, createUnknownKeyErrorsFn, createFormatTransformFn,
  createJsonEncoderFn / createJsonDecoderFn, createBinaryEncoderFn /
  createBinarySizerFn / createBinaryDecoderFn, and createMockDataFn. Factories
  that return an object are untouched (createStandardSchema, createFriendlyText,
  createFriendlyTextI18n, the DataView serializers), as are the return-type aliases
  (ValidateFn, JsonEncoderFn, …). Pure identifier rename — the scanner keys on the
  marker, not the JS name, so no cache key, hash or protocol changes.
• cli: [breaking] One tsgo-style args[0] command table replaces the mixed
  flag/subcommand dispatch: serve subsumes the default stdio server, the inline
  server and the stdin-sources lanes behind --sources project|stdin|ops, compile
  replaces --compile, and each command owns its own flag set. --daemon and its
  socket transport are retired (no caller), --json is uniform, and --cmd -h prints
  self-documenting per-command help listing every flag.
• cli: [breaking] gen and check merge into one enrich verb: bare enrich
  scaffolds, --no-emit turns any write lane into a diagnostics-only pass, and
  compile --no-emit gets the same meaning. describe is removed — its indented type
  tree was near-identical to the source type, had no caller, and is superseded by the
  enrich scaffold.
• enrich: --require-complete is the completeness gate: unfilled @todo
  placeholders and blank scaffold values (FT020/FT023, MD020/MD023) are reported by
  --no-emit but exit 0, while --require-complete fails on them. Wrong or stale
  content (bad field, orphan carcass, drift) still fails both lanes.
• enrich: [breaking] --translate is renamed --i18n to line the flag up with
  the config it reads (tsconfig i18n, plugin enrich.i18n); it manages translation
  files and never translates. Sub-modes are unchanged.
• plugin: Opt-in enrichment from the bundler: a new PluginOptions.enrich object
  (friendly / mock / i18n / suppressHmr, all off by default) syncs the
  enrichment mirrors on source change through a new daemon op, auto-suppresses HMR for
  its own writes, and runs a read-only drift gate on production builds. Under
  failOnError that gate now enforces completeness too, so a build fails on an
  unfilled @todo or a blank value as well as on drift; dev and watch still tolerate
  blanks while you are authoring.
• validate: New numberMode option (isFinite | typeof | notNaN) selects the
  emitted base number check, settable per call site or project-wide via the plugin /
  tsconfig and merged per field. It eases migration from a looser validator: typeof
  accepts NaN and Infinity (like ajv, typia, JSON Schema), notNaN rejects NaN but
  keeps Infinity, and the default isFinite is unchanged — so existing cache keys stay
  byte-stable.
• mocking: createMockDataFn({mock: {seed}}) produces deterministic, repeatable
  values for every type. All mock randomness moves into one exported MockRandom (a
  mulberry32 PRNG under a seed, including UUID bytes and a fixed reference clock for
  Date / Temporal), threaded through custom mock fns so consumer formats stay
  reproducible. Without a seed, behaviour is byte-for-byte unchanged.
• mocking: paramsOptions is an alias of tupleOptions.
• core: Export the compiled-fn data model and reconstruction helpers
  (CompiledFnData, CompiledTypeFn, CompiledPureFunction, PureFunctionData,
  CompiledFnArgs, InitializedTypeFn, plus buildFactoryFromCode,
  buildPureFnFactoryFromCode, entryCode) so a host that ships compiled RT functions
  over the wire and rebuilds them on the far side consumes ts-runtypes as the single
  source of truth instead of reimplementing the structs. Additive re-exports: no
  behaviour, hash or fingerprint change.
• core: Export type-format metadata via codegen — typeFormats (canonical format
  name to {name, kind}), the FormatName union and TypeFormatMeta, generated from
  the Go format registry and drift-guarded, so a consumer mapping a reflected prop's
  formatAnnotation.name onto something external keys off ts-runtypes.
• marker: Unresolvable generics are classified with chain provenance instead of a
  bare "too deeply nested": MKR009 names a self-instantiating generic, MKR010 points at
  a free type parameter reached through a data position, and MKR011 catches a generic
  written without its required type arguments. Defaulted generics used bare resolve
  unchanged.
• devtools: Option parity — failOnError, hashLength and singleThreaded are
  settable in both the tsconfig plugin entry and the bundler options with tsc-style
  precedence, and a codegen'd guard fails CI if either side gains an option the other
  lacks.
• bin: RT_BIN overrides the resolver binary lookup on every lane, so an
  unpublished build or a bisect can be pointed at directly; a value that is not an
  executable throws instead of silently falling through.
• lint: The OXlint/ESLint plugin honours settings.runtypes.binary (config beats
  the RT_BIN env, matching the bundler lane), and unknown keys under
  settings.runtypes warn once per key instead of being a silent no-op.
• release: Publishing is gated on an e2e receipt over the exact tarball bytes — a
  PASS records a sha256 per tarball and the publisher refuses bytes no receipt covers,
  so a repack after the gate can no longer slip through. Stage-approval is now a single
  interactive OTP prompt that approves leaves-first and auto-dispatches the website
  deploy.
• container: The website image trusts RT_WEBSITE_CA_CERT at run time, not only
  during the build.
• website: The Test Suites section is unpublished (the files still feed the
  suite-data codegen), and the site build is gated on the benchmark pages rendering.

Bug Fixes

• typeid: Depth backstop for the structural-id walker. A type graph that mints a
  fresh checker type per member query (lib.esnext's IteratorObject family, a
  self-instantiating generic) defeated the pointer-identity cycle guard and recursed
  into a fatal Go stack overflow; the walk now caps at a generous depth, commits a
  benign placeholder instead of a truncated node, and raises MKR008 at the call site.
• config: One tsconfig, one behaviour. An explicit --tsconfig wins, otherwise the
  config is discovered upward from the working directory exactly as TypeScript does,
  resolved once at process entry and threaded into the plugin-block read, the daemon
  session, the one-shot, compile and program construction; the JS side sheds its
  config logic entirely. Full compiler-option adoption now applies on every lane, so
  the lint lane and the bundler lane can no longer disagree with tsc.
• devtools: Drain the resolver on close and retry requests lost to a respawn, fixing
  a buildEnd race that could drop in-flight work.
• devtools: singleThreaded: false overrides a tsconfig singleThreaded: true.
• lint: Honour tsconfig customConditions / paths in ESLint inline-server mode.
• enrich: rt$default emits one message per field, not one per constraint.
• enrich: Resolve mirror paths in one canonical symlink space.
• website: Mount twoslash package types under their scoped npm names.
• bench: Fail loud when a benchmark stage's container run fails.
• setup: Survive a go.dev tarball 403 in the web installer, fall back to
  proxy.golang.org when go.dev is blocked, and wire the Go install onto the harness's
  non-login PATH.

Performance

• validate: Union validators emit the object guard once in the parent instead of
  repeating it in every child.

Refactoring

• rtx: [breaking] Bare rtx release prints help; the full chain answers to
  rtx release all. The chain ends in an interactive publish that bumps, commits and
  tags, so it should answer to its own name. Internal dev CLI only — no CI impact.
• enrich: Extract the shared enrichgen leaf package so the CLI verb and the daemon
  op plan through the same code and cannot drift, slim the daemon wire to files-only
  with config on the spawn flags, and resolve like a build rather than forcing a source
  condition.
• diagnostics: Name MKR010/MKR011 for the unresolved generic they describe; fold
  CFG001 into the marker codes.
• mocking: Share one mulberry32 PRNG across the mock surface.
• Remove garble obfuscation from the Go build and fix Go setup version handling.

Documentation

• architecture: ARCHITECTURE.md is rewritten as a compact repo map, frames compile
  and enrich as one idea with two owners, and calls serve the daemon mode.
• website: The CLI, configuration and i18n pages document the enrich verb, the
  --no-emit health vs --require-complete completeness split, and the plugin's
  enrichment sync.
• Reconcile the publish runbook to the shipped NPM_TOKEN + 2FA model.

Testing

• enrich: CLI-daemon parity plus CLI-surface contract tests, and the spawn harnesses
  move onto the enrich verb and --no-emit.
• lint: Prove settings.runtypes.tsconfig and RT_BIN reach the resolver through a
  real oxlint config.
• cli: Guard the e2e fixture's CLI verbs against the real binary.
• validate: Assert the union object guard sits in the parent, not the children.

---

Configuration

📅 Schedule: (UTC)

• Branch creation
  • At any time (no schedule defined)
• Automerge
  • At any time (no schedule defined)

🚦 Automerge: Enabled.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.

---

• If you want to rebase/retry this PR, check this box

---

This PR was generated by Mend Renovate. View the repository job log.

[renovate]

⚠️ Artifact update problem

Renovate failed to update an artifact related to this branch. You probably do not want to merge this PR as-is.

♻ Renovate will retry this branch, including artifacts, only when one of the following happens:

• any of the package files in this branch needs updating, or
• the branch becomes conflicted, or
• you click the rebase/retry checkbox if found above, or
• you rename this PR's title to start with "rebase!" to trigger it manually

The artifact failure details are included below:

File name: package-lock.json

npm ERR! code ERESOLVE
npm ERR! ERESOLVE unable to resolve dependency tree
npm ERR! 
npm ERR! While resolving: typescript-runtime-type-benchmarks@1.0.0
npm ERR! Found: @ts-runtypes/bin@0.10.0
npm ERR! node_modules/@ts-runtypes/bin
npm ERR!   dev @ts-runtypes/bin@"0.10.0" from the root project
npm ERR! 
npm ERR! Could not resolve dependency:
npm ERR! peer @ts-runtypes/bin@"0.12.2" from @ts-runtypes/devtools@0.12.2
npm ERR! node_modules/@ts-runtypes/devtools
npm ERR!   dev @ts-runtypes/devtools@"0.12.2" from the root project
npm ERR! 
npm ERR! Fix the upstream dependency conflict, or retry
npm ERR! this command with --force, or --legacy-peer-deps
npm ERR! to accept an incorrect (and potentially broken) dependency resolution.
npm ERR! 
npm ERR! See /runner/cache/others/npm/eresolve-report.txt for a full report.

npm ERR! A complete log of this run can be found in:
npm ERR!     /runner/cache/others/npm/_logs/2026-09-21T04_26_45_526Z-debug-0.log