@ghostry/fabricator 0.0.1

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

@@ -0,0 +1,27 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+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`.
+ *
+ * `$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> {
+    /**
+     * Layer an opaque production on this schema's existing `[Meta]` — carrying
+     * `whereby` forward, not discarding it, so a later `.as(...)` (or future
+     * validation of `produce`) still has it 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.
+     */
+    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>>>;
+}
+export declare function Schema<$Meta extends ThisMeta, $Adaptations extends Adaptations = {}>(schema: Core<$Meta, $Adaptations>): Schema<$Meta, $Adaptations>;

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

@@ -0,0 +1,33 @@
+import type { Adaptations } from "../../Adapter/Types";
+import type { Bound, InputBound } from "../../Bound";
+import type { Produce } from "../../Random/Types";
+import type { Adaptation, Kind, Meta, Produces } from "../../Types";
+export type InputWhereby = {
+    min?: InputBound<bigint> | undefined;
+    max: InputBound<bigint>;
+};
+export type Whereby = {
+    min: Bound<bigint>;
+    max: Bound<bigint>;
+};
+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.
+ */
+export type Meta = {
+    whereby: Whereby;
+    produce?: never;
+} | {
+    whereby?: Whereby;
+    produce: Produce<Fabricated>;
+};
+export type Core<$Meta extends Meta = Meta, $Adaptations extends Adaptations = {}> = {
+    [Kind]: "bigint";
+    [Meta]: $Meta;
+    readonly [Produces]?: Fabricated;
+    readonly [Adaptation]?: $Adaptations;
+};

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

@@ -0,0 +1,5 @@
+export * from "./Types";
+export * from "./Schema";
+export * from "./Fabricator";
+export * from "./Registry";
+export { default } from "./Registry";

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

@@ -0,0 +1,19 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { FabricatorContext, NaiveFabricator } from "../../Fabricator/Types";
+import type { Trace } from "../../Random/Types";
+import { Kind, Meta, type Adaptation } from "../../Types";
+import { Schema } from "./Schema";
+import type { Fabricated, Meta as ThisMeta } from "./Types";
+export type Fabrication<_ extends Fabricator> = Fabricated;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = NaiveFabricator<Fabricated> & {
+    [Kind]: "boolean";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<$Schema[typeof Meta], AdaptationsOf<$Schema>>;
+};
+export declare function Fabricator(context: FabricatorContext<Schema>): Fabricator;

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

@@ -0,0 +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.
+ *
+ * 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

@@ -0,0 +1,14 @@
+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;

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

@@ -0,0 +1,28 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+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`.
+ *
+ * `$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> {
+    /**
+     * Layer an opaque production on this schema's existing `[Meta]` — carrying
+     * `weights` forward, not discarding it, so a later `.as(...)` (or future
+     * validation of `produce`) still has it to check against.
+     */
+    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.
+     */
+    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>>>;
+}
+export declare function Schema<$Meta extends ThisMeta, $Adaptations extends Adaptations = {}>(schema: Core<$Meta, $Adaptations>): Schema<$Meta, $Adaptations>;

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

@@ -0,0 +1,26 @@
+import type { Adaptations } from "../../Adapter/Types";
+import type { Produce } from "../../Random/Types";
+import type { Adaptation, Kind, Meta, Produces } from "../../Types";
+export type Fabricated = boolean;
+export type Weights = {
+    true: number;
+    false?: number | undefined;
+} | {
+    true?: number | undefined;
+    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.
+ */
+export type Meta = {
+    produce?: Produce<Fabricated>;
+    weights?: Weights;
+};
+export type Core<$Meta extends Meta = Meta, $Adaptations extends Adaptations = {}> = {
+    [Kind]: "boolean";
+    [Meta]: $Meta;
+    readonly [Produces]?: Fabricated;
+    readonly [Adaptation]?: $Adaptations;
+};

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

@@ -0,0 +1,6 @@
+export * from "./Fabricator";
+export * from "./Outcomes";
+export * from "./Registry";
+export { default } from "./Registry";
+export * from "./Schema";
+export * from "./Types";

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

@@ -0,0 +1,32 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { FabricatorContext, NaiveFabricator } from "../../Fabricator/Types";
+import type { Trace } from "../../Random/Types";
+import { Children, Kind, Meta, type Adaptation } from "../../Types";
+import { Schema } from "./Schema";
+import type { Fabricated, Items, Meta as ThisMeta } from "./Types";
+export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Schema extends {
+    [Meta]: ThisMeta;
+}> ? Fabricated<$Schema[typeof Meta]["items"]> : never;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = NaiveFabricator<Fabricated<$Schema[typeof Meta]["items"]>> & {
+    [Kind]: "choice";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    [Children]: ReadonlyArray<NaiveFabricator<any>>;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<$Schema[typeof Meta]["items"], AdaptationsOf<$Schema>>;
+};
+/**
+ * `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").
+ */
+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

@@ -0,0 +1,38 @@
+import { Schema } from "./Schema";
+import type { Item, Items } from "./Types";
+/**
+ * Tuple-preserving: a mapped type over `$Items` keeps its exact length and
+ * 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`.
+ */
+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.
+ */
+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: <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.
+     */
+    weighted: <const $Items extends NonEmpty<Items[number]>>(items: $Items) => Schema<$Items>;
+};
+export default _default;

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

@@ -0,0 +1,24 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+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.
+ */
+export interface Schema<$Items extends Items = Items, $Adaptations extends Adaptations = {}> extends Core<$Items, $Adaptations> {
+    /**
+     * Layer an opaque production on this schema's existing `[Meta]` — carrying
+     * `items` forward, not discarding it, so a later `.as(...)` (or future
+     * validation of `produce`) still has it to check against.
+     */
+    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.
+     */
+    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>>>;
+}
+export declare function Schema<$Items extends Items, $Adaptations extends Adaptations = {}>(schema: Core<$Items, $Adaptations>): Schema<$Items, $Adaptations>;

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

@@ -0,0 +1,35 @@
+import type { Adaptations } from "../../Adapter/Types";
+import type { Produce } from "../../Random/Types";
+import type { AnySchema, ValueOf } from "../../Schema/Types";
+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.
+ */
+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.
+ */
+export type Meta<$Items extends Items = Items> = {
+    items: $Items;
+    produce?: Produce<Fabricated<$Items>>;
+};
+export interface Core<$Items extends Items = Items, $Adaptations extends Adaptations = {}> {
+    [Kind]: "choice";
+    [Meta]: Meta<$Items>;
+    bindings?: unknown[];
+    readonly [Produces]?: Fabricated<$Items, NonNullable<this["bindings"]>>;
+    readonly [Adaptation]?: $Adaptations;
+}

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

@@ -0,0 +1,5 @@
+export * from "./Fabricator";
+export * from "./Registry";
+export { default } from "./Registry";
+export * from "./Schema";
+export * from "./Types";

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

@@ -0,0 +1,19 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { FabricatorContext, NaiveFabricator } from "../../Fabricator/Types";
+import type { Trace } from "../../Random/Types";
+import { Kind, Meta, type Adaptation } from "../../Types";
+import { Schema } from "./Schema";
+import type { Fabricated, Meta as ThisMeta } from "./Types";
+export type Fabrication<_ extends Fabricator> = Fabricated;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = NaiveFabricator<Fabricated> & {
+    [Kind]: "date";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<$Schema[typeof Meta], AdaptationsOf<$Schema>>;
+};
+export declare function Fabricator(context: FabricatorContext<Schema>): Fabricator;

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

@@ -0,0 +1,82 @@
+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>>>;
+    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>>>;
+        /**
+         * 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.
+         */
+        whereby: (whereby: {
+            min?: InputBound<Date> | undefined;
+            distribution?: Distribution | undefined;
+        }) => 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>>>;
+        /**
+         * 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.
+         */
+        whereby: (whereby: {
+            max?: InputBound<Date> | undefined;
+            distribution?: Distribution | undefined;
+        }) => Schema<{
+            mode: "future";
+            whereby: Whereby;
+        }, {}>;
+    };
+};
+export default _default;

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

@@ -0,0 +1,28 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+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`.
+ *
+ * `$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.
+     */
+    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.
+     */
+    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>>>;
+}
+export declare function Schema<$Meta extends ThisMeta, $Adaptations extends Adaptations = {}>(schema: Core<$Meta, $Adaptations>): Schema<$Meta, $Adaptations>;

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

@@ -0,0 +1,34 @@
+import type { Adaptations } from "../../Adapter/Types";
+import type { Bound, InputBound } from "../../Bound";
+import type { Distribution } from "../../Distribution";
+import type { Produce } from "../../Random/Types";
+import type { Adaptation, Kind, Meta, Produces } from "../../Types";
+export type InputWhereby = {
+    min?: InputBound<Date> | undefined;
+    max?: InputBound<Date> | undefined;
+    distribution?: Distribution | undefined;
+};
+export type Whereby = {
+    min?: Bound<Date> | undefined;
+    max?: Bound<Date> | undefined;
+    distribution?: Distribution | undefined;
+};
+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.
+ */
+export type Meta = {
+    mode?: "past" | "future";
+    whereby?: Whereby;
+    produce?: Produce<Fabricated>;
+};
+export type Core<$Meta extends Meta = Meta, $Adaptations extends Adaptations = {}> = {
+    [Kind]: "date";
+    [Meta]: $Meta;
+    readonly [Produces]?: Fabricated;
+    readonly [Adaptation]?: $Adaptations;
+};

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

@@ -0,0 +1,5 @@
+export * from "./Types";
+export * from "./Schema";
+export * from "./Fabricator";
+export * from "./Registry";
+export { default } from "./Registry";

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

@@ -0,0 +1,19 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { FabricatorContext, NaiveFabricator } from "../../Fabricator/Types";
+import type { Trace } from "../../Random/Types";
+import { Kind, Meta, type Adaptation } from "../../Types";
+import { Schema } from "./Schema";
+import type { Fabricated, Items, Meta as ThisMeta } from "./Types";
+export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Schema> ? Fabricated<$Schema[typeof Meta]["items"]> : never;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = NaiveFabricator<Fabricated<$Schema[typeof Meta]["items"]>> & {
+    [Kind]: "enum";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<$Schema[typeof Meta]["items"], AdaptationsOf<$Schema>>;
+};
+export declare function Fabricator<$Items extends Items>(context: FabricatorContext<Schema<$Items>>): Fabricator<Schema<$Items>>;

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

@@ -0,0 +1,39 @@
+import { Schema } from "./Schema";
+import type { Item, Items } from "./Types";
+/**
+ * Tuple-preserving: a mapped type over `$Items` keeps its exact length and
+ * 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.
+ */
+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.
+ */
+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: <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.
+     */
+    weighted: <const $Items extends NonEmpty<Items[number]>>(items: $Items) => Schema<$Items>;
+};
+export default _default;

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

@@ -0,0 +1,23 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+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.
+ */
+export interface Schema<$Items extends Items = Items, $Adaptations extends Adaptations = {}> extends Core<$Items, $Adaptations> {
+    /**
+     * Layer an opaque production on this schema's existing `[Meta]` — carrying
+     * `items` forward, not discarding it, so a later `.as(...)` (or future
+     * validation of `produce`) still has it to check against.
+     */
+    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.
+     */
+    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>>>;
+}
+export declare function Schema<$Items extends Items, $Adaptations extends Adaptations = {}>(schema: Core<$Items, $Adaptations>): Schema<$Items, $Adaptations>;

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

@@ -0,0 +1,44 @@
+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).
+ *
+ * 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.
+ *
+ * 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.
+ */
+export type Meta<$Items extends Items = Items> = {
+    items: $Items;
+    produce?: Produce<Fabricated<$Items>>;
+};
+export type Core<$Items extends Items = Items, $Adaptations extends Adaptations = {}> = {
+    [Kind]: "enum";
+    [Meta]: Meta<$Items>;
+    readonly [Produces]?: Fabricated<$Items>;
+    readonly [Adaptation]?: $Adaptations;
+};

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

@@ -0,0 +1,5 @@
+export * from "./Types";
+export * from "./Schema";
+export * from "./Fabricator";
+export * from "./Registry";
+export { default } from "./Registry";