@ghostry/fabricator 0.0.1 → 0.0.3

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

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

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

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

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

@@ -9,14 +9,13 @@ import type { Core, Definition, Fabricated } from "./Types";
 export interface Schema<$Definition extends Definition = Definition, $Adaptations extends Adaptations = {}> extends Core<$Definition, $Adaptations> {
     /**
      * Layer an opaque production on this schema's existing `[Meta]` — carrying
-     * `whereby`/`definition` forward, not discarding them, so a later
-     * `.as(...)` (or future validation of `produce`) still has them to check
-     * against.
+     * `whereby`/`definition` forward, not discarding them, so a later `.as(...)`
+     * (or future validation of `produce`) still has them to check against.
      */
     as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition, $Adaptations>;
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Definition, $Adaptations>>) => $Returnable) => Schema<$Definition, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -19,12 +19,12 @@ export type Whereby = {
 };
 /**
  * `whereby` (a length spec — no natural bound to fuzz to, so unlike
- * `number`/`date` there's no bare form), optionally overridden by an
- * opaque `as` production, carried alongside `whereby` rather than replacing
- * it (when `whereby` was already set) so a prior length spec survives `as`
- * for future validation. `definition` stays required regardless — it's
- * known at `T.array(...)` call time and describes the element shape TypeBox
- * derives either way.
+ * `number`/`date` there's no bare form), optionally overridden by an opaque
+ * `as` production, carried alongside `whereby` rather than replacing it (when
+ * `whereby` was already set) so a prior length spec survives `as` for future
+ * validation. `definition` stays required regardless — it's known at
+ * `T.array(...)` call time and describes the element shape TypeBox derives
+ * either way.
  */
 export type Meta<$Definition extends Definition = Definition> = {
     definition: $Definition;

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

@@ -4,16 +4,16 @@ import { Schema } from "./Schema";
 import type { Fabricated, InputWhereby, Whereby } from "./Types";
 declare const _default: {
     /**
-     * The builder carries the primitive's `[Kind]` so it can be named directly
-     * as a `compute` source — which derives its schema by kind — without
-     * first satisfying a `whereby`.
+     * The builder carries the primitive's `[Kind]` so it can be named directly as
+     * a `compute` source — which derives its schema by kind — without first
+     * satisfying a `whereby`.
      */
     [Kind]: "bigint";
     whereby: (whereby: InputWhereby) => Schema<{
         whereby: Whereby;
-    }, {}>;
+    }>;
     as: (produce: Produce<Fabricated>) => Schema<{
-        produce: Produce<bigint>;
-    }, {}>;
+        produce: Produce<Fabricated>;
+    }>;
 };
 export default _default;

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

@@ -3,13 +3,13 @@ import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adap
 import type { Produce } from "../../Random/Types";
 import type { Core, Fabricated, Meta as ThisMeta } from "./Types";
 /**
- * Buildable `bigint` recipe: a range (`whereby` — required, like `string`;
- * no natural bound to fuzz to), or opaque production via `as`.
+ * Buildable `bigint` recipe: a range (`whereby` — required, like `string`; no
+ * natural bound to fuzz to), or opaque production via `as`.
  *
- * `$Meta` is generic (defaulting to the full `Meta` union) so builder
- * return types stay narrow — see `number/Schema.ts`. `$Adaptations` is
- * threaded through every builder method for the same reason — see
- * `string/Schema.ts`'s `adapt`.
+ * `$Meta` is generic (defaulting to the full `Meta` union) so builder return
+ * types stay narrow — see `number/Schema.ts`. `$Adaptations` is threaded
+ * through every builder method for the same reason — see `string/Schema.ts`'s
+ * `adapt`.
  */
 export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends Adaptations = {}> extends Core<$Meta, $Adaptations> {
     /**
@@ -19,8 +19,8 @@ export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends
      */
     as: (produce: Produce<Fabricated>) => Schema<$Meta, $Adaptations>;
     /**
-     * Override what this schema maps to in one or more external schema
-     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     * Override what this schema maps to in one or more external schema libraries
+     * — see `string/Schema.ts`'s `adapt` for the full contract.
      */
     adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Meta, $Adaptations>>) => $Returnable) => Schema<$Meta, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
 }

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

@@ -12,11 +12,11 @@ export type Whereby = {
 };
 export type Fabricated = bigint;
 /**
- * A ranged bigint, drawn via `whereby` — no natural bound to fuzz to, so
- * unlike `number`/`date` there's no bare form — optionally overridden by
- * an opaque `as` production, carried alongside `whereby` rather than
- * replacing it (when `whereby` was already set) so a prior range survives
- * `as` for future validation.
+ * A ranged bigint, drawn via `whereby` — no natural bound to fuzz to, so unlike
+ * `number`/`date` there's no bare form — optionally overridden by an opaque
+ * `as` production, carried alongside `whereby` rather than replacing it (when
+ * `whereby` was already set) so a prior range survives `as` for future
+ * validation.
  */
 export type Meta = {
     whereby: Whereby;

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

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

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

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

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

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

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

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

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

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

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

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

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>>>;
 }