@ghostry/fabricator 0.0.1

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

@@ -0,0 +1,72 @@
+import type { Adaptations } from "../../../Adapter/Types";
+import type { Produce } from "../../../Random/Types";
+import type { AnySchema, ValueOf } from "../../../Schema/Types";
+import { Kind, Meta, Omitted, type Adaptation, type Produces } from "../../../Types";
+/**
+ * The wrapped field's Schema — the value type when the roll is
+ * present-with-a-value.
+ */
+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`.
+ */
+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.
+ */
+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()`
+ * (`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.
+ */
+export type Weights = {
+    omitted: number;
+    undefined?: number | undefined;
+    value?: number | undefined;
+} | {
+    omitted?: number | undefined;
+    undefined: number;
+    value?: number | undefined;
+} | {
+    omitted?: number | undefined;
+    undefined?: number | undefined;
+    value: number;
+};
+/**
+ * `definition` stays required regardless of `produce` — an opaque `as`
+ * production layers on top rather than replacing it, so a prior definition
+ * survives `as` for future validation of `produce` (and so `ToTypeBox`'s
+ * structural derivation of the wrapped shape keeps working either way).
+ */
+export type Meta<$Definition extends Definition = Definition> = {
+    definition: $Definition;
+    produce?: Produce<Resolved<$Definition>>;
+    weights?: Weights;
+};
+export interface Core<$Definition extends Definition = Definition, $Adaptations extends Adaptations = {}> {
+    [Kind]: "object.optional";
+    [Meta]: Meta<$Definition>;
+    bindings?: unknown[];
+    readonly [Produces]?: Fabricated<$Definition, NonNullable<this["bindings"]>>;
+    readonly [Adaptation]?: $Adaptations;
+}

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

@@ -0,0 +1,6 @@
+export * from "./Fabricator";
+export * from "./Outcomes";
+export * from "./Registry";
+export { default } from "./Registry";
+export * from "./Schema";
+export * from "./Types";

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

@@ -0,0 +1,19 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { FabricatorContext, NaiveFabricator } from "../../Fabricator/Types";
+import type { Trace } from "../../Random/Types";
+import { Kind, Meta, type Adaptation } from "../../Types";
+import { Schema } from "./Schema";
+import type { Fabricated, Meta as ThisMeta } from "./Types";
+export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Schema> ? $Schema[typeof Meta] extends ThisMeta<infer $T> ? Fabricated<$T> : never : never;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta<any>;
+} = {
+    [Meta]: ThisMeta;
+}> = NaiveFabricator<$Schema[typeof Meta] extends ThisMeta<infer $T> ? Fabricated<$T> : never> & {
+    [Kind]: "opaque";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: $Schema[typeof Meta] extends ThisMeta<infer $T> ? Schema<$T, AdaptationsOf<$Schema>> : never;
+};
+export declare function Fabricator<$T>(context: FabricatorContext<Schema<$T>>): Fabricator<Schema<$T>>;

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

@@ -0,0 +1,12 @@
+import type { Produce } from "../../Random/Types";
+import { Schema } from "./Schema";
+/**
+ * A value this library has no kind for — a `Map`, a `Set`, a `URL`, a class
+ * 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.
+ */
+export default function <$T>(produce: Produce<$T>): Schema<$T>;

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

@@ -0,0 +1,22 @@
+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`).
+ *
+ * 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.
+ */
+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.
+     */
+    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>>>;
+}
+export declare function Schema<$T, $Adaptations extends Adaptations = {}>(schema: Core<$T, $Adaptations>): Schema<$T, $Adaptations>;

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

@@ -0,0 +1,18 @@
+import type { Adaptations } from "../../Adapter/Types";
+import type { Produce } from "../../Random/Types";
+import { Produces, type Adaptation, type Kind, type Meta } from "../../Types";
+export type Fabricated<$T> = $T;
+/**
+ * A single required member, unlike the two-arm unions kinds with a `whereby`
+ * carry: there is no configuration for an opaque value to layer `produce` on
+ * top of — `produce` is the entire schema.
+ */
+export type Meta<$T = unknown> = {
+    produce: Produce<$T>;
+};
+export type Core<$T = unknown, $Adaptations extends Adaptations = {}> = {
+    [Kind]: "opaque";
+    [Meta]: Meta<$T>;
+    readonly [Produces]?: Fabricated<$T>;
+    readonly [Adaptation]?: $Adaptations;
+};

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

@@ -0,0 +1,5 @@
+export * from "./Types";
+export * from "./Schema";
+export * from "./Fabricator";
+export * from "./Registry";
+export { default } from "./Registry";

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

@@ -0,0 +1,25 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { FabricatorContext, NaiveFabricator } from "../../Fabricator/Types";
+import type { Trace } from "../../Random/Types";
+import { Children, Kind, Meta, type Adaptation } from "../../Types";
+import { Schema } from "./Schema";
+import type { Fabricated, Key, Meta as ThisMeta, Value } from "./Types";
+export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Schema extends {
+    [Meta]: ThisMeta;
+}> ? Fabricated<$Schema[typeof Meta]["key"], $Schema[typeof Meta]["value"]> : never;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = NaiveFabricator<Fabricated<$Schema[typeof Meta]["key"], $Schema[typeof Meta]["value"]>> & {
+    [Kind]: "record";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    [Children]: {
+        key: NaiveFabricator<any>;
+        value: NaiveFabricator<any>;
+    };
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<$Schema[typeof Meta]["key"], $Schema[typeof Meta]["value"], AdaptationsOf<$Schema>>;
+};
+export declare function Fabricator<$Key extends Key, $Value extends Value>(context: FabricatorContext<Schema<$Key, $Value>>, key: NaiveFabricator<any>, value: NaiveFabricator<any>): Fabricator<Schema<$Key, $Value>>;

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

@@ -0,0 +1,17 @@
+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): {
+    /**
+     * 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`.
+     */
+    whereby: (whereby: Whereby) => Schema<$Key, $Value>;
+    /**
+     * A record whose production is `produce`, in full, instead of drawn
+     * entry by entry.
+     */
+    as: (produce: Produce<Fabricated<$Key, $Value>>) => Schema<$Key, $Value>;
+};

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

@@ -0,0 +1,27 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+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.
+ */
+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.
+     */
+    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.
+     */
+    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>>>;
+}
+export declare function Schema<$Key extends Key, $Value extends Value, $Adaptations extends Adaptations = {}>(schema: Core<$Key, $Value, $Adaptations>): Schema<$Key, $Value, $Adaptations>;

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

@@ -0,0 +1,85 @@
+import type { Adaptations } from "../../Adapter/Types";
+import type { Produce } from "../../Random/Types";
+import type { AnySchema, ValueOf } from "../../Schema/Types";
+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.
+ *
+ * `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.
+ */
+type IsKeyspaceOpen<$Key> = string extends $Key ? true : symbol extends $Key ? true : false;
+/**
+ * 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.
+ *
+ * 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
+ * `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>>>;
+/**
+ * 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`.
+ *
+ * No bare-number form (unlike `array`'s `length`): "exactly N" is a promise
+ * a collapsing key set cannot keep.
+ */
+export type Whereby = {
+    size: {
+        max: number;
+        minTried?: number | undefined;
+    };
+};
+/**
+ * `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`.
+ */
+export type Meta<$Key extends Key = Key, $Value extends Value = Value> = {
+    key: $Key;
+    value: $Value;
+    whereby: Whereby;
+    produce?: never;
+} | {
+    key: $Key;
+    value: $Value;
+    whereby?: Whereby;
+    produce: Produce<Fabricated<$Key, $Value>>;
+};
+export interface Core<$Key extends Key = Key, $Value extends Value = Value, $Adaptations extends Adaptations = {}> {
+    [Kind]: "record";
+    [Meta]: Meta<$Key, $Value>;
+    bindings?: unknown[];
+    readonly [Produces]?: Fabricated<$Key, $Value, NonNullable<this["bindings"]>>;
+    readonly [Adaptation]?: $Adaptations;
+}
+export {};

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

@@ -0,0 +1,5 @@
+export * from "./Types";
+export * from "./Schema";
+export * from "./Fabricator";
+export * from "./Registry";
+export { default } from "./Registry";

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

@@ -0,0 +1,47 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { ConstructionContext, FabricatorContext, NaiveFabricator } from "../../Fabricator/Types";
+import type { RandomSource, Trace } from "../../Random/Types";
+import { Kind, Meta, type Adaptation } from "../../Types";
+import { Schema } from "./Schema";
+import type { Fabricated, Meta as ThisMeta } from "./Types";
+export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Schema extends {
+    [Meta]: ThisMeta;
+}> ? Fabricated<$Schema[typeof Meta]["body"]> : never;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = NaiveFabricator<Fabricated<$Schema[typeof Meta]["body"]>> & {
+    [Kind]: "recursive";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<$Schema[typeof Meta]["body"], AdaptationsOf<$Schema>>;
+};
+/**
+ * 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
+ * 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.
+ */
+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

@@ -0,0 +1,22 @@
+import type { AnySchema } from "../../Schema/Types";
+import { type Schema as SelfSchema } from "./self";
+import { Schema } from "./Schema";
+import type { Whereby } from "./Types";
+/**
+ * `T.recursive(body)` — a builder, not a Schema, matching `array`/`record`:
+ * `.whereby({ depth })` is what produces one; no bare form. `terminal` is
+ * optional: omitted, it is derived from `body` (`Terminate.ts`).
+ *
+ * `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.
+ */
+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

@@ -0,0 +1,21 @@
+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`.
+ *
+ * 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.
+ */
+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.
+     */
+    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>>>;
+}
+export declare function Schema<$Body, $Adaptations extends Adaptations = {}>(schema: Core<$Body, $Adaptations>): Schema<$Body, $Adaptations>;

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

@@ -0,0 +1,20 @@
+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).
+ *
+ * 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`.
+ */
+export declare function terminate(body: AnySchema): AnySchema;

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

@@ -0,0 +1,82 @@
+import type { Adaptations } from "../../Adapter/Types";
+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*
+ * 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`".
+ *
+ * Wherever `self` sits in `$Body` (nested through `array`/`object`/`tuple`/
+ * etc., each forwarding `this["bindings"]`), it reads `bindings[0]` —
+ * `RecursiveValue<$Body>` itself, closing the loop.
+ */
+export type RecursiveValue<$Body> = ValueOf<$Body, [RecursiveValue<$Body>]>;
+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.
+ *
+ * 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.
+ *
+ * `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(() => [])`.
+ */
+export type Whereby<$Body> = {
+    depth: {
+        max: number;
+    };
+    terminal?: (AnySchema & {
+        readonly [Produces]?: RecursiveValue<$Body>;
+    }) | undefined;
+};
+/**
+ * `terminal` is stored as `AnySchema` — once `.whereby(...)` has checked it
+ * against `RecursiveValue<$Body>`, nothing downstream needs its precise type
+ * (unlike `object.compute`'s `source`, which feeds `Resolved<$Source>`).
+ */
+export type Meta<$Body = unknown> = {
+    body: $Body;
+    depth: {
+        max: number;
+    };
+    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).
+ */
+export type Core<$Body = unknown, $Adaptations extends Adaptations = {}> = {
+    [Kind]: "recursive";
+    [Meta]: Meta<$Body>;
+    readonly [Produces]?: Fabricated<$Body>;
+    readonly [Adaptation]?: $Adaptations;
+};

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

@@ -0,0 +1,6 @@
+export * from "./Types";
+export * from "./Schema";
+export * from "./Fabricator";
+export * from "./Registry";
+export { default } from "./Registry";
+export * as self from "./self";

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

@@ -0,0 +1,29 @@
+import type { FabricatorContext, NaiveFabricator } from "../../../Fabricator/Types";
+import type { Trace } from "../../../Random/Types";
+import { Kind, Meta } from "../../../Types";
+import type { Schema } from "./Schema";
+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.
+ */
+export type Fabricator<$Bindings extends unknown[] = []> = NaiveFabricator<Fabricated<$Bindings>> & {
+    [Kind]: "recursive.self";
+    [Meta]: ThisMeta;
+    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`.
+ */
+export declare function Fabricator<$Bindings extends unknown[]>(context: FabricatorContext<Schema>, resolve?: (() => Fabricated<$Bindings>) | undefined): Fabricator<$Bindings>;

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

@@ -0,0 +1,7 @@
+import { Schema } from "./Schema";
+/**
+ * Mints a fresh `self` placeholder — called only from `recursive/Registry.ts`
+ * to hand one to `T.recursive`'s own body callback. Not exposed as `T.self`,
+ * the same standing as `object.compute`'s own internal-only factory.
+ */
+export default function (): Schema;

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

@@ -0,0 +1,20 @@
+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`.
+ *
+ * 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>>>;
+}
+export declare function Schema<$Adaptations extends Adaptations = {}>(schema: Core<$Adaptations>): Schema<$Adaptations>;

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

@@ -0,0 +1,28 @@
+import type { Adaptations } from "../../../Adapter/Types";
+import { Produces, type Adaptation, type Kind, type Meta } from "../../../Types";
+/**
+ * The value a `self` reference resolves to at this position — whatever the
+ * enclosing `T.recursive`'s current expansion binds it to. Reads
+ * `bindings[0]`, the analogue of TypeBox's `TThis` reading
+ * `this['params'][0]`; see `Schema/Types.ts`'s `ValueOf` for what
+ * `bindings` is and why it's a tuple.
+ *
+ * Unlike every other kind, `self` has no type parameter of its own — its
+ * whole value comes from outside, threaded in structurally by whatever
+ * composite kinds wrap it (`recursive/Types.ts`'s `RecursiveValue` is what
+ * ultimately supplies `bindings[0]`).
+ */
+export type Fabricated<$Bindings extends unknown[] = []> = $Bindings[0];
+export type Meta = Record<string, never>;
+/**
+ * An `interface`, not a `type` alias, so `this["bindings"]` resolves — the
+ * entire mechanism this kind exists for. See `CLAUDE.md`'s "`ValueOf`'s
+ * `$Bindings`" section for why threading requires this.
+ */
+export interface Core<$Adaptations extends Adaptations = {}> {
+    [Kind]: "recursive.self";
+    [Meta]: Meta;
+    bindings?: unknown[];
+    readonly [Produces]?: Fabricated<NonNullable<this["bindings"]>>;
+    readonly [Adaptation]?: $Adaptations;
+}

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

@@ -0,0 +1,5 @@
+export * from "./Types";
+export * from "./Schema";
+export * from "./Fabricator";
+export * from "./Registry";
+export { default } from "./Registry";