@ghostry/fabricator 0.0.1 → 0.0.2

package/dist/types/Primitive/object/optional/Fabricator.d.ts

@@ -17,29 +17,27 @@ export type Fabricator<$Schema extends {
     readonly [Adaptation]?: AdaptationsOf<$Schema>;
     /**
      * `Omitted` on the omission roll (or when an `.as(...)` producer returns it)
-     * — read only by `object/Fabricator.ts`'s fabricate loop, which omits the
-     * key entirely rather than writing `undefined`. A "present as `undefined`"
-     * roll returns `undefined` directly, which the loop assigns like any
-     * ordinary value — the difference from `object.omittable`. Fabricating this
-     * outside a parent `object` hands whichever of the three results back
-     * verbatim.
+     * — read only by `object/Fabricator.ts`'s fabricate loop, which omits the key
+     * entirely rather than writing `undefined`. A "present as `undefined`" roll
+     * returns `undefined` directly, which the loop assigns like any ordinary
+     * value — the difference from `object.omittable`. Fabricating this outside a
+     * parent `object` hands whichever of the three results back verbatim.
      */
     fabricate: () => Resolved<$Schema[typeof Meta]["definition"]>;
 };
 export declare function isObjectOptionalFabricator(candidate: BaseFabricator<unknown>): candidate is Fabricator;
 /**
- * Three-way roll: omitted, present-as-`undefined`, or the wrapped value —
- * on this field's private stream; `source` is drawn only when "value" wins.
+ * Three-way roll: omitted, present-as-`undefined`, or the wrapped value — on
+ * this field's private stream; `source` is drawn only when "value" wins.
  * Uniform (1/3 each) by default; not achievable by composing
- * `object.omittable(T.undefinable(inner))`'s two independent 50/50 rolls
- * (that is 50/25/25, not 33/33/33), hence the dedicated three-way
- * `weighted()` here — see CLAUDE.md's "Why `T.optional` isn't
- * `omittable(undefinable(inner))`" under "Compound / field-only kinds".
- * `.weighted(...)` (`Schema.ts`) reweights individual outcomes relative to
- * that same default of `1`; an unspecified outcome keeps it. Skipping
- * `source`'s draw on the two non-"value" outcomes is safe for the same
- * reason as `object/omittable/Fabricator.ts`: `source` already has its own
- * independent stream, minted at build time regardless of this roll (see
- * CLAUDE.md's "Randomness").
+ * `object.omittable(T.undefinable(inner))`'s two independent 50/50 rolls (that
+ * is 50/25/25, not 33/33/33), hence the dedicated three-way `weighted()` here —
+ * see CLAUDE.md's "Why `T.optional` isn't `omittable(undefinable(inner))`"
+ * under "Compound / field-only kinds". `.weighted(...)` (`Schema.ts`) reweights
+ * individual outcomes relative to that same default of `1`; an unspecified
+ * outcome keeps it. Skipping `source`'s draw on the two non-"value" outcomes is
+ * safe for the same reason as `object/omittable/Fabricator.ts`: `source`
+ * already has its own independent stream, minted at build time regardless of
+ * this roll (see CLAUDE.md's "Randomness").
  */
 export declare function Fabricator<$Definition extends Definition>(context: FabricatorContext<Schema<$Definition>>, source: BaseFabricator<any>): Fabricator<Schema<$Definition>>;

package/dist/types/Primitive/object/optional/Outcomes.d.ts

@@ -1,6 +1,6 @@
 /**
- * The three outcomes an optional field's roll can land on. Also the key
- * space `.weighted(...)` weighs — see `Types.ts`'s `Weights`.
+ * The three outcomes an optional field's roll can land on. Also the key space
+ * `.weighted(...)` weighs — see `Types.ts`'s `Weights`.
  *
  * Lives here rather than `Types.ts` so that file stays type-only (see
  * `boolean/Outcomes.ts`).

package/dist/types/Primitive/object/optional/Schema.d.ts

@@ -8,8 +8,8 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      * Layer an opaque production on this schema's existing `[Meta]` — carrying
      * `definition` forward, not discarding it, so a later `.as(...)` (or future
      * validation of `produce`) still has it to check against. `produce` may
-     * return `undefined` or `Omitted`, so custom logic composes the same way
-     * the built-in three-way roll does.
+     * return `undefined` or `Omitted`, so custom logic composes the same way the
+     * built-in three-way roll does.
      */
     as: (produce: Produce<Resolved<$Definition>>) => Schema<$Definition, $Adaptations>;
     /**
@@ -23,8 +23,8 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      */
     weighted: (weights: Weights) => Schema<$Definition, $Adaptations>;
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Definition, $Adaptations>>) => $Returnable) => Schema<$Definition, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

package/dist/types/Primitive/object/optional/Types.d.ts

@@ -11,33 +11,33 @@ export type Definition = AnySchema;
  * The value an optional field's key holds when present at all — the wrapped
  * value, or `undefined` (present-as-`undefined` is one of three outcomes,
  * distinct from the key not appearing). Flows through `[Produces]` into
- * `object/Types.ts`'s per-field type, so a `T.optional`-wrapped field types
- * as `{ a?: T | undefined }` — a real `?:` (from `OmittableKeys`, which also
- * covers this kind) *and* a real `| undefined`.
+ * `object/Types.ts`'s per-field type, so a `T.optional`-wrapped field types as
+ * `{ a?: T | undefined }` — a real `?:` (from `OmittableKeys`, which also
+ * covers this kind) _and_ a real `| undefined`.
  */
 export type Fabricated<$Definition extends Definition, $Bindings extends unknown[] = []> = ValueOf<$Definition, $Bindings> | undefined;
 /**
- * What an optional field's Fabricator returns: the wrapped value,
- * `undefined`, or `Omitted` when the key should not appear — whether from
- * the built-in three-way roll or, via `.as(...)`, an opaque producer.
+ * What an optional field's Fabricator returns: the wrapped value, `undefined`,
+ * or `Omitted` when the key should not appear — whether from the built-in
+ * three-way roll or, via `.as(...)`, an opaque producer.
  */
 export type Resolved<$Definition extends Definition> = Fabricated<$Definition> | typeof Omitted;
 export type { Outcome } from "./Outcomes";
 /**
- * Relative weights for `.weighted(...)`, keyed by `Outcome`. Keys optional —
- * an omitted key falls back to baseline `1`, the same weight the uniform
- * 1/3 split already uses. Values are relative, exactly like `weighted()`
+ * Relative weights for `.weighted(...)`, keyed by `Outcome`. Keys optional — an
+ * omitted key falls back to baseline `1`, the same weight the uniform 1/3 split
+ * already uses. Values are relative, exactly like `weighted()`
  * (`Distribution/index.ts`) — they need not sum to one, and are fed to
  * `weighted()` unchanged alongside each unspecified key's baseline `1`.
  *
- * Specifying one outcome's weight shifts *every* outcome's resulting
- * probability, not just the named one — unspecified ones stay at weight `1`
- * but their share of the total still moves, since the total changed.
- * `.weighted({ omitted: 0.1 })` on `T.optional` is not "10% omitted, other
- * two still 33%" — with `undefined`/`value` at default `1`, the split is
- * `0.1 / 2.1 ≈ 4.8%` omitted and `≈47.6%` each for the other two. No
- * independent "absolute probability" mode; weights are only meaningful
- * relative to the full set in play.
+ * Specifying one outcome's weight shifts _every_ outcome's resulting
+ * probability, not just the named one — unspecified ones stay at weight `1` but
+ * their share of the total still moves, since the total changed. `.weighted({
+ * omitted: 0.1 })` on `T.optional` is not "10% omitted, other two still 33%" —
+ * with `undefined`/`value` at default `1`, the split is `0.1 / 2.1 ≈ 4.8%`
+ * omitted and `≈47.6%` each for the other two. No independent "absolute
+ * probability" mode; weights are only meaningful relative to the full set in
+ * play.
  */
 export type Weights = {
     omitted: number;

package/dist/types/Primitive/opaque/Registry.d.ts

@@ -5,8 +5,8 @@ import { Schema } from "./Schema";
  * instance — produced by `produce` and typed as whatever it returns, so
  * `T.opaque((random) => new Map<string, number>())` needs no annotation.
  *
- * `produce` receives this schema's own seeded stream, so an opaque value
- * still replays from a seed; see `Types.ts`'s `Produce`. No bare form and
- * no `.as()` — `produce` is the whole schema.
+ * `produce` receives this schema's own seeded stream, so an opaque value still
+ * replays from a seed; see `Types.ts`'s `Produce`. No bare form and no `.as()`
+ * — `produce` is the whole schema.
  */
 export default function <$T>(produce: Produce<$T>): Schema<$T>;

package/dist/types/Primitive/opaque/Schema.d.ts

@@ -2,20 +2,19 @@ import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Core } from "./Types";
 /**
- * Escape hatch for values no kind models — a `Map`, a `Set`, a `URL`, a
- * class instance, a branded type. `produce` is supplied at construction and
- * receives the schema's own seeded stream (`Types.ts`'s `Produce`).
+ * Escape hatch for values no kind models — a `Map`, a `Set`, a `URL`, a class
+ * instance, a branded type. `produce` is supplied at construction and receives
+ * the schema's own seeded stream (`Types.ts`'s `Produce`).
  *
  * No `.as()`, for `always`'s reason: the constructor argument already fully
- * determines production. `adapt` matters more here than for any other kind
- * — an opaque value maps to TypeBox's `Unknown`, which is honest but
- * maximally imprecise, and `.adapt(typebox, ...)` is the only way to say
- * more.
+ * determines production. `adapt` matters more here than for any other kind — an
+ * opaque value maps to TypeBox's `Unknown`, which is honest but maximally
+ * imprecise, and `.adapt(typebox, ...)` is the only way to say more.
  */
 export interface Schema<$T = unknown, $Adaptations extends Adaptations = {}> extends Core<$T, $Adaptations> {
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$T, $Adaptations>>) => $Returnable) => Schema<$T, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

package/dist/types/Primitive/record/Registry.d.ts

@@ -1,17 +1,19 @@
 import type { Produce } from "../../Random/Types";
 import { Schema } from "./Schema";
 import type { Fabricated, Key, Value, Whereby } from "./Types";
-export default function <const $Key extends Key, const $Value extends Value>(key: $Key, value: $Value): {
+type ThisRegistry<$Key extends Key, $Value extends Value> = {
     /**
      * A record of `value` keyed by `key`, attempted `whereby.size` times —
-     * uniformly across `[size.minTried, size.max]` (with `minTried`
-     * defaulting to 0). Colliding keys collapse, so the result holds *at
-     * most* that many entries; see `Types.ts`'s `Whereby`.
+     * uniformly across `[size.minTried, size.max]` (with `minTried` defaulting to
+     * 0). Colliding keys collapse, so the result holds _at most_ that many
+     * entries; see `Types.ts`'s `Whereby`.
      */
     whereby: (whereby: Whereby) => Schema<$Key, $Value>;
     /**
-     * A record whose production is `produce`, in full, instead of drawn
-     * entry by entry.
+     * A record whose production is `produce`, in full, instead of drawn entry by
+     * entry.
      */
     as: (produce: Produce<Fabricated<$Key, $Value>>) => Schema<$Key, $Value>;
 };
+export default function <const $Key extends Key, const $Value extends Value>(key: $Key, value: $Value): ThisRegistry<$Key, $Value>;
+export {};

package/dist/types/Primitive/record/Schema.d.ts

@@ -3,24 +3,22 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Key, Value } from "./Types";
 /**
- * The buildable recipe for a `record`: a key Schema and a value Schema,
- * drawn `whereby.size` times. `array`'s sibling — one repeated value shape
- * and a fuzzed count — but keyed rather than indexed.
+ * The buildable recipe for a `record`: a key Schema and a value Schema, drawn
+ * `whereby.size` times. `array`'s sibling — one repeated value shape and a
+ * fuzzed count — but keyed rather than indexed.
  */
 export interface Schema<$Key extends Key = Key, $Value extends Value = Value, $Adaptations extends Adaptations = {}> extends Core<$Key, $Value, $Adaptations> {
     /**
      * Layer an opaque production on this schema's existing `[Meta]` — carrying
-     * `whereby`/`key`/`value` forward, not discarding them, so a later
-     * `.as(...)` (or future validation of `produce`) still has them to check
-     * against.
+     * `whereby`/`key`/`value` forward, not discarding them, so a later `.as(...)`
+     * (or future validation of `produce`) still has them to check against.
      */
     as: (produce: Produce<Fabricated<$Key, $Value>>) => Schema<$Key, $Value, $Adaptations>;
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt`. Particularly relevant
-     * here: a symbol-keyed record has no TypeBox counterpart
-     * (`Adapter/TypeBox`'s `record` case), so this is the only way to give
-     * one a mapping.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt`. Particularly relevant here: a
+     * symbol-keyed record has no TypeBox counterpart (`Adapter/TypeBox`'s
+     * `record` case), so this is the only way to give one a mapping.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Key, $Value, $Adaptations>>) => $Returnable) => Schema<$Key, $Value, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

package/dist/types/Primitive/record/Types.d.ts

@@ -5,37 +5,37 @@ import { Produces, type Adaptation, type Kind, type Meta } from "../../Types";
 /**
  * A Schema usable as a record's keys: any Schema whose fabricated value is a
  * legal JS property key. Constrained through the phantom `[Produces]` marker
- * rather than by enumerating kinds, so any current or future key-producing
- * kind qualifies — `T.string.whereby(...)`, `T.symbol`,
- * `T.enum.uniform([...])` of strings, `T.always("k")`, a string `T.choice` —
- * while `T.number`/`T.date` are rejected at the call site.
+ * rather than by enumerating kinds, so any current or future key-producing kind
+ * qualifies — `T.string.whereby(...)`, `T.symbol`, `T.enum.uniform([...])` of
+ * strings, `T.always("k")`, a string `T.choice` — while `T.number`/`T.date` are
+ * rejected at the call site.
  *
- * `symbol` is included deliberately: symbols are legal property keys.
- * Excluding them would arbitrarily narrow what a record can describe. They
- * do not survive `Adapter/TypeBox` — see its `record` case.
+ * `symbol` is included deliberately: symbols are legal property keys. Excluding
+ * them would arbitrarily narrow what a record can describe. They do not survive
+ * `Adapter/TypeBox` — see its `record` case.
  */
 export type Key = AnySchema & {
     readonly [Produces]?: string | symbol;
 };
 export type Value = AnySchema;
 /**
- * Whether a key type spans a whole primitive key type rather than a finite
- * set of literals — i.e. whether the record's keyspace is open-ended.
+ * Whether a key type spans a whole primitive key type rather than a finite set
+ * of literals — i.e. whether the record's keyspace is open-ended.
  */
 type IsKeyspaceOpen<$Key> = string extends $Key ? true : symbol extends $Key ? true : false;
 /**
- * Split is *open keyspace vs. finite*, not string vs. symbol.
+ * Split is _open keyspace vs. finite_, not string vs. symbol.
  *
  * An open key (`string`, `symbol`, or both) is a plain index signature: no
  * `Partial` — an index signature never guarantees a key is present, and
  * wrapping one would only add a spurious `| undefined`. Carrying
- * `ValueOf<$Key>` rather than hardcoding `string` keeps a mixed
- * `string | symbol` key as `Record<string | symbol, ...>` instead of
- * silently dropping the symbol half.
+ * `ValueOf<$Key>` rather than hardcoding `string` keeps a mixed `string |
+ * symbol` key as `Record<string | symbol, ...>` instead of silently dropping
+ * the symbol half.
  *
  * A finite literal key set (`enum`/`always`/`choice`) is `Partial`: size is
- * drawn from `whereby.size`, and colliding keys collapse (`Fabricator.ts`),
- * so a two-member key schema may produce only one. Every key present wants
+ * drawn from `whereby.size`, and colliding keys collapse (`Fabricator.ts`), so
+ * a two-member key schema may produce only one. Every key present wants
  * `T.object({ ... })` — what a record over a finite key set degenerates to.
  */
 export type Fabricated<$Key extends Key = Key, $Value extends Value = Value, $Bindings extends unknown[] = []> = IsKeyspaceOpen<ValueOf<$Key, $Bindings>> extends true ? Record<ValueOf<$Key, $Bindings> & PropertyKey, ValueOf<$Value, $Bindings>> : Partial<Record<ValueOf<$Key, $Bindings> & PropertyKey, ValueOf<$Value, $Bindings>>>;
@@ -43,13 +43,13 @@ export type Fabricated<$Key extends Key = Key, $Value extends Value = Value, $Bi
  * How many entries to attempt, uniformly across `[minTried, max]`.
  *
  * Asymmetric naming is the point. Colliding keys collapse rather than being
- * redrawn, so surviving count is only ever *at most* what was attempted:
- * `max` is a real upper bound; the lower bound is not guaranteed and the
- * field says so. `minTried` is optional, default `0`, matching
- * `string`'s `whereby.length.min`.
+ * redrawn, so surviving count is only ever _at most_ what was attempted: `max`
+ * is a real upper bound; the lower bound is not guaranteed and the field says
+ * so. `minTried` is optional, default `0`, matching `string`'s
+ * `whereby.length.min`.
  *
- * No bare-number form (unlike `array`'s `length`): "exactly N" is a promise
- * a collapsing key set cannot keep.
+ * No bare-number form (unlike `array`'s `length`): "exactly N" is a promise a
+ * collapsing key set cannot keep.
  */
 export type Whereby = {
     size: {
@@ -59,10 +59,10 @@ export type Whereby = {
 };
 /**
  * `key`/`value` stay required regardless of `produce` — both are known at
- * `T.record(...)` call time and describe the shape TypeBox derives either
- * way. `produce` is carried *alongside* `whereby` rather than replacing it,
- * so a prior size spec survives `as` for future validation — same as
- * `array`'s `Meta`.
+ * `T.record(...)` call time and describe the shape TypeBox derives either way.
+ * `produce` is carried _alongside_ `whereby` rather than replacing it, so a
+ * prior size spec survives `as` for future validation — same as `array`'s
+ * `Meta`.
  */
 export type Meta<$Key extends Key = Key, $Value extends Value = Value> = {
     key: $Key;

package/dist/types/Primitive/recursive/Fabricator.d.ts

@@ -21,27 +21,26 @@ export type Fabricator<$Schema extends {
 /**
  * Expansion is lazy — one dispatch per `self` at fabricate time, not unrolled
  * to `depth.max` at build. This is the only place dispatch (assigning a node
- * its private stream) happens *inside* `fabricate()`, not at
- * `new Fabricator(...)`. Safe because of isolation, not memoization: every
- * other kind's dispatch count is a function of schema shape, so structural
- * path keying already identifies it. A recursive node's count is
- * data-dependent — how deep this `fabricate()` goes — so no structural path
- * distinguishes sibling expansions at the same depth (an `array` of three
- * `self` children calls `fabricateAt` three times on one shared element
- * Fabricator; the schema does not tell them apart). Each expansion gets its
- * own *root*: `forkSource` mints an isolated `RandomSource` seeded from this
- * node's draw, and each `fabricateAt` opens a `"counted"` scope on it
- * (`Random/Types.ts`'s `RootKind` — recorded on each expansion's
- * `trace`, not chosen at `ConstructorOptions`). The
- * private source's construction counter orders expansions; nothing to
+ * its private stream) happens _inside_ `fabricate()`, not at `new
+ * Fabricator(...)`. Safe because of isolation, not memoization: every other
+ * kind's dispatch count is a function of schema shape, so structural path
+ * keying already identifies it. A recursive node's count is data-dependent —
+ * how deep this `fabricate()` goes — so no structural path distinguishes
+ * sibling expansions at the same depth (an `array` of three `self` children
+ * calls `fabricateAt` three times on one shared element Fabricator; the schema
+ * does not tell them apart). Each expansion gets its own _root_: `forkSource`
+ * mints an isolated `RandomSource` seeded from this node's draw, and each
+ * `fabricateAt` opens a `"counted"` scope on it (`Random/Types.ts`'s `RootKind`
+ * — recorded on each expansion's `trace`, not chosen at `ConstructorOptions`).
+ * The private source's construction counter orders expansions; nothing to
  * increment here. Isolation also keeps this node's data-dependent draws from
  * perturbing (or being perturbed by) an unrelated Fabricator from the same
  * `initialize()` instance.
  *
  * Each `self` gets its own independently-dispatched expansion — calling
- * `context.self` twice (two array slots) is two `fabricateAt` calls, each
- * with its own scope and stream space — `tuple`'s per-slot convention, not
- * `array`'s shared-element one. Sibling tree branches therefore draw
- * independently, not a correlated shared sequence.
+ * `context.self` twice (two array slots) is two `fabricateAt` calls, each with
+ * its own scope and stream space — `tuple`'s per-slot convention, not `array`'s
+ * shared-element one. Sibling tree branches therefore draw independently, not a
+ * correlated shared sequence.
  */
 export declare function Fabricator<$Body>(context: FabricatorContext<Schema<$Body>>, forkSource: (seed: string) => RandomSource, make: (schema: unknown, path: ReadonlyArray<string>, context: ConstructionContext) => NaiveFabricator<unknown>): Fabricator<Schema<$Body>>;

package/dist/types/Primitive/recursive/Registry.d.ts

@@ -9,13 +9,12 @@ import type { Whereby } from "./Types";
  *
  * `body` is called exactly once, here, with a single freshly-minted `self`
  * placeholder — eagerly, the same timing `array`/`record` normalize their
- * nested definitions at call time, not deferred to `.whereby()`. Every
- * `self` in the returned schema is this same placeholder;
- * `Constructor.ts`'s `make` matches it only by `[Kind]`, never by identity,
- * so a `self` captured out of its callback and reused elsewhere silently
- * resolves against whichever recursion is currently active rather than
- * erroring — a misuse this library doesn't guard, the same way passing the
- * wrong schema object elsewhere isn't.
+ * nested definitions at call time, not deferred to `.whereby()`. Every `self`
+ * in the returned schema is this same placeholder; `Constructor.ts`'s `make`
+ * matches it only by `[Kind]`, never by identity, so a `self` captured out of
+ * its callback and reused elsewhere silently resolves against whichever
+ * recursion is currently active rather than erroring — a misuse this library
+ * doesn't guard, the same way passing the wrong schema object elsewhere isn't.
  */
 export default function <const $Body extends AnySchema>(body: (self: SelfSchema) => $Body): {
     whereby(config: Whereby<$Body>): Schema<$Body>;

package/dist/types/Primitive/recursive/Schema.d.ts

@@ -2,19 +2,19 @@ import { type AdaptationEntry } from "../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
 import type { Core } from "./Types";
 /**
- * A recursive schema, produced by `.whereby({ depth })` — see
- * `Registry.ts` for the builder `T.recursive(body)` itself returns.
- * `terminal` is optional there; omitted, it is derived from `body`.
+ * A recursive schema, produced by `.whereby({ depth })` — see `Registry.ts` for
+ * the builder `T.recursive(body)` itself returns. `terminal` is optional there;
+ * omitted, it is derived from `body`.
  *
  * No `.as()`, unlike `array`/`record`: a fully custom whole-value producer
- * would need to be reproducible per depth on its own terms, which is
- * exactly the problem `depth`/`terminal` already solve — deferred rather
- * than ruled out, since adding it later is non-breaking.
+ * would need to be reproducible per depth on its own terms, which is exactly
+ * the problem `depth`/`terminal` already solve — deferred rather than ruled
+ * out, since adding it later is non-breaking.
  */
 export interface Schema<$Body = unknown, $Adaptations extends Adaptations = {}> extends Core<$Body, $Adaptations> {
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Body, $Adaptations>>) => $Returnable) => Schema<$Body, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

package/dist/types/Primitive/recursive/Terminate.d.ts

@@ -1,20 +1,19 @@
 import type { AnySchema } from "../../Schema/Types";
 /**
- * Derive the schema that `fabricateAt` swaps in at `depth.max` when the
- * caller omits `terminal`. Walks `body` and rewrites every `self` site
- * into a declining state so the result contains *no* `recursive.self`
- * nodes — `Constructor.ts`'s `make` still dispatches nested schemas
- * eagerly, and `recursive.self` throws when `context.self` is missing
- * (which it is, at the ceiling).
+ * Derive the schema that `fabricateAt` swaps in at `depth.max` when the caller
+ * omits `terminal`. Walks `body` and rewrites every `self` site into a
+ * declining state so the result contains _no_ `recursive.self` nodes —
+ * `Constructor.ts`'s `make` still dispatches nested schemas eagerly, and
+ * `recursive.self` throws when `context.self` is missing (which it is, at the
+ * ceiling).
  *
- * Empty collections are `opaque(() => [])` / `opaque(() => ({}))`,
- * never `always([])`: each leaf must get its own reference (see
- * `Recursive.test.ts`). Presence wrappers become a self-free schema
- * that always declines (`null` / `undefined` / `Omitted`), rather than
- * keeping the inner `self` behind a produce short-circuit — `make`
- * would still construct that inner node.
+ * Empty collections are `opaque(() => [])` / `opaque(() => ({}))`, never
+ * `always([])`: each leaf must get its own reference (see `Recursive.test.ts`).
+ * Presence wrappers become a self-free schema that always declines (`null` /
+ * `undefined` / `Omitted`), rather than keeping the inner `self` behind a
+ * produce short-circuit — `make` would still construct that inner node.
  *
- * Nested `T.recursive` is its own fixed point and is treated as a
- * leaf; its inner `self` is not this walk's `self`.
+ * Nested `T.recursive` is its own fixed point and is treated as a leaf; its
+ * inner `self` is not this walk's `self`.
  */
 export declare function terminate(body: AnySchema): AnySchema;

package/dist/types/Primitive/recursive/Types.d.ts

@@ -3,11 +3,11 @@ import type { AnySchema, ValueOf } from "../../Schema/Types";
 import { Produces, type Adaptation, type Kind, type Meta } from "../../Types";
 /**
  * Fixed point of a recursive schema. A self-referential alias, normally
- * `TS2456` ("`RecursiveValue` circularly references itself") — legal *only*
+ * `TS2456` ("`RecursiveValue` circularly references itself") — legal _only_
  * because `ValueOf`'s second argument is read through an interface member
- * (`this["bindings"]` on every composite `Core`), which TypeScript defers.
- * Do not rewrite as a conditional; that reintroduces the error. See
- * `CLAUDE.md`'s "`ValueOf`'s `$Bindings`".
+ * (`this["bindings"]` on every composite `Core`), which TypeScript defers. Do
+ * not rewrite as a conditional; that reintroduces the error. See `CLAUDE.md`'s
+ * "`ValueOf`'s `$Bindings`".
  *
  * Wherever `self` sits in `$Body` (nested through `array`/`object`/`tuple`/
  * etc., each forwarding `this["bindings"]`), it reads `bindings[0]` —
@@ -19,33 +19,33 @@ export type Fabricated<$Body> = RecursiveValue<$Body>;
  * `terminal` is what `self` expands into at `depth.max`, in place of `body`.
  * Expansion is lazy (per `self`, at fabricate time) — see `Fabricator.ts`.
  *
- * Constraining `terminal` against `RecursiveValue<$Body>` as a plain field
- * type (not `terminal`'s own type parameter) is enough: structural
- * assignability already rejects a wrong terminal (e.g. missing a required
- * field `body` has), and nothing downstream needs `terminal`'s precise type
- * (`Core`'s `[Produces]` depends only on `$Body`). A bare-vs-generic
- * comparison rejects the same wrong terminal either way.
+ * Constraining `terminal` against `RecursiveValue<$Body>` as a plain field type
+ * (not `terminal`'s own type parameter) is enough: structural assignability
+ * already rejects a wrong terminal (e.g. missing a required field `body` has),
+ * and nothing downstream needs `terminal`'s precise type (`Core`'s `[Produces]`
+ * depends only on `$Body`). A bare-vs-generic comparison rejects the same wrong
+ * terminal either way.
  *
  * Omitted, `terminal` is derived from `body` (`Terminate.ts`): every `self`
  * behind a declining kind is rewritten into a stop (empty array/record,
- * remaining non-`self` choice arms, `null`/`undefined`/`Omitted`). A
- * required `self` cannot be derived — `.whereby()` throws
- * `UnterminableRecursiveError`, and an explicit `terminal` is the way out.
- * A provided `terminal` is a wholesale override of that derivation (custom
- * leaf values, a narrower JSON leaf), not a patch of `self` sites.
+ * remaining non-`self` choice arms, `null`/`undefined`/`Omitted`). A required
+ * `self` cannot be derived — `.whereby()` throws `UnterminableRecursiveError`,
+ * and an explicit `terminal` is the way out. A provided `terminal` is a
+ * wholesale override of that derivation (custom leaf values, a narrower JSON
+ * leaf), not a patch of `self` sites.
  *
- * `depth.max` is a ceiling, not a target: `fabricateAt` (`Fabricator.ts`)
- * only *compares* a counter against it, never draws one — unlike
- * `array`/`record`/`string`'s `{min, max}`, there is no drawn count for a
- * `min` to constrain. Realized depth is emergent: intervening kinds decline
- * to recurse (an `array`/`record` rolling 0, a `choice` picking a non-`self`
+ * `depth.max` is a ceiling, not a target: `fabricateAt` (`Fabricator.ts`) only
+ * _compares_ a counter against it, never draws one — unlike
+ * `array`/`record`/`string`'s `{min, max}`, there is no drawn count for a `min`
+ * to constrain. Realized depth is emergent: intervening kinds decline to
+ * recurse (an `array`/`record` rolling 0, a `choice` picking a non-`self`
  * option, an `omittable`/`optional`/`undefinable` resolving absent). The
- * recursive node has no say. "Force `body` while `depth` is below some
- * `min`" is a no-op: that already happens below `depth.max`. A genuine floor
- * would coerce those intervening kinds' draws — a different feature than a
- * second number here. The derived terminal may empty a collection whose
- * `body` said `length.min > 0`: the ceiling has to stop somehow, and an
- * explicit `terminal` already did the same with `T.opaque(() => [])`.
+ * recursive node has no say. "Force `body` while `depth` is below some `min`"
+ * is a no-op: that already happens below `depth.max`. A genuine floor would
+ * coerce those intervening kinds' draws — a different feature than a second
+ * number here. The derived terminal may empty a collection whose `body` said
+ * `length.min > 0`: the ceiling has to stop somehow, and an explicit `terminal`
+ * already did the same with `T.opaque(() => [])`.
  */
 export type Whereby<$Body> = {
     depth: {
@@ -68,11 +68,11 @@ export type Meta<$Body = unknown> = {
     terminal: AnySchema;
 };
 /**
- * A `type` alias, not an `interface` — unlike every composite that *contains*
- * a `self`, `recursive` is where the fixed point *closes*, so `[Produces]`
- * never needs `this["bindings"]`: `RecursiveValue` is already concrete once
- * `$Body` is, regardless of bindings this schema sits inside (a nested
- * `T.recursive` is its own independent fixed point).
+ * A `type` alias, not an `interface` — unlike every composite that _contains_ a
+ * `self`, `recursive` is where the fixed point _closes_, so `[Produces]` never
+ * needs `this["bindings"]`: `RecursiveValue` is already concrete once `$Body`
+ * is, regardless of bindings this schema sits inside (a nested `T.recursive` is
+ * its own independent fixed point).
  */
 export type Core<$Body = unknown, $Adaptations extends Adaptations = {}> = {
     [Kind]: "recursive";

package/dist/types/Primitive/recursive/self/Fabricator.d.ts

@@ -6,9 +6,8 @@ import type { Fabricated, Meta as ThisMeta } from "./Types";
 export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Bindings> ? $Bindings[0] : never;
 /**
  * Deliberately not parameterized by a Schema the way every other kind's
- * Fabricator type is — `self` carries no config to read a shape from
- * (`[Meta]` is always `{}`), only whatever `$Bindings` its position resolves
- * against.
+ * Fabricator type is — `self` carries no config to read a shape from (`[Meta]`
+ * is always `{}`), only whatever `$Bindings` its position resolves against.
  */
 export type Fabricator<$Bindings extends unknown[] = []> = NaiveFabricator<Fabricated<$Bindings>> & {
     [Kind]: "recursive.self";
@@ -16,14 +15,14 @@ export type Fabricator<$Bindings extends unknown[] = []> = NaiveFabricator<Fabri
     readonly trace: Trace;
 };
 /**
- * A transient passthrough, unlike every other kind's Fabricator — it draws
- * no randomness of its own: a `self` node stands for wherever
- * `T.recursive`'s current expansion is, and `resolve` *is* that expansion,
- * one level deeper — the same closure `recursive/Fabricator.ts` hands to
- * every `self` in its body via `Constructor.ts`'s `make` context (`case
- * "recursive.self"`). Calling `resolve` is what actually recurses; this
- * function only wraps it in the shape `make` expects back. Absent
- * `resolve` (a `self` rebuilt from its schema plus trace, without the
- * enclosing recursive parent), `.fabricate()` throws `DetachedSelfError`.
+ * A transient passthrough, unlike every other kind's Fabricator — it draws no
+ * randomness of its own: a `self` node stands for wherever `T.recursive`'s
+ * current expansion is, and `resolve` _is_ that expansion, one level deeper —
+ * the same closure `recursive/Fabricator.ts` hands to every `self` in its body
+ * via `Constructor.ts`'s `make` context (`case "recursive.self"`). Calling
+ * `resolve` is what actually recurses; this function only wraps it in the shape
+ * `make` expects back. Absent `resolve` (a `self` rebuilt from its schema plus
+ * trace, without the enclosing recursive parent), `.fabricate()` throws
+ * `DetachedSelfError`.
  */
 export declare function Fabricator<$Bindings extends unknown[]>(context: FabricatorContext<Schema>, resolve?: (() => Fabricated<$Bindings>) | undefined): Fabricator<$Bindings>;

package/dist/types/Primitive/recursive/self/Schema.d.ts

@@ -2,17 +2,17 @@ import { type AdaptationEntry } from "../../../Adapter/Core";
 import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../../Adapter/Types";
 import type { Core } from "./Types";
 /**
- * The placeholder `T.recursive`'s body callback receives in place of the
- * schema being defined — everywhere `self` appears, it stands for "recurse
- * one level deeper here." Never constructed directly: `T.recursive` is the
- * only thing that mints one, and only ever hands it to its own callback, so
- * there is no bare `T.self`.
+ * The placeholder `T.recursive`'s body callback receives in place of the schema
+ * being defined — everywhere `self` appears, it stands for "recurse one level
+ * deeper here." Never constructed directly: `T.recursive` is the only thing
+ * that mints one, and only ever hands it to its own callback, so there is no
+ * bare `T.self`.
  *
- * No `.as()` — unlike `always`, not because there's nothing left to
- * override, but because there is nothing here *to* produce: a `self` node
- * carries no value of its own, only a reference to whatever the enclosing
- * recursion currently binds it to. `adapt` still applies, on the same
- * footing as every other kind.
+ * No `.as()` — unlike `always`, not because there's nothing left to override,
+ * but because there is nothing here _to_ produce: a `self` node carries no
+ * value of its own, only a reference to whatever the enclosing recursion
+ * currently binds it to. `adapt` still applies, on the same footing as every
+ * other kind.
  */
 export interface Schema<$Adaptations extends Adaptations = {}> extends Core<$Adaptations> {
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Adaptations>>) => $Returnable) => Schema<WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;