@ghostry/fabricator 0.0.1 → 0.0.2

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

@@ -1,52 +1,34 @@
 import type { Adaptations } from "../../Adapter/Types";
-import { Adaptation, Kind, Meta, Produces } from "../../Types";
+import { default as bigint } from "../bigint";
 import { Schema } from "./Schema";
-import type { Fabricated, InputWhereby, Whereby } from "./Types";
-declare const _default: {
-    [Kind]: "number";
-    [Meta]: {};
-    [Produces]?: Fabricated;
-    [Adaptation]?: Adaptations;
-    as: (produce: import("../../Random/Types").Produce<Fabricated>, hints?: import("./Types").JsonSchema) => 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>>>;
+import type { InputWhereby, Whereby } from "./Types";
+type ThisRegistry = Schema<{}, Adaptations> & {
+    /**
+     * A `number` drawn from `[min, max]`, either end optional. Pass a
+     * `distribution` to shape how values cluster within the range; without one,
+     * every value is equally likely.
+     */
     whereby: (whereby: InputWhereby) => Schema<{
         whereby: Whereby;
-    }, {}>;
-    integer: {
-        [Kind]: "number";
-        [Meta]: {
-            integer: true;
-        };
-        [Produces]?: Fabricated;
-        [Adaptation]?: {};
-        as: (produce: import("../../Random/Types").Produce<Fabricated>, hints?: import("./Types").JsonSchema) => Schema<{
-            integer: true;
-        }, {}>;
-        adapt: <const $Adapter extends import("../..").Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: import("../..").Adapting<Schema<{
-            integer: true;
-        }, {}>>) => $Returnable) => Schema<{
-            integer: true;
-        }, import("../../Adapter/Types").WithAdaptations<{}, import("../../Adapter/Core").AdaptationEntry<$Adapter, $Returnable>>>;
+    }>;
+    /** The same surface, restricted to integers. */
+    integer: Schema<{
+        integer: true;
+    }> & {
         whereby: (whereby: InputWhereby) => Schema<{
             integer: true;
             whereby: Whereby;
-        }, {}>;
+        }>;
         /**
-         * A monotonically increasing counter starting at 1, fresh per `construct()`.
+         * A monotonically increasing counter starting at 1, fresh per
+         * `construct()`.
          */
         sequence: Schema<{
             sequence: true;
             integer: true;
-        }, {}>;
-        big: {
-            [Kind]: "bigint";
-            whereby: (whereby: import("../bigint").InputWhereby) => import("../bigint").Schema<{
-                whereby: import("../bigint").Whereby;
-            }, {}>;
-            as: (produce: import("../../Random/Types").Produce<import("../bigint").Fabricated>) => import("../bigint").Schema<{
-                produce: import("../../Random/Types").Produce<bigint>;
-            }, {}>;
-        };
+        }>;
+        big: typeof bigint;
     };
 };
-export default _default;
+declare const registry: ThisRegistry;
+export default registry;

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

@@ -3,17 +3,16 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, JsonSchema, Meta as ThisMeta } from "./Types";
 /**
- * Buildable `number` recipe: a range/distribution (`whereby`, absent for
- * the full-range bare form), `integer` for whole-number semantics, a
- * `sequence` counter, or opaque production via `as`. `construct()` derives
- * `fabricate` from this data — no variant carries its own closure until
- * it's built.
+ * Buildable `number` recipe: a range/distribution (`whereby`, absent for the
+ * full-range bare form), `integer` for whole-number semantics, a `sequence`
+ * counter, or opaque production via `as`. `construct()` derives `fabricate`
+ * from this data — no variant carries its own closure until it's built.
  *
- * `$Meta` is generic (defaulting to the full `Meta` union) so builder
- * return types stay narrow — e.g. `T.number.integer.sequence` types as
- * `Schema<{ sequence: true; integer: true }>`, not the widened `Schema`, so
- * a downstream conditional (`ToTypeBox`) can still tell an integer schema
- * apart from a bare one.
+ * `$Meta` is generic (defaulting to the full `Meta` union) so builder return
+ * types stay narrow — e.g. `T.number.integer.sequence` types as `Schema<{
+ * sequence: true; integer: true }>`, not the widened `Schema`, so a downstream
+ * conditional (`ToTypeBox`) can still tell an integer schema apart from a bare
+ * one.
  */
 export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends Adaptations = {}> extends Core<$Meta, $Adaptations> {
     /**
@@ -24,8 +23,8 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
      */
     as: (produce: Produce<Fabricated>, hints?: JsonSchema) => 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/number/Types.d.ts

@@ -4,9 +4,9 @@ import type { Distribution } from "../../Distribution";
 import type { Produce } from "../../Random/Types";
 import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 /**
- * Call-site `{ min, max }` — scalars are inclusive. Either end may be
- * omitted; a missing end is unbounded (the same policy as a bare
- * `T.number`), not a default of `0`.
+ * Call-site `{ min, max }` — scalars are inclusive. Either end may be omitted;
+ * a missing end is unbounded (the same policy as a bare `T.number`), not a
+ * default of `0`.
  */
 export type InputWhereby = {
     min?: InputBound<number> | undefined;
@@ -14,8 +14,8 @@ export type InputWhereby = {
     distribution?: Distribution | undefined;
 };
 /**
- * Stored `{ min, max }` — each present end is a canonical {@link Bound}.
- * An omitted end stays omitted (fabricate fills the unbounded cap; adapters
+ * Stored `{ min, max }` — each present end is a canonical {@link Bound}. An
+ * omitted end stays omitted (fabricate fills the unbounded cap; adapters
  * forward only the ends that were named).
  */
 export type Whereby = {
@@ -27,19 +27,19 @@ export type Fabricated = number;
 /**
  * JSON-Schema keywords that constrain a number value — carried as neutral,
  * schema-library-agnostic hints (see the builder's `as`). The numeric range
- * lives on `whereby` as {@link Bound}s, which adapters forward; `hints`
- * holds only the orthogonal constraints not expressible there.
+ * lives on `whereby` as {@link Bound}s, which adapters forward; `hints` holds
+ * only the orthogonal constraints not expressible there.
  */
 export type JsonSchema = {
     multipleOf?: number;
 };
 /**
- * A ranged number — `whereby` is absent on the full-range form, `integer`
- * (a literal, not widened to `boolean`) selects whole-number semantics, or
- * a sequence counter (`sequence`, always paired with `integer: true`, since
- * a counter only ever yields whole numbers), optionally overridden by an
- * opaque `as` production — carried alongside the rest rather than replacing
- * it, so a prior scoping survives `as` for future validation.
+ * A ranged number — `whereby` is absent on the full-range form, `integer` (a
+ * literal, not widened to `boolean`) selects whole-number semantics, or a
+ * sequence counter (`sequence`, always paired with `integer: true`, since a
+ * counter only ever yields whole numbers), optionally overridden by an opaque
+ * `as` production — carried alongside the rest rather than replacing it, so a
+ * prior scoping survives `as` for future validation.
  */
 export type Meta = {
     whereby?: Whereby;

package/dist/types/Primitive/number/defaults.d.ts

@@ -1,8 +1,8 @@
 import type { Bound } from "../../Bound";
 /**
- * Inclusive caps a missing `whereby` end draws against. Not stored on the
- * bare schema — `T.number` / `T.number.integer` carry no `whereby` until
- * one is named, and an omitted end stays omitted on `[Meta]`.
+ * Inclusive caps a missing `whereby` end draws against. Not stored on the bare
+ * schema — `T.number` / `T.number.integer` carry no `whereby` until one is
+ * named, and an omitted end stays omitted on `[Meta]`.
  */
 export declare const unboundedContinuous: {
     min: Bound<number>;

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

@@ -22,8 +22,8 @@ export type Fabricator<$Schema extends {
      * never drawing fresh (see `Fabricator()` below). `config.validate` defaults
      * to `true`, delegated to `schema.override(overrides)`'s existing recursive
      * checks (result unused); `{ validate: false }` skips that — used internally
-     * when recursing into an already-validated nested override, also available
-     * to a caller who already knows their overrides are valid.
+     * when recursing into an already-validated nested override, also available to
+     * a caller who already knows their overrides are valid.
      */
     fabricate: (overrides?: Override<$Schema[typeof Meta]["definition"]>, config?: {
         validate?: boolean;
@@ -36,21 +36,21 @@ export type Fields = Record<string, BaseFabricator<unknown>>;
  * built by `Constructor.ts` — which owns recursion into nested Schemas, so
  * `object` never calls `construct()` and there's no import cycle with
  * `Constructor.ts`. Schema-baked `.override()`-marked fields (`[Fixed]` in
- * `Types.ts`) are already resolved into literal-valued `fields` entries
- * before they reach here. `fabricate`'s `overrides` (below) is a separate
- * per-call mechanism; the two compose.
+ * `Types.ts`) are already resolved into literal-valued `fields` entries before
+ * they reach here. `fabricate`'s `overrides` (below) is a separate per-call
+ * mechanism; the two compose.
  *
  * `schema` is echoed as `.schema` unchanged — callers wanting a
- * `toSchema`-normalized Fabricator (no `extend`/`refine`/`override`) pass
- * that; `Constructor.ts`'s `make` passes `object.rehydrate(...)` so a
- * top-level built Fabricator's `.schema` still composes.
+ * `toSchema`-normalized Fabricator (no `extend`/`refine`/`override`) pass that;
+ * `Constructor.ts`'s `make` passes `object.rehydrate(...)` so a top-level built
+ * Fabricator's `.schema` still composes.
  *
- * A compute-kind field (from `.refine()`) needs the rest of the object
- * already fabricated (`object/compute/Fabricator.ts`), which isn't available
- * until every ordinary field has resolved. Two phases: ordinary fields
- * first, then compute fields against the accumulated result, in definition
- * order (a compute field can see an earlier compute field's value, not a
- * later one) — unless covered by `overrides`, in which case it resolves in
- * phase 1 like any other overridden field.
+ * A compute-kind field (from `.refine()`) needs the rest of the object already
+ * fabricated (`object/compute/Fabricator.ts`), which isn't available until
+ * every ordinary field has resolved. Two phases: ordinary fields first, then
+ * compute fields against the accumulated result, in definition order (a compute
+ * field can see an earlier compute field's value, not a later one) — unless
+ * covered by `overrides`, in which case it resolves in phase 1 like any other
+ * overridden field.
  */
 export declare function Fabricator<$Definition extends Definition>(context: FabricatorContext<Schema<$Definition>>, fields: Fields): Fabricator<Schema<$Definition>>;

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

@@ -4,20 +4,20 @@ import { Schema } from "./Schema";
 import type { Definition, Meta as ThisMeta } from "./Types";
 /**
  * Rebuild a full `object` Schema — with `extend`/`refine` restored — from
- * anything already reduced to this kind's `[Meta]` (a bare Schema, or a
- * built Fabricator normalized via `toSchema`). `toSchema` alone only keeps
+ * anything already reduced to this kind's `[Meta]` (a bare Schema, or a built
+ * Fabricator normalized via `toSchema`). `toSchema` alone only keeps
  * `[Kind]`/`[Meta]`, enough to fabricate from but not to derive a subtype —
  * this is what lets a built Fabricator's `.schema` still compose via
  * `extend`/`refine` (`Constructor.ts`'s `make`). Reattaches `produce` via
- * `.as(...)` when present, so a `toSchema`-stripped, `.as(...)`-produced
- * schema doesn't lose its custom producer — and carries `[Adaptation]` for
- * the same reason: without it, `.override(...)` on a nested adapted
- * `object` field (which round-trips through here) and a built Fabricator's
- * `.schema` would both silently come back unadapted.
+ * `.as(...)` when present, so a `toSchema`-stripped, `.as(...)`-produced schema
+ * doesn't lose its custom producer — and carries `[Adaptation]` for the same
+ * reason: without it, `.override(...)` on a nested adapted `object` field
+ * (which round-trips through here) and a built Fabricator's `.schema` would
+ * both silently come back unadapted.
  */
 export declare function rehydrate<$Definition extends Definition, $Adaptations extends Adaptations = {}>(schema: {
     [Meta]: ThisMeta<$Definition>;
     readonly [Adaptation]?: $Adaptations;
 }): Schema<$Definition, $Adaptations>;
+declare const _default: <const $Definition extends Definition>(definition: $Definition) => Schema<$Definition>;
 export default _default;
-declare function _default<const $Definition extends Definition>(definition: $Definition): Schema<$Definition>;

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

@@ -17,25 +17,25 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      * Layer an opaque production on this schema's existing `[Meta]` — carrying
      * `definition`/`refinements` forward, not discarding them, so
      * `extend`/`refine`/`override` keep working (they drop the custom producer
-     * again, falling back to definition-based fabrication) and a later
-     * `.as(...)` (or future validation of `produce`) still has the definition
-     * to check against.
+     * again, falling back to definition-based fabrication) and a later `.as(...)`
+     * (or future validation of `produce`) still has the definition 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.
-     * Carried through `extend`/`refine`/`override`, which all reduce to a
-     * fresh `make(...)` (`Registry.ts`) over this same schema.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract. Carried through
+     * `extend`/`refine`/`override`, which all reduce to a fresh `make(...)`
+     * (`Registry.ts`) over this same schema.
      */
     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>>>;
 }
 /**
- * Unlike every other kind, `adapt` is *not* added here but by `Registry.ts`'s
+ * Unlike every other kind, `adapt` is _not_ added here but by `Registry.ts`'s
  * `make` alongside `extend`/`refine`/`override`: those three rebuild from
  * `definition`/`refinements` rather than deriving from this object, so the
- * adaptation map has to be threaded through `make` itself or chaining one
- * of them would drop it (see `make`'s `adapt`).
+ * adaptation map has to be threaded through `make` itself or chaining one of
+ * them would drop it (see `make`'s `adapt`).
  */
 export declare function Schema<$Definition extends Definition, $Adaptations extends Adaptations = {}>(schema: Omit<Schema<$Definition, $Adaptations>, "as">): Schema<$Definition, $Adaptations>;
 export declare function isObjectSchema(candidate: AnySchema): candidate is Schema;

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

@@ -8,10 +8,10 @@ export type Definition<$Schema = AnySchema> = {
     [_ in string]: $Schema;
 };
 /**
- * Constraint for a refinement's values. The source schema differs per
- * property, so it must be `any` (not `AnySchema`) to stay assignable across
- * every property's own `$Source`. Constraint only: precise types still flow
- * via `$Refinement`.
+ * Constraint for a refinement's values. The source schema differs per property,
+ * so it must be `any` (not `AnySchema`) to stay assignable across every
+ * property's own `$Source`. Constraint only: precise types still flow via
+ * `$Refinement`.
  */
 export type Refinement<$Definition extends Definition> = Definition<ComputeSchema<Fabricated<$Definition>, any>>;
 export type Extender<$Definition extends Definition, $Extension extends Definition> = (params: {
@@ -21,12 +21,11 @@ export type Refinements = ReadonlyArray<Definition>;
 /**
  * Every `object.omittable`- or `object.optional`-kind field's key, so
  * `Fabricated` can mark exactly those `?:` instead of required — matching
- * runtime, where a field whose roll lands on omission never has its key
- * appear (`object/omittable/Fabricator.ts`, `object/optional/Fabricator.ts`).
+ * runtime, where a field whose roll lands on omission never has its key appear
+ * (`object/omittable/Fabricator.ts`, `object/optional/Fabricator.ts`).
  * `object.optional`'s `ValueOf` already carries `| undefined` (its
- * `Fabricated`), so combined with the `?:` here a field lands on
- * `{ a?: T | undefined }` — omitted, present-as-`undefined`, or
- * present-with-a-value.
+ * `Fabricated`), so combined with the `?:` here a field lands on `{ a?: T |
+ * undefined }` — omitted, present-as-`undefined`, or present-with-a-value.
  */
 type OmittableKeys<$Definition extends Definition> = {
     [$K in keyof $Definition]: $Definition[$K] extends {
@@ -39,19 +38,18 @@ export type Fabricated<$Definition extends Definition, $Bindings extends unknown
     [$K in OmittableKeys<$Definition>]?: ValueOf<$Definition[$K], $Bindings>;
 }>;
 /**
- * The shape `.override()` accepts: every field optional, so a present key
- * skips generation for that field. A nested `object`-kind field recurses
- * into its own `Override` (deep-merge); an `object.omittable` or
- * `object.optional` field additionally accepts `Omitted`, to force that
- * field off rather than only forcing a value on (`object.optional` already
- * accepts `undefined` via `ValueOf`); every other field — including
- * `object.compute` — is a full-replacement leaf, typed as whatever it
- * fabricates to (`ValueOf`).
+ * The shape `.override()` accepts: every field optional, so a present key skips
+ * generation for that field. A nested `object`-kind field recurses into its own
+ * `Override` (deep-merge); an `object.omittable` or `object.optional` field
+ * additionally accepts `Omitted`, to force that field off rather than only
+ * forcing a value on (`object.optional` already accepts `undefined` via
+ * `ValueOf`); every other field — including `object.compute` — is a
+ * full-replacement leaf, typed as whatever it fabricates to (`ValueOf`).
  *
  * Checked via a bare structural `[Kind]`/`[Meta]` shape, never `Schema`/
- * `Fabricator` — either carries `refine`'s contravariant use of
- * `$Definition`, and referencing it here would leak that contravariance
- * into every recursive `Override` instantiation.
+ * `Fabricator` — either carries `refine`'s contravariant use of `$Definition`,
+ * and referencing it here would leak that contravariance into every recursive
+ * `Override` instantiation.
  */
 export type Override<$Definition extends Definition> = Pretty<{
     [$K in keyof $Definition]?: $Definition[$K] extends {
@@ -64,8 +62,8 @@ export type Override<$Definition extends Definition> = Pretty<{
     } ? ValueOf<$Definition[$K]> | typeof Omitted : ValueOf<$Definition[$K]>;
 }>;
 /**
- * `definition`/`refinements` stay required regardless of `produce` — an
- * opaque `as` production layers on top rather than replacing them, so
+ * `definition`/`refinements` stay required regardless of `produce` — an opaque
+ * `as` production layers on top rather than replacing them, so
  * `extend`/`refine`/`override` and `ToTypeBox`'s structural derivation keep
  * working, and a prior definition survives `as` for future validation of
  * `produce`.

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

@@ -22,10 +22,9 @@ export type Fabricator<$Fabricated, $Source extends Source, $Adaptations extends
 export declare function isObjectComputeFabricator(candidate: BaseFabricator<unknown>): candidate is Fabricator<unknown, Source>;
 /**
  * Turn an `object.compute` Schema into a live Fabricator. Unlike every other
- * kind, there's nothing of `source` to build here — a computed field's
- * value comes entirely from `resolve`, given the rest of the object. The
- * node still records `trace` so it can be rebuilt from a parent field's
- * captured trace; `.fabricate()` without the parent object throws
- * `DetachedComputeError`.
+ * kind, there's nothing of `source` to build here — a computed field's value
+ * comes entirely from `resolve`, given the rest of the object. The node still
+ * records `trace` so it can be rebuilt from a parent field's captured trace;
+ * `.fabricate()` without the parent object throws `DetachedComputeError`.
  */
 export declare function Fabricator<$Fabricated, $Source extends Source>(context: FabricatorContext<Schema<$Fabricated, $Source>>): Fabricator<$Fabricated, $Source>;

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

@@ -10,10 +10,10 @@ export type Computer<$Definition extends object.Definition> = <const $Source ext
 };
 export interface Schema<$Fabricated, $Source extends Source, $Adaptations extends Adaptations = {}> extends Core<$Fabricated, $Source, $Adaptations> {
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
-     * Adapting the computed field itself, rather than the `source` it derives
-     * its shape from, is the way to say the two differ.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract. Adapting the
+     * computed field itself, rather than the `source` it derives its shape from,
+     * is the way to say the two differ.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Fabricated, $Source, $Adaptations>>) => $Returnable) => Schema<$Fabricated, $Source, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -3,22 +3,22 @@ import type { AnySchema, ValueOf } from "../../../Schema/Types";
 import { Kind, type Adaptation, type Meta, type Produces } from "../../../Types";
 /**
  * A builder that can mint a Schema via `as` — e.g. `T.string`, `T.bigint`.
- * `compute` accepts one alongside a plain Schema so a caller needn't
- * satisfy a `whereby` just to name a computed field's type: the resolver
- * supplies the value, so the field's length/range is irrelevant.
+ * `compute` accepts one alongside a plain Schema so a caller needn't satisfy a
+ * `whereby` just to name a computed field's type: the resolver supplies the
+ * value, so the field's length/range is irrelevant.
  */
 export type Builder<$Schema extends AnySchema = AnySchema> = {
     [Kind]: $Schema[typeof Kind];
     as: (produce: () => any) => $Schema;
 };
 /**
- * A `compute` source: the Schema whose value and shape a computed field
- * adopts, or a builder that denotes one.
+ * A `compute` source: the Schema whose value and shape a computed field adopts,
+ * or a builder that denotes one.
  */
 export type Source = AnySchema | Builder;
 /**
- * The Schema a source denotes: a plain Schema is itself; a builder is
- * the Schema its `as` mints.
+ * The Schema a source denotes: a plain Schema is itself; a builder is the
+ * Schema its `as` mints.
  */
 export type Denoted<$Source> = $Source extends AnySchema ? $Source : $Source extends Builder<infer $Schema> ? $Schema : never;
 /**
@@ -26,20 +26,19 @@ export type Denoted<$Source> = $Source extends AnySchema ? $Source : $Source ext
  */
 export type Resolved<$Source, $Bindings extends unknown[] = []> = ValueOf<Denoted<$Source>, $Bindings>;
 /**
- * Source and resolver are stored raw — the source whether a Schema or a
- * builder (both carry a `[Kind]`, which is all schema derivation needs),
- * and the resolver as plain data from the moment
- * `compute(source).as(resolve)` is called: `compute` never builds anything,
- * so unlike a Fabricator's closure there's nothing lossy about storing it.
- * `source` is only used for its shape/type (`Adapter/TypeBox` reflects a
- * computed field as its source's shape, unless the field itself is
- * adapted) — the resolver draws entirely from `fabricated`, never from
- * `source`, which may not even have a buildable recipe (a bare
- * `T.string`/`T.bigint`).
+ * Source and resolver are stored raw — the source whether a Schema or a builder
+ * (both carry a `[Kind]`, which is all schema derivation needs), and the
+ * resolver as plain data from the moment `compute(source).as(resolve)` is
+ * called: `compute` never builds anything, so unlike a Fabricator's closure
+ * there's nothing lossy about storing it. `source` is only used for its
+ * shape/type (`Adapter/TypeBox` reflects a computed field as its source's
+ * shape, unless the field itself is adapted) — the resolver draws entirely from
+ * `fabricated`, never from `source`, which may not even have a buildable recipe
+ * (a bare `T.string`/`T.bigint`).
  *
- * Unlike every other kind's `Meta`, this one is generic over the *enclosing
- * object's* fabricated type as well as the source — that is what the
- * resolver is handed.
+ * Unlike every other kind's `Meta`, this one is generic over the _enclosing
+ * object's_ fabricated type as well as the source — that is what the resolver
+ * is handed.
  */
 export type Meta<$Fabricated, $Source extends Source> = {
     source: $Source;

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

@@ -16,22 +16,22 @@ export type Fabricator<$Schema extends {
     [Children]: BaseFabricator<any>;
     readonly [Adaptation]?: AdaptationsOf<$Schema>;
     /**
-     * `Omitted` on the empty roll (or when an `.as(...)` producer returns it)
-     * — read only by `object/Fabricator.ts`'s fabricate loop, which omits the
-     * key entirely rather than writing `undefined`. Fabricating this outside
-     * a parent `object` hands the sentinel straight back.
+     * `Omitted` on the empty roll (or when an `.as(...)` producer returns it) —
+     * read only by `object/Fabricator.ts`'s fabricate loop, which omits the key
+     * entirely rather than writing `undefined`. Fabricating this outside a parent
+     * `object` hands the sentinel straight back.
      */
     fabricate: () => Resolved<$Schema[typeof Meta]["definition"]>;
 };
 export declare function isObjectOmittableFabricator(candidate: BaseFabricator<unknown>): candidate is Fabricator;
 /**
- * A presence roll on this field's private stream, drawn only when present
- * is decided — an omission roll never advances `source`'s stream, and since
+ * A presence roll on this field's private stream, drawn only when present is
+ * decided — an omission roll never advances `source`'s stream, and since
  * `source` is already dispatched into its own independent stream by
- * `Constructor.ts` regardless of this roll, skipping its draw here can
- * never perturb any other field's reproducibility (`Random/index.ts`'s
+ * `Constructor.ts` regardless of this roll, skipping its draw here can never
+ * perturb any other field's reproducibility (`Random/index.ts`'s
  * `toStreamFromTrace`: every field's stream is private from the moment it's
- * minted). 50/50 by default; `.weighted(...)` (`Schema.ts`) reweights
- * either outcome relative to that same default of `1`.
+ * minted). 50/50 by default; `.weighted(...)` (`Schema.ts`) reweights either
+ * outcome relative to that same default of `1`.
  */
 export declare function Fabricator<$Definition extends Definition>(context: FabricatorContext<Schema<$Definition>>, source: BaseFabricator<any>): Fabricator<Schema<$Definition>>;

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

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

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

@@ -6,25 +6,25 @@ import type { Core, Definition, Resolved, Weights } 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
-     * `definition` forward, not discarding it, so a later `.as(...)` (or
-     * future validation of `produce`) still has it to check against.
-     * `produce` may return `Omitted`, so custom presence logic composes the
-     * same way the built-in roll does.
+     * `definition` forward, not discarding it, so a later `.as(...)` (or future
+     * validation of `produce`) still has it to check against. `produce` may
+     * return `Omitted`, so custom presence logic composes the same way the
+     * built-in roll does.
      */
     as: (produce: Produce<Resolved<$Definition>>) => Schema<$Definition, $Adaptations>;
     /**
      * Reweight the built-in presence roll. Keys are optional — an omitted key
-     * keeps baseline weight `1`, the same weight the 50/50 split already uses
-     * — but that baseline is still relative to whatever else is specified, so
+     * keeps baseline weight `1`, the same weight the 50/50 split already uses —
+     * but that baseline is still relative to whatever else is specified, so
      * `.weighted({ omitted: 0.1 })` shifts both outcomes' shares, not just
-     * `omitted`'s (see `Types.ts`'s `Weights`). Chaining `.weighted(...)`
-     * merges into previous weights rather than replacing them, the same
-     * layering `.as(...)` uses for `produce`.
+     * `omitted`'s (see `Types.ts`'s `Weights`). Chaining `.weighted(...)` merges
+     * into previous weights rather than replacing them, the same layering
+     * `.as(...)` uses for `produce`.
      */
     weighted: (weights: Weights) => Schema<$Definition, $Adaptations>;
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Definition, $Adaptations>>) => $Returnable) => Schema<$Definition, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -3,32 +3,31 @@ import type { Produce } from "../../../Random/Types";
 import type { AnySchema, ValueOf } from "../../../Schema/Types";
 import { Kind, Meta, Omitted, type Adaptation, type Produces } from "../../../Types";
 /**
- * The wrapped field's own Schema — the value type an omittable field
- * produces when its presence roll comes up present.
+ * The wrapped field's own Schema — the value type an omittable field produces
+ * when its presence roll comes up present.
  */
 export type Definition = AnySchema;
 export type Fabricated<$Definition extends Definition, $Bindings extends unknown[] = []> = ValueOf<$Definition, $Bindings>;
 /**
- * What an omittable field's Fabricator returns: the wrapped value, or
- * `Omitted` when it should not appear — whether from the built-in presence
- * roll or, via `.as(...)`, an opaque producer.
+ * What an omittable field's Fabricator returns: the wrapped value, or `Omitted`
+ * when it should not appear — whether from the built-in presence roll or, via
+ * `.as(...)`, an opaque producer.
  */
 export type Resolved<$Definition extends Definition> = Fabricated<$Definition> | typeof Omitted;
 export type { Outcome } from "./Outcomes";
 /**
- * Relative weights for `.weighted(...)`, keyed by `Outcome`. Keys optional —
- * an omitted key falls back to baseline `1`, the same weight the 50/50
- * split already uses. Values are relative, exactly like `weighted()`
+ * Relative weights for `.weighted(...)`, keyed by `Outcome`. Keys optional — an
+ * omitted key falls back to baseline `1`, the same weight the 50/50 split
+ * already uses. Values are relative, exactly like `weighted()`
  * (`Distribution/index.ts`) — they need not sum to one, and are fed to
  * `weighted()` unchanged alongside each unspecified key's baseline `1`.
  *
- * Specifying one outcome's weight shifts the *other* outcome's resulting
- * probability too, even though its weight stays at `1` — its share of the
- * total still moves, since the total changed. `.weighted({ omitted: 0.1 })`
- * is not "10% omitted, 90% present" — with `value` at default `1`, the
- * split is `0.1 / 1.1 ≈ 9.1%` omitted, `≈90.9%` present. No independent
- * "absolute probability" mode; weights are only meaningful relative to the
- * full set in play.
+ * Specifying one outcome's weight shifts the _other_ outcome's resulting
+ * probability too, even though its weight stays at `1` — its share of the total
+ * still moves, since the total changed. `.weighted({ omitted: 0.1 })` is not
+ * "10% omitted, 90% present" — with `value` at default `1`, the split is `0.1 /
+ * 1.1 ≈ 9.1%` omitted, `≈90.9%` present. No independent "absolute probability"
+ * mode; weights are only meaningful relative to the full set in play.
  */
 export type Weights = {
     omitted: number;