@ghostry/fabricator 0.0.1 → 0.0.2

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

@@ -3,10 +3,10 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Items } from "./Types";
 /**
- * Buildable `choice` recipe: a weighted set of option Schemas, one of which
- * is drawn (and only then dispatched into a value) each fabrication. No
- * bare form — see `Registry.ts`'s `uniform`/`weighted`, the only way to
- * reach this Schema.
+ * Buildable `choice` recipe: a weighted set of option Schemas, one of which is
+ * drawn (and only then dispatched into a value) each fabrication. No bare form
+ * — see `Registry.ts`'s `uniform`/`weighted`, the only way to reach this
+ * Schema.
  */
 export interface Schema<$Items extends Items = Items, $Adaptations extends Adaptations = {}> extends Core<$Items, $Adaptations> {
     /**
@@ -16,8 +16,8 @@ export interface Schema<$Items extends Items = Items, $Adaptations extends Adapt
      */
     as: (produce: Produce<Fabricated<$Items>>) => Schema<$Items, $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<$Items, $Adaptations>>) => $Returnable) => Schema<$Items, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -5,22 +5,22 @@ import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 /** The schemas a `choice` can draw from. */
 export type Item = AnySchema;
 /**
- * A *tuple* of `[weight, option]` pairs, one per position — not a flattened
- * `ReadonlyArray<[number, Item]>`, which would remember only the union of
- * every option's type and lose how many options there were (two identical
- * option types would collapse to one union member). The real tuple is what
- * lets `Adapter/TypeBox` mirror TypeBox's `Union<T>` — which collapses to a
- * bare schema for a single option and only wraps in `TUnion<T>` for two or
- * more — instead of always wrapping regardless of count.
+ * A _tuple_ of `[weight, option]` pairs, one per position — not a flattened
+ * `ReadonlyArray<[number, Item]>`, which would remember only the union of every
+ * option's type and lose how many options there were (two identical option
+ * types would collapse to one union member). The real tuple is what lets
+ * `Adapter/TypeBox` mirror TypeBox's `Union<T>` — which collapses to a bare
+ * schema for a single option and only wraps in `TUnion<T>` for two or more —
+ * instead of always wrapping regardless of count.
  */
 export type Items = ReadonlyArray<readonly [number, Item]>;
 export type Fabricated<$Items extends Items = Items, $Bindings extends unknown[] = []> = ValueOf<$Items[number][1], $Bindings>;
 /**
  * Always stored as weighted pairs — `.uniform(...)` (`Registry.ts`) is
- * `.weighted(...)` with every item given weight `1`, so there is only one
- * shape to fabricate from. `produce` layers an opaque production via
- * `.as()`, carried alongside `items` rather than replacing it, so a prior
- * option set survives `.as()` for future validation.
+ * `.weighted(...)` with every item given weight `1`, so there is only one shape
+ * to fabricate from. `produce` layers an opaque production via `.as()`, carried
+ * alongside `items` rather than replacing it, so a prior option set survives
+ * `.as()` for future validation.
  */
 export type Meta<$Items extends Items = Items> = {
     items: $Items;

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

@@ -1,44 +1,32 @@
 import type { Adaptations } from "../../Adapter/Types";
 import { type InputBound } from "../../Bound";
 import { type Distribution } from "../../Distribution";
-import { Adaptation, Kind, Meta, Produces } from "../../Types";
 import { Schema } from "./Schema";
-import type { Fabricated, Whereby } from "./Types";
-declare const _default: {
-    [Kind]: "date";
-    [Meta]: {};
-    [Produces]?: Fabricated;
-    [Adaptation]?: Adaptations;
-    as: (produce: import("../../Random/Types").Produce<Fabricated>) => 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 { Whereby } from "./Types";
+type ThisRegistry = Schema<{}, Adaptations> & {
+    /**
+     * A `Date` drawn from `[min, max]`. Pass a `distribution` to shape how values
+     * cluster within the range; without one, every instant is equally likely.
+     */
     whereby: (whereby: {
         min: InputBound<Date>;
         max: InputBound<Date>;
         distribution?: Distribution | undefined;
     }) => Schema<{
         whereby: Whereby;
-    }, {}>;
-    /** Any `Date` from the earliest representable instant up to the present moment. */
-    past: {
-        [Kind]: "date";
-        [Meta]: {
-            mode: "past";
-        };
-        [Produces]?: Fabricated;
-        [Adaptation]?: {};
-        as: (produce: import("../../Random/Types").Produce<Fabricated>) => Schema<{
-            mode: "past";
-        }, {}>;
-        adapt: <const $Adapter extends import("../..").Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: import("../..").Adapting<Schema<{
-            mode: "past";
-        }, {}>>) => $Returnable) => Schema<{
-            mode: "past";
-        }, import("../../Adapter/Types").WithAdaptations<{}, import("../../Adapter/Core").AdaptationEntry<$Adapter, $Returnable>>>;
+    }>;
+    /**
+     * Any `Date` from the earliest representable instant up to the present
+     * moment.
+     */
+    past: Schema<{
+        mode: "past";
+    }> & {
         /**
          * A past `Date` drawn from `[min, now]`. `min` defaults to the earliest
          * representable instant. The implicit `now` end stays inclusive. Pass a
-         * `distribution` to shape how values cluster within the range; without
-         * one, every instant is equally likely.
+         * `distribution` to shape how values cluster within the range; without one,
+         * every instant is equally likely.
          */
         whereby: (whereby: {
             min?: InputBound<Date> | undefined;
@@ -46,29 +34,17 @@ declare const _default: {
         }) => Schema<{
             mode: "past";
             whereby: Whereby;
-        }, {}>;
+        }>;
     };
     /** Any `Date` from the present moment up to the latest representable instant. */
-    future: {
-        [Kind]: "date";
-        [Meta]: {
-            mode: "future";
-        };
-        [Produces]?: Fabricated;
-        [Adaptation]?: {};
-        as: (produce: import("../../Random/Types").Produce<Fabricated>) => Schema<{
-            mode: "future";
-        }, {}>;
-        adapt: <const $Adapter extends import("../..").Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: import("../..").Adapting<Schema<{
-            mode: "future";
-        }, {}>>) => $Returnable) => Schema<{
-            mode: "future";
-        }, import("../../Adapter/Types").WithAdaptations<{}, import("../../Adapter/Core").AdaptationEntry<$Adapter, $Returnable>>>;
+    future: Schema<{
+        mode: "future";
+    }> & {
         /**
          * A future `Date` drawn from `[now, max]`. `max` defaults to the latest
          * representable instant. The implicit `now` end stays inclusive. Pass a
-         * `distribution` to shape how values cluster within the range; without
-         * one, every instant is equally likely.
+         * `distribution` to shape how values cluster within the range; without one,
+         * every instant is equally likely.
          */
         whereby: (whereby: {
             max?: InputBound<Date> | undefined;
@@ -76,7 +52,8 @@ declare const _default: {
         }) => Schema<{
             mode: "future";
             whereby: Whereby;
-        }, {}>;
+        }>;
     };
 };
-export default _default;
+declare const registry: ThisRegistry;
+export default registry;

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

@@ -4,24 +4,23 @@ import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Meta as ThisMeta } from "./Types";
 /**
  * Buildable `Date` recipe: a range/distribution (`whereby`, absent for the
- * full-range bare form), optionally scoped by `mode` to `"past"` (up to now)
- * or `"future"` (from now), or opaque production via `as`.
+ * full-range bare form), optionally scoped by `mode` to `"past"` (up to now) or
+ * `"future"` (from now), or opaque production via `as`.
  *
- * `$Meta` is generic (defaulting to the full `Meta` union) so builder
- * return types stay narrow — e.g. `T.date.past` types as
- * `Schema<{ mode: "past" }>`, not the widened `Schema` — see
- * `number/Schema.ts`.
+ * `$Meta` is generic (defaulting to the full `Meta` union) so builder return
+ * types stay narrow — e.g. `T.date.past` types as `Schema<{ mode: "past" }>`,
+ * not the widened `Schema` — see `number/Schema.ts`.
  */
 export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends Adaptations = {}> extends Core<$Meta, $Adaptations> {
     /**
      * Layer an opaque production on this schema's existing `[Meta]` — carrying
-     * `mode`/`whereby` forward, not discarding them, so a later `.as(...)`
-     * (or future validation of `produce`) still has them to check against.
+     * `mode`/`whereby` forward, not discarding them, so a later `.as(...)` (or
+     * future validation of `produce`) still has them to check against.
      */
     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/date/Types.d.ts

@@ -16,10 +16,10 @@ export type Whereby = {
 export type Fabricated = Date;
 /**
  * A range/distribution (`whereby`, absent for the full-range bare form),
- * optionally scoped by `mode` to `"past"` (up to now) or `"future"` (from
- * now), optionally overridden by an opaque `as` production — carried
- * alongside the rest rather than replacing it, so a prior scoping survives
- * `as` for future validation.
+ * optionally scoped by `mode` to `"past"` (up to now) or `"future"` (from now),
+ * 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 = {
     mode?: "past" | "future";

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

@@ -5,34 +5,34 @@ import type { Item, Items } from "./Types";
  * per-position member 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-member — see `Types.ts`'s `Items`. The
- * same helper `choice/Registry.ts` uses, for the same reason.
+ * `Adapter/TypeBox` recover real arity later and mirror TypeBox's `Union<T>`
+ * collapse-for-a-single-member — see `Types.ts`'s `Items`. The same helper
+ * `choice/Registry.ts` uses, for the same reason.
  */
 type Weighted<$Items extends ReadonlyArray<Item>> = {
     [$K in keyof $Items]: readonly [number, $Items[$K]];
 };
 /**
  * At least one element — an empty `enum` has no member 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.
+ * 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 member. 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 members, given as `[weight, item]` pairs —
-     * the same tuple shape `weighted()` (`Distribution/index.ts`) itself
-     * accepts, not an object keyed by member.
+     * Relative probability across members, given as `[weight, item]` pairs — the
+     * same tuple shape `weighted()` (`Distribution/index.ts`) itself accepts, not
+     * an object keyed by member.
      */
     weighted: <const $Items extends NonEmpty<Items[number]>>(items: $Items) => Schema<$Items>;
 };

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

@@ -3,9 +3,9 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Items } from "./Types";
 /**
- * The buildable recipe for an `enum`: a weighted set of member values, one
- * of which is drawn each fabrication. There is no bare form — see
- * `Registry.ts`'s `uniform`/`weighted`, the only way to reach this Schema.
+ * The buildable recipe for an `enum`: a weighted set of member values, one of
+ * which is drawn each fabrication. There is no bare form — see `Registry.ts`'s
+ * `uniform`/`weighted`, the only way to reach this Schema.
  */
 export interface Schema<$Items extends Items = Items, $Adaptations extends Adaptations = {}> extends Core<$Items, $Adaptations> {
     /**
@@ -15,8 +15,8 @@ export interface Schema<$Items extends Items = Items, $Adaptations extends Adapt
      */
     as: (produce: Produce<Fabricated<$Items>>) => Schema<$Items, $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<$Items, $Adaptations>>) => $Returnable) => Schema<$Items, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -2,35 +2,33 @@ import type { Adaptations } from "../../Adapter/Types";
 import type { Produce } from "../../Random/Types";
 import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 /**
- * The values an `enum` can draw from — any value at all, for the same
- * reason `always.Value` is unconstrained (see its doc).
+ * The values an `enum` can draw from — any value at all, for the same reason
+ * `always.Value` is unconstrained (see its doc).
  *
- * What still separates `enum` from `choice`: an `enum` draws one of these
- * exact *values*; a `choice` draws one of these *schemas* and fabricates
- * from it.
+ * What still separates `enum` from `choice`: an `enum` draws one of these exact
+ * _values_; a `choice` draws one of these _schemas_ and fabricates from it.
  */
 export type Item = unknown;
 /**
- * A *tuple* of `[weight, item]` pairs, one per position — not a flattened
- * `ReadonlyArray<[number, Item]>`, which would remember only the union of
- * every member's type and lose how many members there were (two identical
- * member types would collapse to one union member). The real tuple is what
- * lets `Adapter/TypeBox` mirror TypeBox's `Union<T>` — which collapses to a
- * bare schema for a single member and only wraps in `TUnion<T>` for two or
- * more — instead of mapping each member independently and losing the union
- * wrapper.
+ * A _tuple_ of `[weight, item]` pairs, one per position — not a flattened
+ * `ReadonlyArray<[number, Item]>`, which would remember only the union of every
+ * member's type and lose how many members there were (two identical member
+ * types would collapse to one union member). The real tuple is what lets
+ * `Adapter/TypeBox` mirror TypeBox's `Union<T>` — which collapses to a bare
+ * schema for a single member and only wraps in `TUnion<T>` for two or more —
+ * instead of mapping each member independently and losing the union wrapper.
  *
- * Identical shape to `choice.Items`; the two kinds differ only in what sits
- * on the right of each pair (a value here, a Schema there).
+ * Identical shape to `choice.Items`; the two kinds differ only in what sits on
+ * the right of each pair (a value here, a Schema there).
  */
 export type Items = ReadonlyArray<readonly [number, Item]>;
 export type Fabricated<$Items extends Items = Items> = $Items[number][1];
 /**
  * Always stored as weighted pairs — `.uniform(...)` (`Registry.ts`) is
- * `.weighted(...)` with every item given weight `1`, so there is only one
- * shape to fabricate from. `produce` layers an opaque production via
- * `.as()`, carried alongside `items` rather than replacing it, so a prior
- * member set survives `.as()` for future validation.
+ * `.weighted(...)` with every item given weight `1`, so there is only one shape
+ * to fabricate from. `produce` layers an opaque production via `.as()`, carried
+ * alongside `items` rather than replacing it, so a prior member set survives
+ * `.as()` for future validation.
  */
 export type Meta<$Items extends Items = Items> = {
     items: $Items;

package/dist/types/Primitive/namespace.d.ts

@@ -2,19 +2,19 @@
  * The kind modules as a single namespace object — `Primitive.boolean`,
  * `Primitive.object.compute`, and so on.
  *
- * Each kind's `Types.ts` must stay type-only. A value export in the same
- * file as `export type Fabricated = boolean` (or `string`) makes that
- * module a value module; `export * as boolean` here then resolves
- * `boolean` to this namespace rather than the TypeScript primitive, which
- * drops `[Kind]`/`[Meta]` off `Core`. Named outcome lists and string's
- * character tables live in `Outcomes.ts`.
+ * Each kind's `Types.ts` must stay type-only. A value export in the same file
+ * as `export type Fabricated = boolean` (or `string`) makes that module a value
+ * module; `export * as boolean` here then resolves `boolean` to this namespace
+ * rather than the TypeScript primitive, which drops `[Kind]`/`[Meta]` off
+ * `Core`. Named outcome lists and string's character tables live in
+ * `Outcomes.ts`.
  *
- * A top-level `import * as boolean` is the same trap without needing a
- * cycle through this file. Prefer `import { Primitive }`.
+ * A top-level `import * as boolean` is the same trap without needing a cycle
+ * through this file. Prefer `import { Primitive }`.
  *
  * Consumed as `import { Primitive }` from `./index` (or from
- * `@ghostry/fabricator/internal`). Do not add this object to the
- * registry: `T.Primitive` is not a builder.
+ * `@ghostry/fabricator/internal`). Do not add this object to the registry:
+ * `T.Primitive` is not a builder.
  */
 export * as always from "./always";
 export * as array from "./array";

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

@@ -1,3 +1,3 @@
 import { Schema } from "./Schema";
-declare const _default: Schema<{}>;
-export default _default;
+declare const registry: Schema;
+export default registry;

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

@@ -8,8 +8,8 @@ import type { Core, Meta as ThisMeta } from "./Types";
  */
 export interface Schema<$Adaptations extends Adaptations = {}> extends Core<ThisMeta, $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<$Adaptations>>) => $Returnable) => Schema<WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -2,9 +2,9 @@ import type { Adaptations } from "../../Adapter/Types";
 import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 export type Fabricated = null;
 /**
- * Nothing to configure: `null` has exactly one possible value, so there is
- * no `.as()` (see `always/Types.ts` for the same reasoning) and no other
- * knob to carry.
+ * Nothing to configure: `null` has exactly one possible value, so there is no
+ * `.as()` (see `always/Types.ts` for the same reasoning) and no other knob to
+ * carry.
  */
 export type Meta = Record<string, never>;
 export type Core<$Meta extends Meta = Meta, $Adaptations extends Adaptations = {}> = {

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

@@ -19,13 +19,13 @@ export type Fabricator<$Schema extends {
     fabricate: () => Fabricated<$Schema[typeof Meta]["definition"]>;
 };
 /**
- * A presence roll on this field's private stream, drawn only when the
- * wrapped value is needed — a `null` 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 (see
+ * A presence roll on this field's private stream, drawn only when the wrapped
+ * value is needed — a `null` 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 (see
  * `object/omittable/Fabricator.ts`, and CLAUDE.md's "Randomness"). 50/50 by
- * default; `.weighted(...)` (`Schema.ts`) reweights either outcome relative
- * to that same default of `1`.
+ * 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/nullable/Schema.d.ts

@@ -10,25 +10,25 @@ import type { Core, Definition, Fabricated, 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 `null`, so custom 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 `null`, so custom logic composes the same way the built-in roll
+     * does.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition, $Adaptations>;
     /**
-     * Reweight the built-in 50/50 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
-     * `.weighted({ null: 0.1 })` shifts both outcomes' shares, not just
-     * `null`'s (see `Types.ts`'s `Weights`). Chaining `.weighted(...)` merges
-     * into previous weights rather than replacing them, the same layering
-     * `.as(...)` uses for `produce`.
+     * Reweight the built-in 50/50 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
+     * `.weighted({ null: 0.1 })` shifts both outcomes' shares, not just `null`'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/nullable/Types.d.ts

@@ -7,19 +7,18 @@ export type Definition = AnySchema;
 export type Fabricated<$Definition extends Definition, $Bindings extends unknown[] = []> = ValueOf<$Definition, $Bindings> | null;
 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({ null: 0.1 })` is
- * not "10% null, 90% present" — with `value` at default `1`, the split is
- * `0.1 / 1.1 ≈ 9.1%` null, `≈90.9%` value. 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({ null: 0.1 })` is not "10%
+ * null, 90% present" — with `value` at default `1`, the split is `0.1 / 1.1 ≈
+ * 9.1%` null, `≈90.9%` value. No independent "absolute probability" mode;
+ * weights are only meaningful relative to the full set in play.
  */
 export type Weights = {
     null: number;

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

@@ -19,18 +19,17 @@ export type Fabricator<$Schema extends {
     fabricate: () => Fabricated<$Schema[typeof Meta]["definition"]>;
 };
 /**
- * Three-way roll: `null`, `undefined`, or the wrapped value — on this
- * field's private stream; `source` is drawn only when "value" wins. Uniform
- * (1/3 each) by default; not achievable by composing
- * `nullable(T.undefinable(inner))`'s two independent 50/50 rolls (that is
- * 50/25/25, not 33/33/33), hence the dedicated three-way `weighted()` here
- * — see `object/optional/Fabricator.ts` and CLAUDE.md's "Why `T.optional`
- * isn't `omittable(undefinable(inner))`". `.weighted(...)` (`Schema.ts`)
- * reweights individual outcomes relative to that same default of `1`; an
- * unspecified outcome keeps it. Skipping `source`'s draw on the two
- * non-"value" outcomes is safe for the same reason as
- * `object/omittable/Fabricator.ts`: `source` already has its own
- * independent stream, minted at build time regardless of this roll (see
- * CLAUDE.md's "Randomness").
+ * Three-way roll: `null`, `undefined`, or the wrapped value — on this field's
+ * private stream; `source` is drawn only when "value" wins. Uniform (1/3 each)
+ * by default; not achievable by composing `nullable(T.undefinable(inner))`'s
+ * two independent 50/50 rolls (that is 50/25/25, not 33/33/33), hence the
+ * dedicated three-way `weighted()` here — see `object/optional/Fabricator.ts`
+ * and CLAUDE.md's "Why `T.optional` isn't `omittable(undefinable(inner))`".
+ * `.weighted(...)` (`Schema.ts`) reweights individual outcomes relative to that
+ * same default of `1`; an unspecified outcome keeps it. Skipping `source`'s
+ * draw on the two non-"value" outcomes is safe for the same reason as
+ * `object/omittable/Fabricator.ts`: `source` already has its own independent
+ * stream, minted at build time regardless of this roll (see CLAUDE.md's
+ * "Randomness").
  */
 export declare function Fabricator<$Definition extends Definition>(context: FabricatorContext<Schema<$Definition>>, source: BaseFabricator<any>): Fabricator<Schema<$Definition>>;

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

@@ -4,16 +4,16 @@ import type { Produce } from "../../Random/Types";
 import type { AnySchema } from "../../Schema/Types";
 import type { Core, Definition, Fabricated, Weights } from "./Types";
 /**
- * The buildable recipe for a `nullish`: a single wrapped Schema, drawn (or
- * not) each fabrication.
+ * The buildable recipe for a `nullish`: a single wrapped Schema, drawn (or not)
+ * each fabrication.
  */
 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 `null` or `undefined`, so custom logic composes
-     * the same way the built-in three-way 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 `null` or `undefined`, so custom logic composes the same way the
+     * built-in three-way roll does.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition, $Adaptations>;
     /**
@@ -27,8 +27,8 @@ export interface Schema<$Definition extends Definition = Definition, $Adaptation
      */
     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/nullish/Types.d.ts

@@ -3,27 +3,26 @@ import type { Produce } from "../../Random/Types";
 import type { AnySchema, ValueOf } from "../../Schema/Types";
 import type { Adaptation, Kind, Meta, Produces } from "../../Types";
 /**
- * The wrapped schema — the value type produced when the roll lands on
- * neither `null` nor `undefined`.
+ * The wrapped schema — the value type produced when the roll lands on neither
+ * `null` nor `undefined`.
  */
 export type Definition = AnySchema;
 export type Fabricated<$Definition extends Definition, $Bindings extends unknown[] = []> = ValueOf<$Definition, $Bindings> | null | undefined;
 export type { Outcome } from "./Outcomes";
 /**
- * Relative weights for `.weighted(...)`, keyed by `Outcome`. Keys optional —
- * an omitted key falls back to baseline `1`, the same weight the uniform
- * 1/3 split already uses. Values are relative, exactly like `weighted()`
+ * Relative weights for `.weighted(...)`, keyed by `Outcome`. Keys optional — an
+ * omitted key falls back to baseline `1`, the same weight the uniform 1/3 split
+ * already uses. Values are relative, exactly like `weighted()`
  * (`Distribution/index.ts`) — they need not sum to one, and are fed to
  * `weighted()` unchanged alongside each unspecified key's baseline `1`.
  *
- * Specifying one outcome's weight shifts *every* outcome's resulting
- * probability, not just the named one — unspecified ones stay at weight `1`
- * but their share of the total still moves, since the total changed.
- * `.weighted({ null: 0.1 })` on `T.nullish` is not "10% null, other two
- * still 33%" — with `undefined`/`value` at default `1`, the split is
- * `0.1 / 2.1 ≈ 4.8%` null and `≈47.6%` each for the other two. No
- * independent "absolute probability" mode; weights are only meaningful
- * relative to the full set in play.
+ * Specifying one outcome's weight shifts _every_ outcome's resulting
+ * probability, not just the named one — unspecified ones stay at weight `1` but
+ * their share of the total still moves, since the total changed. `.weighted({
+ * null: 0.1 })` on `T.nullish` is not "10% null, other two still 33%" — with
+ * `undefined`/`value` at default `1`, the split is `0.1 / 2.1 ≈ 4.8%` null and
+ * `≈47.6%` each for the other two. No independent "absolute probability" mode;
+ * weights are only meaningful relative to the full set in play.
  */
 export type Weights = {
     null: number;