@ghostry/fabricator 0.0.1 → 0.0.3

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
- * 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.
+ * 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` salted from this node's draw, and each
+ * `fabricateAt` resolves an ordinary construction root on it
+ * (`RandomSource.toRoot`), recorded on each expansion's `trace`. 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>>;
+export declare function Fabricator<$Body>(context: FabricatorContext<Schema<$Body>>, forkSource: (salt: 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>>>;

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

@@ -2,15 +2,14 @@ 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.
+ * 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]`).
+ * 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>;

package/dist/types/Primitive/string/Constants.d.ts

@@ -1,14 +1,13 @@
 import type { CodepointRange } from "./Types";
 /**
- * Unicode code point ranges for spanning the codespace — a fuzzing aid
- * for exercising input far outside ordinary text. Use a preset or build
- * an arbitrary inclusive range with `range(from, to)`.
+ * Unicode code point ranges for spanning the codespace — a fuzzing aid for
+ * exercising input far outside ordinary text. Use a preset or build an
+ * arbitrary inclusive range with `range(from, to)`.
  *
- * Lives here rather than `Types.ts` so that file stays type-only. A
- * value export alongside `export type Fabricated = string` makes the
- * module a value module, and `export * as string` in
- * `Primitive/namespace.ts` then resolves `string` to the namespace —
- * a cycle that drops `[Kind]`/`[Meta]` off `Core`.
+ * Lives here rather than `Types.ts` so that file stays type-only. A value
+ * export alongside `export type Fabricated = string` makes the module a value
+ * module, and `export * as string` in `Primitive/namespace.ts` then resolves
+ * `string` to the namespace — a cycle that drops `[Kind]`/`[Meta]` off `Core`.
  */
 export declare const unicode: {
     /**
@@ -24,8 +23,8 @@ export declare const unicode: {
     }[];
     /**
      * The entire Unicode codespace, U+0000–U+10FFFF, including the surrogate
-     * block — so it can yield lone surrogates and thus ill-formed UTF-16.
-     * Opt in for lone surrogates and other ill-formed UTF-16 when fuzzing.
+     * block — so it can yield lone surrogates and thus ill-formed UTF-16. Opt in
+     * for lone surrogates and other ill-formed UTF-16 when fuzzing.
      */
     codespace: {
         from: number;
@@ -45,9 +44,9 @@ export declare const unicode: {
     range: (from: number, to: number) => CodepointRange;
 };
 /**
- * The built-in character classes as code point ranges, each an alias for
- * the code point ranges it spans. For use in the `[weight, source]` form
- * of `composition` (e.g. mixing a class with a Unicode range).
+ * The built-in character classes as code point ranges, each an alias for the
+ * code point ranges it spans. For use in the `[weight, source]` form of
+ * `composition` (e.g. mixing a class with a Unicode range).
  */
 export declare const classes: {
     lowercase: ReadonlyArray<CodepointRange>;

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

@@ -18,7 +18,7 @@ export type Fabricator<$Schema extends {
 };
 /**
  * Turn a `string` Schema into a live Fabricator — the one place this kind's
- * character-generation logic actually runs. `Constructor.ts` calls this once per
- * `construct()`, never from inside the returned `fabricate`.
+ * character-generation logic actually runs. `Constructor.ts` calls this once
+ * per `construct()`, never from inside the returned `fabricate`.
  */
 export declare function Fabricator(context: FabricatorContext<Schema>): Fabricator;

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

@@ -1,12 +1,12 @@
 import type { Produce } from "../../Random/Types";
 import { Kind } from "../../Types";
 import { Schema } from "./Schema";
-import type { Fabricated, InputWhereby, JsonSchema } from "./Types";
+import type { Fabricated, InputWhereby, JsonSchema, Whereby } from "./Types";
 declare const _default: {
     /**
-     * The builder carries the primitive's `[Kind]` so it can be named directly
-     * as a `compute` source — which derives its schema by kind — without
-     * first satisfying a `whereby`.
+     * The builder carries the primitive's `[Kind]` so it can be named directly as
+     * a `compute` source — which derives its schema by kind — without first
+     * satisfying a `whereby`.
      */
     [Kind]: "string";
     /**
@@ -15,9 +15,9 @@ declare const _default: {
      * (e.g. `toTypeBox`) read.
      */
     as: (produce: Produce<Fabricated>, hints?: JsonSchema) => Schema<{
-        produce: Produce<string>;
+        produce: Produce<Fabricated>;
         hints: JsonSchema | undefined;
-    }, {}>;
+    }>;
     /**
      * A string whose length falls uniformly within `[length.min, length.max]`;
      * `length.min` defaults to inclusive 0. Exclusive ends use a Bound object.
@@ -28,17 +28,11 @@ declare const _default: {
      * `length` counts UTF-16 code units, so the result's `.length` equals the
      * chosen length exactly. When the composition cannot fill the final code
      * units — e.g. only astral, two-unit characters remain for a one-unit gap —
-     * the gap is topped up with a well-formed BMP character outside the
-     * requested `composition`, inserted at a random character boundary.
+     * the gap is topped up with a well-formed BMP character outside the requested
+     * `composition`, inserted at a random character boundary.
      */
     whereby: (whereby: InputWhereby) => Schema<{
-        whereby: {
-            length: {
-                min: import("../..").Bound<number>;
-                max: import("../..").Bound<number>;
-            };
-            composition?: import("./Types").Composition;
-        };
-    }, {}>;
+        whereby: Whereby;
+    }>;
 };
 export default _default;

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

@@ -4,13 +4,13 @@ import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, JsonSchema, Meta as ThisMeta } from "./Types";
 /**
  * Buildable `string` recipe: length/composition (`whereby` — required, unlike
- * `number`/`date`; no natural bound to fuzz a length to), or opaque
- * production via `as`.
+ * `number`/`date`; no natural bound to fuzz a length to), or opaque production
+ * via `as`.
  *
  * `$Meta` is generic (defaulting to the full `Meta` union) so builder return
- * types stay narrow — see `number/Schema.ts`. `$Adaptations` is generic for
- * the same reason, threaded through every builder method so an adaptation
- * survives chaining (see `adapt`).
+ * types stay narrow — see `number/Schema.ts`. `$Adaptations` is generic for the
+ * same reason, threaded through every builder method so an adaptation survives
+ * chaining (see `adapt`).
  */
 export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends Adaptations = {}> extends Core<$Meta, $Adaptations> {
     /**

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

@@ -9,19 +9,19 @@ export type CodepointRange = {
     to: number;
 };
 /**
- * The single mechanism every character is drawn from: one or more code
- * point ranges. A literal string is accepted as shorthand for the ranges
- * of its individual characters, so custom pools, the built-in classes, and
- * the Unicode codespace are all the same thing under the hood.
+ * The single mechanism every character is drawn from: one or more code point
+ * ranges. A literal string is accepted as shorthand for the ranges of its
+ * individual characters, so custom pools, the built-in classes, and the Unicode
+ * codespace are all the same thing under the hood.
  */
 export type CharacterSource = string | CodepointRange | ReadonlyArray<CodepointRange>;
 export type CharacterClass = keyof typeof classes;
 /**
- * How a string's characters should be composed: a weighting over the
- * built-in classes by name, or explicit `[weight, source]` pairs over
- * arbitrary character sources. Each character independently picks a source
- * by weight, then a code point uniformly across that source's ranges — so
- * the weights describe expected composition, not per-character uniformity.
+ * How a string's characters should be composed: a weighting over the built-in
+ * classes by name, or explicit `[weight, source]` pairs over arbitrary
+ * character sources. Each character independently picks a source by weight,
+ * then a code point uniformly across that source's ranges — so the weights
+ * describe expected composition, not per-character uniformity.
  */
 export type Composition = Partial<Record<CharacterClass, number>> | ReadonlyArray<[number, CharacterSource]>;
 export type InputWhereby = {
@@ -41,9 +41,9 @@ export type Whereby = {
 export type Fabricated = string;
 /**
  * JSON-Schema keywords that constrain a string value — carried as neutral,
- * schema-library-agnostic hints (see the builder's `as`). Adapters forward
- * them to their target: `toTypeBox` to `Type.String(...)`, a future `toZod`
- * to `z.string()` refinements, etc.
+ * schema-library-agnostic hints (see the builder's `as`). Adapters forward them
+ * to their target: `toTypeBox` to `Type.String(...)`, a future `toZod` to
+ * `z.string()` refinements, etc.
  *
  * Length lives on `whereby` as Bound pairs, which adapters forward as
  * `minLength`/`maxLength`; `hints` never duplicates it — these are the
@@ -54,11 +54,11 @@ export type JsonSchema = {
     pattern?: string;
 };
 /**
- * A length/composition, drawn via `whereby` — no natural bound to fuzz to,
- * so unlike `number`/`date` there's no bare form — optionally overridden
- * by an opaque `as` production, carried alongside `whereby` rather than
- * replacing it (when `whereby` was already set) so a prior
- * length/composition survives `as` for future validation.
+ * A length/composition, drawn via `whereby` — no natural bound to fuzz to, so
+ * unlike `number`/`date` there's no bare form — optionally overridden by an
+ * opaque `as` production, carried alongside `whereby` rather than replacing it
+ * (when `whereby` was already set) so a prior length/composition survives `as`
+ * for future validation.
  */
 export type Meta = {
     whereby: Whereby;

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

@@ -18,7 +18,7 @@ export type Fabricator<$Schema extends {
 };
 /**
  * A bare symbol draws no randomness at all — `Symbol(meta.key)` is
- * deterministic — so only the `.as(...)`-overridden path ever obtains a
- * stream. The bare path still records `trace`, like every other node.
+ * deterministic — so only the `.as(...)`-overridden path ever obtains a stream.
+ * The bare path still records `trace`, like every other node.
  */
 export declare function Fabricator(context: FabricatorContext<Schema>): Fabricator;