@ghostry/fabricator 0.0.1 → 0.0.3

package/dist/types/Error/index.d.ts

@@ -1,18 +1,17 @@
 /**
  * Every error this library throws is a named subclass of
- * {@link FabricatorError}, kept in one dependency-free module:
- * `instanceof FabricatorError` catches everything the library raises, and no
- * error definition can pull a primitive's module graph into an unrelated
- * import.
+ * {@link FabricatorError}, kept in one dependency-free module: `instanceof
+ * FabricatorError` catches everything the library raises, and no error
+ * definition can pull a primitive's module graph into an unrelated import.
  *
- * Kind tags are plain `string`, not the `Kind` union from
- * `Primitive/index.ts` — that second reason, and because several of these
- * errors exist precisely because the kind in hand was *not* a member of it.
+ * Kind tags are plain `string`, not the `Kind` union from `Primitive/index.ts`
+ * — that second reason, and because several of these errors exist precisely
+ * because the kind in hand was _not_ a member of it.
  *
  * Context is `public readonly` constructor parameters, but the message still
- * stands on its own: a consumer reading only `.message` should not need a
- * field to understand the failure. Fields are for programmatic access, and
- * for detail too bulky to inline.
+ * stands on its own: a consumer reading only `.message` should not need a field
+ * to understand the failure. Fields are for programmatic access, and for detail
+ * too bulky to inline.
  */
 /**
  * Base error class from which more specific errors inherit.
@@ -28,8 +27,8 @@ export declare namespace FabricatorError {
      */
     type Phase = "construction" | "adaptation";
     /**
-     * `initialize({ limits: { combinatorial } })` when the configured limit
-     * could never be a meaningful instance count.
+     * `initialize({ limits: { combinatorial } })` when the configured limit could
+     * never be a meaningful instance count.
      */
     class InvalidCombinatorialLimitError extends FabricatorError {
         /**
@@ -47,28 +46,9 @@ export declare namespace FabricatorError {
         limit: unknown);
     }
     /**
-     * `initialize({ attribution: { kind: "rooted", root } })` when `root` is
-     * not an absolute path or a `file://` URL. A relative root can never prefix
-     * a resolved caller file, so `relativize` would leave every file unchanged
-     * — the option would look configured while silently doing nothing. Thrown
-     * eagerly at `initialize()`, not deferred to wherever that would first
-     * become observable.
-     */
-    class InvalidAttributionRootError extends FabricatorError {
-        /**
-         * The rejected root, as given.
-         */
-        readonly root: string;
-        constructor(
-        /**
-         * The rejected root, as given.
-         */
-        root: string);
-    }
-    /**
-     * A `self` placeholder resolved with no `T.recursive` expanding around it
-     * — only reachable by holding a `self` reference outside the
-     * `T.recursive(...)` callback it was handed to.
+     * A `self` placeholder resolved with no `T.recursive` expanding around it —
+     * only reachable by holding a `self` reference outside the `T.recursive(...)`
+     * callback it was handed to.
      */
     class DetachedSelfError extends FabricatorError {
         /**
@@ -82,36 +62,37 @@ export declare namespace FabricatorError {
         during: Phase);
     }
     /**
-     * `T.recursive(body).whereby({ depth })` with no `terminal`, when `body`
-     * has a `self` that is not behind a kind that can stop recursing — a
-     * required object field, a tuple slot, the body itself, or a `choice`
-     * whose every option still contains `self`. Thrown at `.whereby()`, not
-     * at fabricate time. An explicit `terminal` is the way out.
+     * `T.recursive(body).whereby({ depth })` with no `terminal`, when `body` has
+     * a `self` that is not behind a kind that can stop recursing — a required
+     * object field, a tuple slot, the body itself, or a `choice` whose every
+     * option still contains `self`. Thrown at `.whereby()`, not at fabricate
+     * time. An explicit `terminal` is the way out.
      */
     class UnterminableRecursiveError extends FabricatorError {
         /**
-         * Structural path from the recursive body to the unterminable
-         * `self` (or to the `choice` that had no remaining non-`self`
-         * option), as field names / slot indices.
+         * Structural path from the recursive body to the unterminable `self` (or
+         * to the `choice` that had no remaining non-`self` option), as field
+         * names / slot indices.
          */
         readonly path: ReadonlyArray<string>;
         constructor(
         /**
-         * Structural path from the recursive body to the unterminable
-         * `self` (or to the `choice` that had no remaining non-`self`
-         * option), as field names / slot indices.
+         * Structural path from the recursive body to the unterminable `self` (or
+         * to the `choice` that had no remaining non-`self` option), as field
+         * names / slot indices.
          */
         path: ReadonlyArray<string>);
     }
     /**
-     * A walk reached a node whose `[Kind]` it has no case for — a Schema built
-     * by hand or cast past the type system, or a kind added to
-     * `Primitive/index.ts` without wiring it into every dispatch site.
+     * A walk reached a node whose `[Kind]` it has no case for — a Schema built by
+     * hand or cast past the type system, or a kind added to `Primitive/index.ts`
+     * without wiring it into every dispatch site.
      */
     class UnknownKindError extends FabricatorError {
         /**
-         * The unrecognized `[Kind]` tag, stringified — it may be any value at all,
-         * since reaching this error means the type system was already bypassed.
+         * The unrecognized `[Kind]` tag, stringified — it may be any value at
+         * all, since reaching this error means the type system was already
+         * bypassed.
          */
         readonly kind: string;
         /**
@@ -120,8 +101,9 @@ export declare namespace FabricatorError {
         readonly during: Phase;
         constructor(
         /**
-         * The unrecognized `[Kind]` tag, stringified — it may be any value at all,
-         * since reaching this error means the type system was already bypassed.
+         * The unrecognized `[Kind]` tag, stringified — it may be any value at
+         * all, since reaching this error means the type system was already
+         * bypassed.
          */
         kind: string, 
         /**
@@ -154,10 +136,9 @@ export declare namespace FabricatorError {
         noun: string);
     }
     /**
-     * An object's definition names a key that would reach `Object.prototype` —
-     * a developer-written key, where throwing is actionable (contrast
-     * `record`'s *drawn* keys, written with `Object.defineProperty` instead of
-     * rejected).
+     * An object's definition names a key that would reach `Object.prototype` — a
+     * developer-written key, where throwing is actionable (contrast `record`'s
+     * _drawn_ keys, written with `Object.defineProperty` instead of rejected).
      */
     class PrototypePollutionError extends FabricatorError {
         /**
@@ -179,8 +160,8 @@ export declare namespace FabricatorError {
         constructor();
     }
     /**
-     * A `.refine()`-computed field's resolver returned a value of the wrong
-     * shape for the source schema it was declared against.
+     * A `.refine()`-computed field's resolver returned a value of the wrong shape
+     * for the source schema it was declared against.
      */
     class ComputeResultMismatchError extends FabricatorError {
         /**
@@ -202,8 +183,8 @@ export declare namespace FabricatorError {
         value: unknown);
     }
     /**
-     * An override names a field the object schema does not define — most
-     * often a typo, which is why the known fields are listed.
+     * An override names a field the object schema does not define — most often a
+     * typo, which is why the known fields are listed.
      */
     class UnknownOverrideFieldError extends FabricatorError {
         /**
@@ -225,8 +206,8 @@ export declare namespace FabricatorError {
         available: ReadonlyArray<string>);
     }
     /**
-     * An override value does not fit the field it is meant to replace. Raised
-     * for every field shape — a plain field, a nested object, and each presence
+     * An override value does not fit the field it is meant to replace. Raised for
+     * every field shape — a plain field, a nested object, and each presence
      * wrapper unwrapped to its inner kind — the same failure in each case.
      */
     class InvalidOverrideValueError extends FabricatorError {
@@ -236,7 +217,7 @@ export declare namespace FabricatorError {
         readonly field: string;
         /**
          * The `[Kind]` the value was checked against — for a wrapper field, the
-         * *inner* kind, since the wrapper's own absent/null outcomes are accepted
+         * _inner_ kind, since the wrapper's own absent/null outcomes are accepted
          * separately.
          */
         readonly kind: string;
@@ -251,7 +232,7 @@ export declare namespace FabricatorError {
         field: string, 
         /**
          * The `[Kind]` the value was checked against — for a wrapper field, the
-         * *inner* kind, since the wrapper's own absent/null outcomes are accepted
+         * _inner_ kind, since the wrapper's own absent/null outcomes are accepted
          * separately.
          */
         kind: string, 
@@ -261,9 +242,8 @@ export declare namespace FabricatorError {
         value: unknown);
     }
     /**
-     * Thrown when `Omitted` is passed to override a field that has no
-     * absent outcome. Only `T.omittable`/`T.optional` fields can be forced
-     * off.
+     * Thrown when `Omitted` is passed to override a field that has no absent
+     * outcome. Only `T.omittable`/`T.optional` fields can be forced off.
      */
     class IllegalOmittedOverrideError extends FabricatorError {
         /**
@@ -310,8 +290,8 @@ export declare namespace FabricatorError {
         width: bigint);
     }
     /**
-     * `resolve()` handed a pin for a kind `plan()` never produces one for —
-     * the two must stay in agreement; internal invariant, not caller-reachable.
+     * `resolve()` handed a pin for a kind `plan()` never produces one for — the
+     * two must stay in agreement; internal invariant, not caller-reachable.
      */
     class UnpinnableKindError extends FabricatorError {
         /**
@@ -352,8 +332,8 @@ export declare namespace FabricatorError {
     }
     /**
      * A `record`'s key schema has no counterpart in the external schema library
-     * being adapted to — a symbol key, for TypeBox, whose `Type.Record`
-     * silently yields a schema nothing can satisfy rather than raising.
+     * being adapted to — a symbol key, for TypeBox, whose `Type.Record` silently
+     * yields a schema nothing can satisfy rather than raising.
      */
     class UnrepresentableRecordKeyError extends FabricatorError {
         /**
@@ -367,10 +347,10 @@ export declare namespace FabricatorError {
         kind: string);
     }
     /**
-     * A `{ min, max }` range contains no fabricable value — inverted bounds,
-     * a point range with an exclusive end, or a discrete exclusive pair whose
-     * effective integers are none. Thrown at `.whereby()` (or at construction
-     * for `T.date.past`/`future`, whose other end is the instance clock).
+     * A `{ min, max }` range contains no fabricable value — inverted bounds, a
+     * point range with an exclusive end, or a discrete exclusive pair whose
+     * effective integers are none. Thrown at `.whereby()` (or at construction for
+     * `T.date.past`/`future`, whose other end is the instance clock).
      */
     class EmptyRangeError extends FabricatorError {
         /**
@@ -413,8 +393,8 @@ export declare namespace FabricatorError {
     }
     /**
      * A distribution's bounds fall outside its own domain — a `logarithmic`
-     * distribution's density is proportional to `1/x`, so it is undefined at
-     * or below zero.
+     * distribution's density is proportional to `1/x`, so it is undefined at or
+     * below zero.
      */
     class InvalidDistributionBoundError extends FabricatorError {
         /**
@@ -444,8 +424,8 @@ export declare namespace FabricatorError {
         max: number);
     }
     /**
-     * Which entry of a `.weighted(...)` call carried the bad weight: a position in
-     * a caller-supplied list, or one of a fixed, named outcome set.
+     * Which entry of a `.weighted(...)` call carried the bad weight: a position
+     * in a caller-supplied list, or one of a fixed, named outcome set.
      */
     type WeightEntry = {
         readonly kind: "index";
@@ -456,10 +436,10 @@ export declare namespace FabricatorError {
         readonly name: string;
     };
     /**
-     * A `.weighted(...)` call gives an outcome a weight that is not
-     * expressible: negative, `NaN`, or `Infinity`. Zero is valid — it
-     * disables the outcome — so this is not "anything `weighted()` would
-     * drop." An empty drawable set is {@link NoDrawableOutcomesError}.
+     * A `.weighted(...)` call gives an outcome a weight that is not expressible:
+     * negative, `NaN`, or `Infinity`. Zero is valid — it disables the outcome —
+     * so this is not "anything `weighted()` would drop." An empty drawable set is
+     * {@link NoDrawableOutcomesError}.
      */
     class InvalidWeightError extends FabricatorError {
         /**
@@ -489,9 +469,9 @@ export declare namespace FabricatorError {
         entry: WeightEntry);
     }
     /**
-     * A weighted draw table has nothing left to pick: every weight is
-     * zero (or the list was empty of drawable entries). Zeroing an
-     * outcome disables it, so at least one must keep a positive weight.
+     * A weighted draw table has nothing left to pick: every weight is zero (or
+     * the list was empty of drawable entries). Zeroing an outcome disables it, so
+     * at least one must keep a positive weight.
      */
     class NoDrawableOutcomesError extends FabricatorError {
         /**
@@ -515,9 +495,9 @@ export declare namespace FabricatorError {
         noun: string);
     }
     /**
-     * `new Fabricator(schema, trace)` when `trace.kind` names a different
-     * kind than `schema`. A trace reproduces the node it was taken from,
-     * so its kind must match the schema it is replayed against.
+     * `new Fabricator(schema, trace)` when `trace.kind` names a different kind
+     * than `schema`. A trace reproduces the node it was taken from, so its kind
+     * must match the schema it is replayed against.
      */
     class TraceKindMismatchError extends FabricatorError {
         /**
@@ -538,4 +518,38 @@ export declare namespace FabricatorError {
          */
         given: string);
     }
+    /**
+     * `wrap(overlay, block)` handed an `async` block while the lineage's ambient
+     * carrier is the synchronous one (`Instance/Stack/Sync.ts`).
+     *
+     * Its frame cannot outlive the block's first `await`, so a build reached
+     * after one would resolve against the base instance rather than the wrap —
+     * plausible data, quietly drawn from the wrong configuration. Raised instead
+     * of allowing that, which is why it fires even when `block` only ever uses
+     * `scope`: whether a later build reads the ambient frame is not knowable from
+     * here.
+     *
+     * Reachable only where `#stack` resolved to `default` — a runtime with no
+     * `node:async_hooks`, in practice a browser bundle — or where `initialize({
+     * stack })` supplied a synchronous carrier explicitly. Node, Bun, and Deno
+     * all resolve to the `AsyncLocalStorage` carrier and never raise this.
+     */
+    class SynchronousStackError extends FabricatorError {
+        constructor();
+    }
+    /**
+     * The `fabricator` provider of `integration(instance)`
+     * (`@ghostry/fabricator/harnessing`) was called outside that integration's
+     * own `around`.
+     *
+     * The provider hands back the per-test scope `around` just entered, so there
+     * is no scope for it to return anywhere else. `@ghostry/harness` never does
+     * this — it runs each provider inside its integration's `around` — so this
+     * means a composer that breaks the contract. Raised rather than returning the
+     * base instance, which would draw plausible data from the wrong configuration
+     * with no signal.
+     */
+    class HarnessingProviderError extends FabricatorError {
+        constructor();
+    }
 }

package/dist/types/Fabricator/Constructor.d.ts

@@ -3,41 +3,39 @@ import type { ConstructorOptions, RandomSource } from "../Random/Types";
 import { type Buildable } from "../Types";
 import { type AsFabricator } from "./Types";
 /**
- * The type of `construct()` itself, as handed back by `Constructor` —
- * kept separate so `initialize`'s return type (`src/index.ts`) can name
- * it without re-deriving it from `Constructor`'s implementation.
+ * The type of `construct()` itself, as handed back by `Constructor` — kept
+ * separate so `initialize`'s return type (`src/index.ts`) can name it without
+ * re-deriving it from `Constructor`'s implementation.
  *
- * Both a call signature and a construct signature: `construct` is a
- * plain `function` that explicitly returns an object, so
- * `new construct(schema)` behaves identically to `construct(schema)` —
- * a `new` call's returned object always replaces the freshly-created
- * `this`. The construct signature lets callers spell
- * `new T.Fabricator(schema)` — or `new Fabricator(schema, { seed })` to
- * pin this one build to an explicit seed, independent of the file it's
- * constructed in (see `construct()` for what `options.seed` does).
+ * Both a call signature and a construct signature: `construct` is a plain
+ * `function` that explicitly returns an object, so `new construct(schema)`
+ * behaves identically to `construct(schema)` — a `new` call's returned object
+ * always replaces the freshly-created `this`. The construct signature lets
+ * callers spell `new T.Fabricator(schema)` — or `new Fabricator(schema, { salt
+ * })` to pin this one build's salt slot, leaving every other slot to resolve as
+ * usual (see `construct()` for what `options.salt` does).
  */
 export type Constructor = {
     new <const $Schema extends Buildable>(schema: $Schema, options?: ConstructorOptions): AsFabricator<$Schema>;
 };
 /**
- * Build the untyped recursive core — mirrors `Adapter/TypeBox/index.ts`'s
- * own internal `convert(schema: any)` — and the precisely-typed
- * `construct()` boundary around it, both closed over a single instance's
- * `source` so every fabricator this `construct()` produces draws from
- * that instance's own seed/streams and never another instance's.
+ * Build the untyped recursive core — mirrors `Adapter/TypeBox/index.ts`'s own
+ * internal `convert(schema: any)` — and the precisely-typed `construct()`
+ * boundary around it, both closed over a single instance's `source` so every
+ * fabricator this `construct()` produces draws from that instance's own
+ * salt/streams and never another instance's.
  *
  * `stack` is the instance's own lineage-wide ambient stack
  * (`Instance/Core.ts`'s `toStack()`) — passed straight through to
- * `resolveScope` on every `construct()` call, never read here directly,
- * so a build reached inside an active `wrap` resolves against that
- * frame automatically, with nothing threaded through by the caller.
+ * `resolveScope` on every `construct()` call, never read here directly, so a
+ * build reached inside an active `wrap` resolves against that frame
+ * automatically, with nothing threaded through by the caller.
  *
- * No separate `clock` parameter: `source` already carries its own
- * resolved clock intrinsically (`Random/Types.ts`'s `Options.clock`,
- * baked in when the source was built), and `resolveScope`'s chosen
- * source — the active `wrap` frame's, or this one — is exactly the
- * source whose clock a construction should resolve "now" against.
- * `toConstructionContext` reads it straight off the resolved root
- * rather than threading a second value alongside `source`.
+ * No separate `clock` parameter: `source` already carries its own resolved
+ * clock intrinsically (`Random/Types.ts`'s `Options.clock`, baked in when the
+ * source was built), and `resolveScope`'s chosen source — the active `wrap`
+ * frame's, or this one — is exactly the source whose clock a construction
+ * should resolve "now" against. `toConstructionContext` reads it straight off
+ * the resolved root rather than threading a second value alongside `source`.
  */
 export declare function Constructor(source: RandomSource, stack: Stack): Constructor;

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

@@ -5,35 +5,32 @@ import type { ValueOf } from "../Schema/Types";
 import type { Adaptation, Kind, Meta, Produces } from "../Types";
 import type { PlainObject } from "../Utility/Types";
 /**
- * Threaded through `Constructor.ts`'s `make` for every dispatch of one
- * `new Fabricator(...)` construction — every branch forwards it
- * (extending `path`, never `algorithm`/`self`) into its own nested
- * `make(...)` calls, so it reaches however deeply a leaf sits nested
- * through `array`/`object`/`tuple`/etc.
+ * Threaded through `Constructor.ts`'s `make` for every dispatch of one `new
+ * Fabricator(...)` construction — every branch forwards it (extending `path`,
+ * never `algorithm`/`self`) into its own nested `make(...)` calls, so it
+ * reaches however deeply a leaf sits nested through
+ * `array`/`object`/`tuple`/etc.
  *
- * `toTrace` records this node's {@link Trace} — a plain object literal,
- * no hashing. Hashing is paid only where a kind actually calls
- * `toStreamFromTrace(algorithm, trace)`. Bound once in `construct()` to
- * this one construction's already-resolved `RandomSource`/
- * `ConstructionTrace` pair (see `Constructor.ts`'s `resolveScope`) —
- * every leaf calls `toTrace` with only its own structural `path` and
- * kind, never re-resolving the construction's root itself.
- * `T.recursive` is the one kind that rebinds `toTrace`: each lazy
- * expansion opens its own scope on the node's own private forked
- * `RandomSource` (see `recursive/Fabricator.ts`), so a data-dependent
- * expansion count can never perturb, or be perturbed by, anything else
- * built from the same `initialize()` instance —
- * `RandomSource.fork` (`Random/Types.ts`) is the isolation primitive.
+ * `toTrace` records this node's {@link Trace} — a plain object literal, no
+ * hashing. Hashing is paid only where a kind actually calls
+ * `toStreamFromTrace(algorithm, trace)`. Bound once in `construct()` to this
+ * one construction's already-resolved `RandomSource`/ `ConstructionTrace` pair
+ * (see `Constructor.ts`'s `resolveScope`) — every leaf calls `toTrace` with
+ * only its own structural `path` and kind, never re-resolving the
+ * construction's root itself. `T.recursive` is the one kind that rebinds
+ * `toTrace`: each lazy expansion opens its own scope on the node's own private
+ * forked `RandomSource` (see `recursive/Fabricator.ts`), so a data-dependent
+ * expansion count can never perturb, or be perturbed by, anything else built
+ * from the same `initialize()` instance — `RandomSource.fork`
+ * (`Random/Types.ts`) is the isolation primitive.
  *
- * `algorithm` rather than the `RandomSource` itself: stream derivation
- * depends on no per-source state, and a leaf has no business with
- * `toRoot`/`fork`. `clock` is not a field of its own — it is always
- * `trace.clock`.
+ * `algorithm` rather than the `RandomSource` itself: stream derivation depends
+ * on no per-source state, and a leaf has no business with `toRoot`/`fork`.
+ * `clock` is not a field of its own — it is always `trace.clock`.
  *
- * `self` is what makes `case "recursive.self"` resolve to "recurse one
- * level deeper, right now" — absent outside any active recursion, which
- * is how `case "recursive.self"` detects and rejects a `self` node used
- * where none applies.
+ * `self` is what makes `case "recursive.self"` resolve to "recurse one level
+ * deeper, right now" — absent outside any active recursion, which is how `case
+ * "recursive.self"` detects and rejects a `self` node used where none applies.
  */
 export type ConstructionContext = {
     toTrace: (path: ReadonlyArray<string>, kind: string) => Trace;
@@ -41,22 +38,20 @@ export type ConstructionContext = {
     self?: (() => unknown) | undefined;
 };
 /**
- * What every kind's `Fabricator(...)` receives in place of a repeated
- * `(schema, algorithm, trace)` positional list — `Constructor.ts`'s
- * `make` builds one per dispatched node from its own
- * `ConstructionContext`. `trace` is already path-bound and built
- * eagerly, so a kind that never draws still records one without calling
- * `toStreamFromTrace`. Laziness is load-bearing: `toTrace` is a plain
- * object literal, and hashing is paid only where a kind actually calls
- * `toStreamFromTrace(algorithm, trace)`. The guard is the call site's
- * own `if (meta.produce)` branch (or the equivalent drawing path), not
- * an unevaluated closure. `algorithm` rather than the `RandomSource`:
- * derivation depends on no per-source state, and a leaf has no business
- * with `toRoot`/`fork`. No `clock`: it is `trace.clock`, always. A
- * kind-specific extra — an array's `element`, an object's `fields`, a
- * choice's `weightings` — still follows as its own trailing parameter:
- * those vary per kind and were never part of the shared prefix this
- * replaces.
+ * What every kind's `Fabricator(...)` receives in place of a repeated `(schema,
+ * algorithm, trace)` positional list — `Constructor.ts`'s `make` builds one per
+ * dispatched node from its own `ConstructionContext`. `trace` is already
+ * path-bound and built eagerly, so a kind that never draws still records one
+ * without calling `toStreamFromTrace`. Laziness is load-bearing: `toTrace` is a
+ * plain object literal, and hashing is paid only where a kind actually calls
+ * `toStreamFromTrace(algorithm, trace)`. The guard is the call site's own `if
+ * (meta.produce)` branch (or the equivalent drawing path), not an unevaluated
+ * closure. `algorithm` rather than the `RandomSource`: derivation depends on no
+ * per-source state, and a leaf has no business with `toRoot`/`fork`. No
+ * `clock`: it is `trace.clock`, always. A kind-specific extra — an array's
+ * `element`, an object's `fields`, a choice's `weightings` — still follows as
+ * its own trailing parameter: those vary per kind and were never part of the
+ * shared prefix this replaces.
  */
 export type FabricatorContext<$Schema> = {
     schema: $Schema;
@@ -64,18 +59,18 @@ export type FabricatorContext<$Schema> = {
     trace: Trace;
 };
 /**
- * The most basic interface for a typed Fabricator.
- * No type introspection is possible.
+ * The most basic interface for a typed Fabricator. No type introspection is
+ * possible.
  */
 export type NaiveFabricator<$T> = {
     fabricate: () => $T;
 };
 /**
- * What every kind's `construct()` produces: a `NaiveFabricator` that
- * also hands back the Schema it was built from, via the same
- * `[Kind]`/`[Meta]` a Schema itself carries — so a built Fabricator
- * can be passed back into `object`/`array`/a registry `.extend()`
- * anywhere a Schema is expected (see `toSchema`).
+ * What every kind's `construct()` produces: a `NaiveFabricator` that also hands
+ * back the Schema it was built from, via the same `[Kind]`/`[Meta]` a Schema
+ * itself carries — so a built Fabricator can be passed back into
+ * `object`/`array`/a registry `.extend()` anywhere a Schema is expected (see
+ * `toSchema`).
  */
 export type Fabricator<$T> = NaiveFabricator<$T> & {
     [Kind]: SchemaKind;
@@ -83,48 +78,45 @@ export type Fabricator<$T> = NaiveFabricator<$T> & {
     readonly trace: Trace;
     /**
      * Carried over from the Schema by `Constructor.ts`'s `make` — inert to
-     * fabrication, but it has to survive building for an adapter handed a
-     * built Fabricator to see what the Schema declared (see
-     * `Adapter/Types.ts`).
+     * fabrication, but it has to survive building for an adapter handed a built
+     * Fabricator to see what the Schema declared (see `Adapter/Types.ts`).
      */
     readonly [Adaptation]?: Adaptations;
 };
 /**
  * The value type a built Fabricator produces — read directly off its
- * `fabricate` signature. Every kind's `construct()` output shares the
- * exact same shape (`NaiveFabricator<$T>` plus `[Kind]`/`[Meta]`, see
- * this file's `Fabricator<$T>`), so there's nothing to dispatch per
- * kind here — unlike `ValueOf`, which reads a Schema's phantom
- * `[Produces]` marker for the pre-`construct()` case, this only ever
- * needs to unwrap an already-uniform `fabricate: () => $T`.
+ * `fabricate` signature. Every kind's `construct()` output shares the exact
+ * same shape (`NaiveFabricator<$T>` plus `[Kind]`/`[Meta]`, see this file's
+ * `Fabricator<$T>`), so there's nothing to dispatch per kind here — unlike
+ * `ValueOf`, which reads a Schema's phantom `[Produces]` marker for the
+ * pre-`construct()` case, this only ever needs to unwrap an already-uniform
+ * `fabricate: () => $T`.
  */
 export type Fabrication<$Fabricator extends NaiveFabricator<any>> = $Fabricator extends NaiveFabricator<infer $T> ? $T : never;
 /**
- * Maps a Schema (or an already-built Fabricator of the same kind — see
- * the `object` branch, and every other branch below since each kind's
- * `Schema` also carries a required `as` method a built Fabricator never
- * has) to the precise, kind-specific `Fabricator<...>` type it builds
- * into. Mirrors `Adapter/TypeBox/index.ts`'s `ToTypeBox` dispatch.
- * Falls back to the loose base `Fabricator<ValueOf<$Schema>>` for
- * anything unmatched.
+ * Maps a Schema (or an already-built Fabricator of the same kind — see the
+ * `object` branch, and every other branch below since each kind's `Schema` also
+ * carries a required `as` method a built Fabricator never has) to the precise,
+ * kind-specific `Fabricator<...>` type it builds into. Mirrors
+ * `Adapter/TypeBox/index.ts`'s `ToTypeBox` dispatch. Falls back to the loose
+ * base `Fabricator<ValueOf<$Schema>>` for anything unmatched.
  *
- * No branch here needs to do anything about `[Adaptation]`: each
- * kind's own `Fabricator<$Schema>` reads it back off `$Schema` via
- * `AdaptationsOf`, so an adapted Schema's Fabricator carries the map
- * without this dispatch (or an intersection on top of it, which the
- * warning below would otherwise apply to) having to mention it.
- * `object.compute` is the one exception, taking its `$Adaptations`
- * explicitly because its Fabricator is parameterized by the computed
- * value and source rather than by the Schema.
+ * No branch here needs to do anything about `[Adaptation]`: each kind's own
+ * `Fabricator<$Schema>` reads it back off `$Schema` via `AdaptationsOf`, so an
+ * adapted Schema's Fabricator carries the map without this dispatch (or an
+ * intersection on top of it, which the warning below would otherwise apply to)
+ * having to mention it. `object.compute` is the one exception, taking its
+ * `$Adaptations` explicitly because its Fabricator is parameterized by the
+ * computed value and source rather than by the Schema.
  *
- * Every branch's own `Fabricator<$Schema>` type already carries a
- * `.schema` field (see each kind's `Core.ts`) — *not* added here via an
- * extra `& { schema: ... }` intersection: wrapping an already-named
- * type in a fresh intersection defeats a later `infer` over it (e.g.
- * each kind's own `Fabrication<$Fabricator>` helper, which narrows via
- * `extends Fabricator<infer $Schema>`) — TypeScript can't always
- * decompose the intersection back to recover `$Schema`, and silently
- * widens to the generic's constraint instead.
+ * Every branch's own `Fabricator<$Schema>` type already carries a `.schema`
+ * field (see each kind's `Core.ts`) — _not_ added here via an extra `& {
+ * schema: ... }` intersection: wrapping an already-named type in a fresh
+ * intersection defeats a later `infer` over it (e.g. each kind's own
+ * `Fabrication<$Fabricator>` helper, which narrows via `extends
+ * Fabricator<infer $Schema>`) — TypeScript can't always decompose the
+ * intersection back to recover `$Schema`, and silently widens to the generic's
+ * constraint instead.
  */
 export type AsFabricator<$Schema> = 
 /**