@ghostry/fabricator 0.0.1 → 0.0.2

package/dist/types/Instance/Types.d.ts

@@ -3,25 +3,24 @@ import type { Constructor } from "../Fabricator/Constructor";
 import type { Algorithm, Attribution, Layered, RandomSource, Seed } from "../Random/Types";
 import type { PlainObject } from "../Utility/Types";
 /**
- * A fully resolved instance configuration — every field present, nothing
- * left to default. `Overlay` is what `fork` accepts; `overlay()`
+ * A fully resolved instance configuration — every field present, nothing left
+ * to default. `Overlay` is what `fork` accepts; `overlay()`
  * (`Instance/Core.ts`) is the only thing producing a complete `Config`.
  *
- * Two fields are declared at their caller-facing type but always hold
- * their resolved form once `overlay()` has run: `seed` is `Seed` because
- * that is what a caller may supply, but always holds the normalized
- * array (`Instance.seed` is the authoritative read); `attribution` is
- * `Attribution` for the same reason but always holds a
- * `ResolvedAttribution`, a subtype. `clock` is different from both:
- * unlike `seed`/`attribution`, it holds *either* a resolved instant
- * (epoch milliseconds) or the unresolved `"seeded"` policy — never
- * collapsed to a number by `overlay()` when `"seeded"`, because that
- * policy must re-derive whenever the seed it composes changes (a
- * `fork({ seed: layer(...) })`). The unconfigured default is a wall-
- * clock number, inherited as-is like an explicit `Date`. `resolveClock`
- * (`Instance/Core.ts`) is the one place that resolves `"seeded"` to a
- * number, called fresh wherever the clock actually matters
- * (`instantiate`, the `context.clock` getter) rather than once here.
+ * Two fields are declared at their caller-facing type but always hold their
+ * resolved form once `overlay()` has run: `seed` is `Seed` because that is what
+ * a caller may supply, but always holds the normalized array (`Instance.seed`
+ * is the authoritative read); `attribution` is `Attribution` for the same
+ * reason but always holds a `ResolvedAttribution`, a subtype. `clock` is
+ * different from both: unlike `seed`/`attribution`, it holds _either_ a
+ * resolved instant (epoch milliseconds) or the unresolved `"seeded"` policy —
+ * never collapsed to a number by `overlay()` when `"seeded"`, because that
+ * policy must re-derive whenever the seed it composes changes (a `fork({ seed:
+ * layer(...) })`). The unconfigured default is a wall- clock number, inherited
+ * as-is like an explicit `Date`. `resolveClock` (`Instance/Core.ts`) is the one
+ * place that resolves `"seeded"` to a number, called fresh wherever the clock
+ * actually matters (`instantiate`, the `context.clock` getter) rather than once
+ * here.
  */
 export type Config<$Registry extends PlainObject> = {
     readonly seed: Seed;
@@ -32,54 +31,60 @@ export type Config<$Registry extends PlainObject> = {
     readonly clock: number | "seeded";
 };
 /**
- * What `fork` accepts — a `Config` to lay over a base, every field
- * optional. Identical to `Partial<Config>` but for `seed`, which
- * additionally accepts a {@link Layered}: a bare `Seed` replaces the
- * base's seed outright (what `seed` means everywhere else in this
- * library), `layer(seed)` appends onto it (`[...base.seed, ...seed]`)
- * — the shape a wrapping integration wants, and what
- * `ConstructorOptions`' layered form is for a single construction.
- * Omitting `seed` inherits the base's unchanged. `clock` similarly
- * accepts the caller-facing `Date | "seeded"` rather than `Config`'s
- * own resolved `number | "seeded"`, so a caller can hand in a literal
- * instant without converting it to epoch milliseconds themselves.
- * `"seeded"` is the explicit opt-in that derives "now" from the
- * instance seed; omitting `clock` at the root captures wall-clock time
- * instead.
+ * What `fork` accepts — a `Config` to lay over a base, every field optional.
+ * Identical to `Partial<Config>` but for `seed`, which additionally accepts a
+ * {@link Layered}: a bare `Seed` replaces the base's seed outright (what `seed`
+ * means everywhere else in this library), `layer(seed)` appends onto it
+ * (`[...base.seed, ...seed]`) — the shape a wrapping integration wants, and
+ * what `ConstructorOptions`' layered form is for a single construction.
+ * Omitting `seed` inherits the base's unchanged. `clock` similarly accepts the
+ * caller-facing `Date | "seeded"` rather than `Config`'s own resolved `number |
+ * "seeded"`, so a caller can hand in a literal instant without converting it to
+ * epoch milliseconds themselves. `"seeded"` is the explicit opt-in that derives
+ * "now" from the instance seed; omitting `clock` at the root captures
+ * wall-clock time instead.
  *
  * `initialize`'s own parameter keeps a plain `seed?: Seed`, so passing
- * `layer(...)` there is a compile error: there is no base to layer onto
- * at the root.
+ * `layer(...)` there is a compile error: there is no base to layer onto at the
+ * root.
  */
 export type Overlay<$Registry extends PlainObject> = Partial<Omit<Config<$Registry>, "seed" | "clock">> & {
     readonly seed?: Seed | Layered;
     readonly clock?: Date | "seeded" | undefined;
 };
 /**
- * One active `wrap` — its resolved config plus the single `RandomSource`
- * every build reached inside that `wrap` shares, whether reached
- * implicitly (any instance in the lineage consulting the active frame)
- * or explicitly (`scope.Fabricator`, the `Instance` passed to the
- * block). Storing the scope's own already-built `source` here, rather
- * than each consumer re-deriving one from `config`, keeps the two
- * routes resolving against the *same* source — sharing one set of
- * construction-ordinal counters — instead of each silently starting
- * its own.
+ * One active `wrap` — its resolved config plus the single `RandomSource` every
+ * build reached inside that `wrap` shares, whether reached implicitly (any
+ * instance in the lineage consulting the active frame) or explicitly
+ * (`scope.Fabricator`, the `Instance` passed to the block). Storing the scope's
+ * own already-built `source` here, rather than each consumer re-deriving one
+ * from `config`, keeps the two routes resolving against the _same_ source —
+ * sharing one set of construction-ordinal counters — instead of each silently
+ * starting its own.
  */
 export type Frame = {
     readonly config: Config<PlainObject>;
     readonly source: RandomSource;
 };
 /**
- * The per-lineage ambient stack. Created once at a root `initialize()`
- * and threaded — never re-created — through every `fork`/`wrap`
- * descended from it (see `instantiate`, `Instance/Core.ts`). Two
- * unrelated `initialize()` calls stay fully isolated; one lineage's
- * `wrap` reaches every instance in that lineage — its `Fabricator`,
- * `combinatorial`, and `coverage` alike — regardless of where in the
- * lineage that instance was itself created.
+ * The per-lineage ambient stack. Created once at a root `initialize()` and
+ * threaded — never re-created — through every `fork`/`wrap` descended from it
+ * (see `instantiate`, `Instance/Core.ts`). Two unrelated `initialize()` calls
+ * stay fully isolated; one lineage's `wrap` reaches every instance in that
+ * lineage — its `Fabricator`, `combinatorial`, and `coverage` alike —
+ * regardless of where in the lineage that instance was itself created.
  */
 export type Stack = {
+    /**
+     * Whether a frame survives an `await` inside the block it was entered for.
+     *
+     * `false` means the carrier is a plain LIFO whose frame unwinds at the
+     * block's first suspension point — correct for synchronous use, and the
+     * reason `wrap` (`Instance/Core.ts`) rejects an async block outright rather
+     * than letting a build after the `await` silently resolve against the base
+     * instance. See `Instance/Stack/Sync.ts` and `Instance/Stack/Async.ts`.
+     */
+    readonly asynchronous: boolean;
     current(): Frame | undefined;
     /**
      * Push `frame`, run `block`, pop — in a `finally`, so a frame unwinds
@@ -88,11 +93,11 @@ export type Stack = {
     enter<$Return>(frame: Frame, block: () => $Return): $Return;
 };
 /**
- * The configuration in effect *right now* — the innermost active `wrap`
- * frame, or this instance's own when there is none. Distinct from
- * `ConstructionContext` (`Fabricator/Types.ts`), which is one
- * construction's internal dispatch plumbing; this is the caller-facing
- * "what configuration is in effect."
+ * The configuration in effect _right now_ — the innermost active `wrap` frame,
+ * or this instance's own when there is none. Distinct from
+ * `ConstructionContext` (`Fabricator/Types.ts`), which is one construction's
+ * internal dispatch plumbing; this is the caller-facing "what configuration is
+ * in effect."
  */
 export type Context = {
     readonly seed: ReadonlyArray<string>;
@@ -101,67 +106,64 @@ export type Context = {
     readonly clock: number;
 };
 /**
- * A single initialized library instance: the registry it was given, and
- * a `construct()` bound to its own isolated randomness — its own seed,
- * builder, and per-file overrides/streams, held internally and never
- * shared with any other `initialize()` call. Independently initialized
- * instances (e.g. parallel tests) can never perturb each other.
+ * A single initialized library instance: the registry it was given, and a
+ * `construct()` bound to its own isolated randomness — its own seed, builder,
+ * and per-file overrides/streams, held internally and never shared with any
+ * other `initialize()` call. Independently initialized instances (e.g. parallel
+ * tests) can never perturb each other.
  */
 export interface Instance<$Registry extends PlainObject> extends Pick<RandomSource, "seed"> {
     /** The registry of type definers this instance was initialized with. */
     readonly T: $Registry;
     /**
      * Turn a Schema built from `T` into a live Fabricator, deriving fresh
-     * randomness from this instance's own seed for whichever leaves
-     * actually need it.
+     * randomness from this instance's own seed for whichever leaves actually need
+     * it.
      */
     Fabricator: Constructor;
     /**
-     * Every combination of every enumerable node in `schema` — every enum
-     * member, both sides of an optional field, and so on — as a cartesian
-     * product, lazily. Throws eagerly, before producing anything, if the
-     * count exceeds `limits.combinatorial` (see `initialize`'s config).
+     * Every combination of every enumerable node in `schema` — every enum member,
+     * both sides of an optional field, and so on — as a cartesian product,
+     * lazily. Throws eagerly, before producing anything, if the count exceeds
+     * `limits.combinatorial` (see `initialize`'s config).
      */
     combinatorial: Enumerable;
     /**
-     * The minimum set of instances such that every option of every
-     * enumerable node in `schema` appears at least once — count equal to
-     * the *widest* single axis, not the product, with narrower axes
-     * cycling to fill it. Unbounded: its count can never exceed the
-     * schema as written, so unlike `combinatorial` it carries no limit.
+     * The minimum set of instances such that every option of every enumerable
+     * node in `schema` appears at least once — count equal to the _widest_ single
+     * axis, not the product, with narrower axes cycling to fill it. Unbounded:
+     * its count can never exceed the schema as written, so unlike `combinatorial`
+     * it carries no limit.
      */
     coverage: Enumerable;
     /**
      * Derive a new instance laid over this one: anything the overlay names
      * overrides, anything it omits inherits. A bare `seed` replaces this
      * instance's seed; `seed: layer(...)` appends onto it. A peer of an
-     * `initialize()` return value in every respect, including its own
-     * `fork`.
+     * `initialize()` return value in every respect, including its own `fork`.
      */
     fork<const $ForkRegistry extends PlainObject = $Registry>(overlay?: Overlay<$ForkRegistry>): Instance<$ForkRegistry>;
     /**
-     * `fork(overlay)`, made ambient for the synchronous extent of `block`:
-     * every `new Fabricator(...)`, `combinatorial(...)`, and
-     * `coverage(...)` reached inside — on this instance or any other in
-     * the same lineage — resolves against the fork instead, with nothing
-     * threaded through. The fork is also passed to `block`: use it
-     * explicitly where that reads better, and *necessarily* for any async
-     * work, which the ambient frame does not survive — a build reached
-     * after an `await` inside `block` sees this instance's own
+     * `fork(overlay)`, made ambient for the synchronous extent of `block`: every
+     * `new Fabricator(...)`, `combinatorial(...)`, and `coverage(...)` reached
+     * inside — on this instance or any other in the same lineage — resolves
+     * against the fork instead, with nothing threaded through. The fork is also
+     * passed to `block`: use it explicitly where that reads better, and
+     * _necessarily_ for any async work, which the ambient frame does not survive
+     * — a build reached after an `await` inside `block` sees this instance's own
      * configuration again, not the wrap's.
      *
-     * A nested `wrap` lays over whichever frame is currently active, not
-     * over the instance it was called on — so `overlay.seed: layer(...)`
-     * accumulates with nesting depth while a bare `seed` still replaces
-     * outright, discarding every enclosing layer.
+     * A nested `wrap` lays over whichever frame is currently active, not over the
+     * instance it was called on — so `overlay.seed: layer(...)` accumulates with
+     * nesting depth while a bare `seed` still replaces outright, discarding every
+     * enclosing layer.
      */
     wrap<$Return, const $WrapRegistry extends PlainObject = $Registry>(overlay: Overlay<$WrapRegistry>, block: (scope: Instance<$WrapRegistry>) => $Return): $Return;
     /**
-     * The configuration in effect right now: the innermost active `wrap`
-     * frame's, or this instance's own outside any `wrap`. A live view, not
-     * a snapshot — reflects whichever frame is active at the moment each
-     * property is read, since one `Instance` outlives any number of
-     * `wrap`s.
+     * The configuration in effect right now: the innermost active `wrap` frame's,
+     * or this instance's own outside any `wrap`. A live view, not a snapshot —
+     * reflects whichever frame is active at the moment each property is read,
+     * since one `Instance` outlives any number of `wrap`s.
      */
     readonly context: Context;
 }

package/dist/types/Primitive/always/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, Value } from "./Types";
 /**
- * A fixed value, so unlike every other kind there is no `.as()` — nothing
- * left to override about producing it. `adapt` still applies: what a value
- * *means* to an external schema library is a separate question from what it
- * fabricates to, and for a value TypeBox cannot pin exactly (a `symbol`, or
- * any value's *static* type — see `Adapter/TypeBox`'s `toConst`) it is the
- * only way to close the gap.
+ * A fixed value, so unlike every other kind there is no `.as()` — nothing left
+ * to override about producing it. `adapt` still applies: what a value _means_
+ * to an external schema library is a separate question from what it fabricates
+ * to, and for a value TypeBox cannot pin exactly (a `symbol`, or any value's
+ * _static_ type — see `Adapter/TypeBox`'s `toConst`) it is the only way to
+ * close the gap.
  */
 export interface Schema<$Value extends Value = Value, $Adaptations extends Adaptations = {}> extends Core<$Value, $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<$Value, $Adaptations>>) => $Returnable) => Schema<$Value, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -1,14 +1,14 @@
 import type { Adaptations } from "../../Adapter/Types";
 import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 /**
- * Any value at all. Deliberately unconstrained: fabricating a fixed value
- * needs nothing of it. A `string | number | boolean` cap would be TypeBox's
- * `TLiteralValue` leaking into the primitive. Narrowing back to what a
- * given external schema library can express is that library's adapter's
- * job — see `Adapter/TypeBox`'s `toConst`.
+ * Any value at all. Deliberately unconstrained: fabricating a fixed value needs
+ * nothing of it. A `string | number | boolean` cap would be TypeBox's
+ * `TLiteralValue` leaking into the primitive. Narrowing back to what a given
+ * external schema library can express is that library's adapter's job — see
+ * `Adapter/TypeBox`'s `toConst`.
  *
- * Kept as a named alias: it is the public name for this kind's domain, and
- * both `Registry.ts` and `Schema.ts` use it as a bound.
+ * Kept as a named alias: it is the public name for this kind's domain, and both
+ * `Registry.ts` and `Schema.ts` use it as a bound.
  */
 export type Value = unknown;
 export type Fabricated<$Value extends Value> = $Value;

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

@@ -1,18 +1,20 @@
 import type { Produce } from "../../Random/Types";
 import { Schema } from "./Schema";
 import type { Definition, Fabricated, InputWhereby } from "./Types";
-export default function <const $Definition extends Definition>(definition: $Definition): {
+type ThisRegistry<$Definition extends Definition> = {
     /**
-     * An array of `definition`, repeated `whereby.length` times — either a
-     * fixed count, or uniformly across `[length.min, length.max]` with
-     * `length.min` defaulting to inclusive 0, so an empty array is a
-     * legitimate outcome when no `min` is given. Exclusive ends use a Bound
-     * object; a bare `length: N` is stored as min = max = N inclusive.
+     * An array of `definition`, repeated `whereby.length` times — either a fixed
+     * count, or uniformly across `[length.min, length.max]` with `length.min`
+     * defaulting to inclusive 0, so an empty array is a legitimate outcome when
+     * no `min` is given. Exclusive ends use a Bound object; a bare `length: N` is
+     * stored as min = max = N inclusive.
      */
     whereby: (whereby: InputWhereby) => Schema<$Definition>;
     /**
-     * An array whose production is `produce`, in full, instead of drawn
-     * element by element.
+     * An array whose production is `produce`, in full, instead of drawn element
+     * by element.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition>;
 };
+export default function <const $Definition extends Definition>(definition: $Definition): ThisRegistry<$Definition>;
+export {};

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

@@ -9,14 +9,13 @@ import type { Core, Definition, Fabricated } from "./Types";
 export interface Schema<$Definition extends Definition = Definition, $Adaptations extends Adaptations = {}> extends Core<$Definition, $Adaptations> {
     /**
      * Layer an opaque production on this schema's existing `[Meta]` — carrying
-     * `whereby`/`definition` forward, not discarding them, so a later
-     * `.as(...)` (or future validation of `produce`) still has them to check
-     * against.
+     * `whereby`/`definition` forward, not discarding them, so a later `.as(...)`
+     * (or future validation of `produce`) still has them to check against.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => 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/array/Types.d.ts

@@ -19,12 +19,12 @@ export type Whereby = {
 };
 /**
  * `whereby` (a length spec — 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 spec survives `as`
- * for future validation. `definition` stays required regardless — it's
- * known at `T.array(...)` call time and describes the element shape TypeBox
- * derives either way.
+ * `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 spec survives `as` for future
+ * validation. `definition` stays required regardless — it's known at
+ * `T.array(...)` call time and describes the element shape TypeBox derives
+ * either way.
  */
 export type Meta<$Definition extends Definition = Definition> = {
     definition: $Definition;

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

@@ -4,16 +4,16 @@ import { Schema } from "./Schema";
 import type { Fabricated, InputWhereby, 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]: "bigint";
     whereby: (whereby: InputWhereby) => Schema<{
         whereby: Whereby;
-    }, {}>;
+    }>;
     as: (produce: Produce<Fabricated>) => Schema<{
-        produce: Produce<bigint>;
-    }, {}>;
+        produce: Produce<Fabricated>;
+    }>;
 };
 export default _default;

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

@@ -3,13 +3,13 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Meta as ThisMeta } from "./Types";
 /**
- * Buildable `bigint` recipe: a range (`whereby` — required, like `string`;
- * no natural bound to fuzz to), or opaque production via `as`.
+ * Buildable `bigint` recipe: a range (`whereby` — required, like `string`; no
+ * natural bound to fuzz 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
- * threaded through every builder method for the same reason — see
- * `string/Schema.ts`'s `adapt`.
+ * `$Meta` is generic (defaulting to the full `Meta` union) so builder return
+ * types stay narrow — see `number/Schema.ts`. `$Adaptations` is threaded
+ * through every builder method for the same reason — see `string/Schema.ts`'s
+ * `adapt`.
  */
 export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends Adaptations = {}> extends Core<$Meta, $Adaptations> {
     /**
@@ -19,8 +19,8 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
      */
     as: (produce: Produce<Fabricated>) => Schema<$Meta, $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<$Meta, $Adaptations>>) => $Returnable) => Schema<$Meta, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -12,11 +12,11 @@ export type Whereby = {
 };
 export type Fabricated = bigint;
 /**
- * A ranged bigint, 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 range survives
- * `as` for future validation.
+ * A ranged bigint, 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 range survives `as` for future
+ * validation.
  */
 export type Meta = {
     whereby: Whereby;

package/dist/types/Primitive/boolean/Outcomes.d.ts

@@ -1,12 +1,12 @@
 /**
- * Weight *keys* for `.weighted(...)`, not the boolean values themselves.
- * Derived so `assertDrawableKeyedWeights` and `Enumeration/Plan.ts`
- * cannot drift from the named outcome set.
+ * Weight _keys_ for `.weighted(...)`, not the boolean values themselves.
+ * Derived so `assertDrawableKeyedWeights` and `Enumeration/Plan.ts` cannot
+ * drift from the named outcome set.
  *
- * Lives here rather than `Types.ts` so that file stays type-only. A
- * value export alongside `export type Fabricated = boolean` makes the
- * module a value module, and `export * as boolean` in
- * `Primitive/namespace.ts` then resolves `boolean` 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 = boolean` makes the module a value
+ * module, and `export * as boolean` in `Primitive/namespace.ts` then resolves
+ * `boolean` to the namespace — a cycle that drops `[Kind]`/`[Meta]` off
+ * `Core`.
  */
 export declare const outcomes: readonly ["true", "false"];

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

@@ -1,14 +1,4 @@
 import type { Adaptations } from "../../Adapter/Types";
-import { Adaptation, Kind, Meta, Produces } from "../../Types";
 import { Schema } from "./Schema";
-import type { Fabricated } from "./Types";
-declare const _default: {
-    [Kind]: "boolean";
-    [Meta]: {};
-    [Produces]?: Fabricated;
-    [Adaptation]?: Adaptations;
-    as: (produce: import("../../Random/Types").Produce<Fabricated>) => Schema<{}, Adaptations>;
-    weighted: (weights: import("./Types").Weights) => Schema<{}, Adaptations>;
-    adapt: <const $Adapter extends import("../..").Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: import("../..").Adapting<Schema<{}, Adaptations>>) => $Returnable) => Schema<{}, import("../../Adapter/Types").WithAdaptations<Adaptations, import("../../Adapter/Core").AdaptationEntry<$Adapter, $Returnable>>>;
-};
-export default _default;
+declare const registry: Schema<{}, Adaptations>;
+export default registry;

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

@@ -3,13 +3,13 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Meta as ThisMeta, Weights } from "./Types";
 /**
- * Buildable `boolean` recipe: an even coin flip, a weighted one
- * (`weights`), or opaque production via `as`.
+ * Buildable `boolean` recipe: an even coin flip, a weighted one (`weights`), 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
- * threaded through every builder method for the same reason — see
- * `string/Schema.ts`'s `adapt`.
+ * `$Meta` is generic (defaulting to the full `Meta` union) so builder return
+ * types stay narrow — see `number/Schema.ts`. `$Adaptations` is threaded
+ * through every builder method for the same reason — see `string/Schema.ts`'s
+ * `adapt`.
  */
 export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends Adaptations = {}> extends Core<$Meta, $Adaptations> {
     /**
@@ -20,8 +20,8 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
     as: (produce: Produce<Fabricated>) => Schema<$Meta, $Adaptations>;
     weighted: (weights: Weights) => Schema<$Meta, $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<$Meta, $Adaptations>>) => $Returnable) => Schema<$Meta, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -10,9 +10,9 @@ export type Weights = {
     false: number;
 };
 /**
- * An even coin flip, or a weighted one via `weights`, optionally overridden
- * by an opaque `as` production — carried alongside `weights` rather than
- * replacing it, so a prior weighting survives `as` for future validation.
+ * An even coin flip, or a weighted one via `weights`, optionally overridden by
+ * an opaque `as` production — carried alongside `weights` rather than replacing
+ * it, so a prior weighting survives `as` for future validation.
  */
 export type Meta = {
     produce?: Produce<Fabricated>;

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

@@ -20,13 +20,12 @@ export type Fabricator<$Schema extends {
     schema: Schema<$Schema[typeof Meta]["items"], AdaptationsOf<$Schema>>;
 };
 /**
- * `weightings` are each option's *already-dispatched* Fabricator, one per
+ * `weightings` are each option's _already-dispatched_ Fabricator, one per
  * `[Meta].items` entry, built by `Constructor.ts`'s `make` before this call —
- * mirrors `array.Fabricator`'s `element`, just one per option instead of
- * one shared across every element. The weighted pick happens on this
- * field's private stream; only the chosen option's `fabricate()` is called,
- * so an unpicked option never advances its stream (safe for the same reason
- * skipping `object.omittable`'s inner draw is — see CLAUDE.md's
- * "Randomness").
+ * mirrors `array.Fabricator`'s `element`, just one per option instead of one
+ * shared across every element. The weighted pick happens on this field's
+ * private stream; only the chosen option's `fabricate()` is called, so an
+ * unpicked option never advances its stream (safe for the same reason skipping
+ * `object.omittable`'s inner draw is — see CLAUDE.md's "Randomness").
  */
 export declare function Fabricator<$Items extends Items>(context: FabricatorContext<Schema<$Items>>, weightings: ReadonlyArray<readonly [number, NaiveFabricator<any>]>): Fabricator<Schema<$Items>>;

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

@@ -5,33 +5,33 @@ import type { Item, Items } from "./Types";
  * per-position option types (`{ [K in keyof $Items]: ... }` walks a tuple
  * position-by-position, unlike `ReadonlyArray<...>`'s `.map()`, which only
  * remembers the union of every element it saw). This is what lets
- * `Adapter/TypeBox` recover real arity later and mirror TypeBox's
- * `Union<T>` collapse-for-a-single-option — see `Types.ts`'s `Items`.
+ * `Adapter/TypeBox` recover real arity later and mirror TypeBox's `Union<T>`
+ * collapse-for-a-single-option — see `Types.ts`'s `Items`.
  */
 type Weighted<$Items extends ReadonlyArray<Item>> = {
     [$K in keyof $Items]: readonly [number, $Items[$K]];
 };
 /**
- * At least one element — a `choice` with no option has nothing to draw,
- * which would otherwise fail inside `weighted()` (`Distribution/index.ts`)
- * with an opaque `TypeError` at fabricate time (weight sum is `0`, so
- * `.find` returns `undefined` and `chosen![1]` throws). Rejecting emptiness
- * here is a construction-time compile error; the runtime check below is the
- * backstop for an `as any` call that bypasses it.
+ * At least one element — a `choice` with no option has nothing to draw, which
+ * would otherwise fail inside `weighted()` (`Distribution/index.ts`) with an
+ * opaque `TypeError` at fabricate time (weight sum is `0`, so `.find` returns
+ * `undefined` and `chosen![1]` throws). Rejecting emptiness here is a
+ * construction-time compile error; the runtime check below is the backstop for
+ * an `as any` call that bypasses it.
  */
 type NonEmpty<$T> = readonly [$T, ...$T[]];
 declare const _default: {
     /**
      * Equal probability across every option. Delegates to `weighted` with a
      * uniform weight of `1` per item — a plain `weighted()` draw is already a
-     * uniform draw when every weight is equal, so there is no separate
-     * unweighted code path to keep in sync.
+     * uniform draw when every weight is equal, so there is no separate unweighted
+     * code path to keep in sync.
      */
     uniform: <const $Items extends NonEmpty<Item>>(items: $Items) => Schema<Weighted<$Items>>;
     /**
-     * Relative probability across options, given as `[weight, schema]` pairs
-     * — the same tuple shape `weighted()` (`Distribution/index.ts`) itself
-     * accepts, not an object keyed by option.
+     * Relative probability across options, given as `[weight, schema]` pairs —
+     * the same tuple shape `weighted()` (`Distribution/index.ts`) itself accepts,
+     * not an object keyed by option.
      */
     weighted: <const $Items extends NonEmpty<Items[number]>>(items: $Items) => Schema<$Items>;
 };