@ghostry/fabricator 0.0.1

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

@@ -0,0 +1,28 @@
+import { Kind } from "../Types";
+import * as Primitive from "./namespace";
+export { default as always } from "./always";
+export { default as array } from "./array";
+export { default as bigint } from "./bigint";
+export { default as boolean } from "./boolean";
+export { default as choice } from "./choice";
+export { default as date } from "./date";
+export { default as enum } from "./enum";
+export { default as null } from "./null";
+export { default as nullable } from "./nullable";
+export { default as nullish } from "./nullish";
+export { default as number } from "./number";
+export { default as object } from "./object";
+export { default as omittable } from "./object/omittable";
+export { default as optional } from "./object/optional";
+export { default as opaque } from "./opaque";
+export { default as record } from "./record";
+export { default as recursive } from "./recursive";
+export { default as string } from "./string";
+export { default as symbol } from "./symbol";
+export { default as tuple } from "./tuple";
+export { default as undefinable } from "./undefinable";
+export { default as undefined } from "./undefined";
+export { Primitive };
+export type Fabricator = Primitive.always.Fabricator<any> | Primitive.array.Fabricator<any> | Primitive.bigint.Fabricator | Primitive.boolean.Fabricator | Primitive.choice.Fabricator<any> | Primitive.date.Fabricator | Primitive.enum.Fabricator<any> | Primitive.null.Fabricator | Primitive.nullable.Fabricator<any> | Primitive.nullish.Fabricator<any> | Primitive.number.Fabricator | Primitive.object.Fabricator<any> | Primitive.object.compute.Fabricator<any, any> | Primitive.object.omittable.Fabricator<any> | Primitive.object.optional.Fabricator<any> | Primitive.opaque.Fabricator<any> | Primitive.record.Fabricator<any> | Primitive.recursive.Fabricator<any> | Primitive.recursive.self.Fabricator<any> | Primitive.string.Fabricator | Primitive.symbol.Fabricator | Primitive.tuple.Fabricator<any> | Primitive.undefined.Fabricator | Primitive.undefinable.Fabricator<any>;
+export type Schema = Primitive.always.Schema<any> | Primitive.array.Schema<any> | Primitive.bigint.Schema | Primitive.boolean.Schema | Primitive.choice.Schema<any> | Primitive.date.Schema | Primitive.enum.Schema<any> | Primitive.null.Schema | Primitive.nullable.Schema<any> | Primitive.nullish.Schema<any> | Primitive.number.Schema | Primitive.object.Schema<any> | Primitive.object.compute.Schema<any, any> | Primitive.object.omittable.Schema<any> | Primitive.object.optional.Schema<any> | Primitive.opaque.Schema<any> | Primitive.record.Schema<any, any> | Primitive.recursive.Schema<any> | Primitive.recursive.self.Schema<any> | Primitive.string.Schema | Primitive.symbol.Schema | Primitive.tuple.Schema<any> | Primitive.undefined.Schema | Primitive.undefinable.Schema<any>;
+export type Kind = Schema[typeof Kind];

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

@@ -0,0 +1,38 @@
+/**
+ * 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`.
+ *
+ * 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.
+ */
+export * as always from "./always";
+export * as array from "./array";
+export * as bigint from "./bigint";
+export * as boolean from "./boolean";
+export * as choice from "./choice";
+export * as date from "./date";
+export * as enum from "./enum";
+export * as null from "./null";
+export * as nullable from "./nullable";
+export * as nullish from "./nullish";
+export * as number from "./number";
+export * as object from "./object";
+export * as opaque from "./opaque";
+export * as record from "./record";
+export * as recursive from "./recursive";
+export * as string from "./string";
+export * as symbol from "./symbol";
+export * as tuple from "./tuple";
+export * as undefinable from "./undefinable";
+export * as undefined from "./undefined";

package/dist/types/Primitive/null/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]: "null";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<AdaptationsOf<$Schema>>;
+};
+export declare function Fabricator(context: FabricatorContext<Schema>): Fabricator;

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

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

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

@@ -0,0 +1,16 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+import type { Core, Meta as ThisMeta } from "./Types";
+/**
+ * Nothing to configure (see `Types.ts`'s `Meta`), so `adapt` is this kind's
+ * only builder method — an external library that spells "null" differently
+ * still needs a way to say so.
+ */
+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.
+     */
+    adapt: <const $Adapter extends Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: Adapting<Schema<$Adaptations>>) => $Returnable) => Schema<WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
+}
+export declare function Schema<$Adaptations extends Adaptations = {}>(schema: Core<ThisMeta, $Adaptations>): Schema<$Adaptations>;

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

@@ -0,0 +1,15 @@
+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.
+ */
+export type Meta = Record<string, never>;
+export type Core<$Meta extends Meta = Meta, $Adaptations extends Adaptations = {}> = {
+    [Kind]: "null";
+    [Meta]: $Meta;
+    readonly [Produces]?: Fabricated;
+    readonly [Adaptation]?: $Adaptations;
+};

package/dist/types/Primitive/null/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/nullable/Fabricator.d.ts

@@ -0,0 +1,31 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { Fabricator as BaseFabricator, FabricatorContext } from "../../Fabricator/Types";
+import type { Trace } from "../../Random/Types";
+import { Children, Kind, Meta, type Adaptation } from "../../Types";
+import { Schema } from "./Schema";
+import type { Definition, Fabricated, Meta as ThisMeta } from "./Types";
+export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Schema> ? Fabricated<$Schema[typeof Meta]["definition"]> : never;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = {
+    [Kind]: "nullable";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    [Children]: BaseFabricator<any>;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<$Schema[typeof Meta]["definition"], AdaptationsOf<$Schema>>;
+    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
+ * `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`.
+ */
+export declare function Fabricator<$Definition extends Definition>(context: FabricatorContext<Schema<$Definition>>, source: BaseFabricator<any>): Fabricator<Schema<$Definition>>;

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

@@ -0,0 +1,9 @@
+/**
+ * The two outcomes a nullable field's roll can land on. Also the key space
+ * `.weighted(...)` weighs — see `Types.ts`'s `Weights`.
+ *
+ * Lives here rather than `Types.ts` so that file stays type-only (see
+ * `boolean/Outcomes.ts`).
+ */
+export declare const outcomes: readonly ["null", "value"];
+export type Outcome = (typeof outcomes)[number];

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

@@ -0,0 +1,3 @@
+import { Schema } from "./Schema";
+import type { Definition } from "./Types";
+export default function <const $Definition extends Definition>(definition: $Definition): Schema<$Definition>;

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

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

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

@@ -0,0 +1,48 @@
+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 wrapped schema — the value type produced when the roll isn't `null`. */
+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()`
+ * (`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.
+ */
+export type Weights = {
+    null: number;
+    value?: number | undefined;
+} | {
+    null?: number | undefined;
+    value: number;
+};
+/**
+ * `definition` stays required regardless of `produce` — an opaque `as`
+ * production layers on top rather than replacing it, so a prior definition
+ * survives `as` for future validation of `produce` (and so `ToTypeBox`'s
+ * structural derivation of the wrapped shape keeps working either way).
+ */
+export type Meta<$Definition extends Definition = Definition> = {
+    definition: $Definition;
+    produce?: Produce<Fabricated<$Definition>>;
+    weights?: Weights;
+};
+export interface Core<$Definition extends Definition = Definition, $Adaptations extends Adaptations = {}> {
+    [Kind]: "nullable";
+    [Meta]: Meta<$Definition>;
+    bindings?: unknown[];
+    readonly [Produces]?: Fabricated<$Definition, NonNullable<this["bindings"]>>;
+    readonly [Adaptation]?: $Adaptations;
+}

package/dist/types/Primitive/nullable/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/nullish/Fabricator.d.ts

@@ -0,0 +1,36 @@
+import type { AdaptationsOf } from "../../Adapter/Types";
+import type { Fabricator as BaseFabricator, FabricatorContext } from "../../Fabricator/Types";
+import type { Trace } from "../../Random/Types";
+import { Children, Kind, Meta, type Adaptation } from "../../Types";
+import { Schema } from "./Schema";
+import type { Definition, Fabricated, Meta as ThisMeta } from "./Types";
+export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Schema> ? Fabricated<$Schema[typeof Meta]["definition"]> : never;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = {
+    [Kind]: "nullish";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    [Children]: BaseFabricator<any>;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<$Schema[typeof Meta]["definition"], AdaptationsOf<$Schema>>;
+    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").
+ */
+export declare function Fabricator<$Definition extends Definition>(context: FabricatorContext<Schema<$Definition>>, source: BaseFabricator<any>): Fabricator<Schema<$Definition>>;

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

@@ -0,0 +1,9 @@
+/**
+ * The three outcomes a nullish roll can land on. Also the key space
+ * `.weighted(...)` weighs — see `Types.ts`'s `Weights`.
+ *
+ * Lives here rather than `Types.ts` so that file stays type-only (see
+ * `boolean/Outcomes.ts`).
+ */
+export declare const outcomes: readonly ["null", "undefined", "value"];
+export type Outcome = (typeof outcomes)[number];

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

@@ -0,0 +1,3 @@
+import { Schema } from "./Schema";
+import type { Definition } from "./Types";
+export default function <const $Definition extends Definition>(definition: $Definition): Schema<$Definition>;

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

@@ -0,0 +1,36 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+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.
+ */
+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.
+     */
+    as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition, $Adaptations>;
+    /**
+     * Reweight the built-in three-way roll. Keys are optional — an omitted key
+     * keeps baseline weight `1`, the same weight the uniform 1/3 split already
+     * uses — but that baseline is still relative to whatever else is specified,
+     * so `.weighted({ null: 0.1 })` shifts every outcome's share, 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.
+     */
+    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>>>;
+}
+export declare function Schema<$Definition extends Definition, $Adaptations extends Adaptations = {}>(schema: Core<$Definition, $Adaptations>): Schema<$Definition, $Adaptations>;
+export declare function isNullishSchema(candidate: AnySchema): candidate is Schema;

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

@@ -0,0 +1,58 @@
+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 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()`
+ * (`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.
+ */
+export type Weights = {
+    null: number;
+    undefined?: number | undefined;
+    value?: number | undefined;
+} | {
+    null?: number | undefined;
+    undefined: number;
+    value?: number | undefined;
+} | {
+    null?: number | undefined;
+    undefined?: number | undefined;
+    value: number;
+};
+/**
+ * `definition` stays required regardless of `produce` — an opaque `as`
+ * production layers on top rather than replacing it, so a prior definition
+ * survives `as` for future validation of `produce` (and so `ToTypeBox`'s
+ * structural derivation of the wrapped shape keeps working either way).
+ */
+export type Meta<$Definition extends Definition = Definition> = {
+    definition: $Definition;
+    produce?: Produce<Fabricated<$Definition>>;
+    weights?: Weights;
+};
+export interface Core<$Definition extends Definition = Definition, $Adaptations extends Adaptations = {}> {
+    [Kind]: "nullish";
+    [Meta]: Meta<$Definition>;
+    bindings?: unknown[];
+    readonly [Produces]?: Fabricated<$Definition, NonNullable<this["bindings"]>>;
+    readonly [Adaptation]?: $Adaptations;
+}

package/dist/types/Primitive/nullish/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/number/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]: "number";
+    [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/number/Registry.d.ts

@@ -0,0 +1,52 @@
+import type { Adaptations } from "../../Adapter/Types";
+import { Adaptation, Kind, Meta, Produces } from "../../Types";
+import { Schema } from "./Schema";
+import type { Fabricated, InputWhereby, Whereby } from "./Types";
+declare const _default: {
+    [Kind]: "number";
+    [Meta]: {};
+    [Produces]?: Fabricated;
+    [Adaptation]?: Adaptations;
+    as: (produce: import("../../Random/Types").Produce<Fabricated>, hints?: import("./Types").JsonSchema) => Schema<{}, Adaptations>;
+    adapt: <const $Adapter extends import("../..").Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: import("../..").Adapting<Schema<{}, Adaptations>>) => $Returnable) => Schema<{}, import("../../Adapter/Types").WithAdaptations<Adaptations, import("../../Adapter/Core").AdaptationEntry<$Adapter, $Returnable>>>;
+    whereby: (whereby: InputWhereby) => Schema<{
+        whereby: Whereby;
+    }, {}>;
+    integer: {
+        [Kind]: "number";
+        [Meta]: {
+            integer: true;
+        };
+        [Produces]?: Fabricated;
+        [Adaptation]?: {};
+        as: (produce: import("../../Random/Types").Produce<Fabricated>, hints?: import("./Types").JsonSchema) => Schema<{
+            integer: true;
+        }, {}>;
+        adapt: <const $Adapter extends import("../..").Adapter, $Returnable extends ReturnType<$Adapter["convert"]>>(adapter: $Adapter, produce: (adapting: import("../..").Adapting<Schema<{
+            integer: true;
+        }, {}>>) => $Returnable) => Schema<{
+            integer: true;
+        }, import("../../Adapter/Types").WithAdaptations<{}, import("../../Adapter/Core").AdaptationEntry<$Adapter, $Returnable>>>;
+        whereby: (whereby: InputWhereby) => Schema<{
+            integer: true;
+            whereby: Whereby;
+        }, {}>;
+        /**
+         * A monotonically increasing counter starting at 1, fresh per `construct()`.
+         */
+        sequence: Schema<{
+            sequence: true;
+            integer: true;
+        }, {}>;
+        big: {
+            [Kind]: "bigint";
+            whereby: (whereby: import("../bigint").InputWhereby) => import("../bigint").Schema<{
+                whereby: import("../bigint").Whereby;
+            }, {}>;
+            as: (produce: import("../../Random/Types").Produce<import("../bigint").Fabricated>) => import("../bigint").Schema<{
+                produce: import("../../Random/Types").Produce<bigint>;
+            }, {}>;
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1,32 @@
+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, JsonSchema, Meta as ThisMeta } from "./Types";
+/**
+ * Buildable `number` recipe: a range/distribution (`whereby`, absent for
+ * the full-range bare form), `integer` for whole-number semantics, a
+ * `sequence` counter, or opaque production via `as`. `construct()` derives
+ * `fabricate` from this data — no variant carries its own closure until
+ * it's built.
+ *
+ * `$Meta` is generic (defaulting to the full `Meta` union) so builder
+ * return types stay narrow — e.g. `T.number.integer.sequence` types as
+ * `Schema<{ sequence: true; integer: true }>`, not the widened `Schema`, so
+ * a downstream conditional (`ToTypeBox`) can still tell an integer schema
+ * apart from a bare one.
+ */
+export interface Schema<$Meta extends ThisMeta = ThisMeta, $Adaptations extends Adaptations = {}> extends Core<$Meta, $Adaptations> {
+    /**
+     * Layer an opaque production on this schema's existing `[Meta]` — carrying
+     * `whereby`/`integer`/`sequence` forward, not discarding them, so a later
+     * `.as(...)` (or future validation of `produce`) still has them to check
+     * against.
+     */
+    as: (produce: Produce<Fabricated>, hints?: JsonSchema) => Schema<$Meta, $Adaptations>;
+    /**
+     * Override what this schema maps to in one or more external schema
+     * libraries — see `string/Schema.ts`'s `adapt` for the full contract.
+     */
+    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/number/Types.d.ts

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

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

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

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

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