@ghostry/fabricator 0.0.1

package/dist/types/Fabricator/Types.d.ts

@@ -0,0 +1,150 @@
+import type { Adaptations, AdaptationsOf } from "../Adapter/Types";
+import type { Primitive, Kind as SchemaKind } from "../Primitive";
+import type { Algorithm, Trace } from "../Random/Types";
+import type { ValueOf } from "../Schema/Types";
+import type { Adaptation, Kind, Meta, Produces } from "../Types";
+import type { PlainObject } from "../Utility/Types";
+/**
+ * Threaded through `Constructor.ts`'s `make` for every dispatch of one
+ * `new Fabricator(...)` construction — every branch forwards it
+ * (extending `path`, never `algorithm`/`self`) into its own nested
+ * `make(...)` calls, so it reaches however deeply a leaf sits nested
+ * through `array`/`object`/`tuple`/etc.
+ *
+ * `toTrace` records this node's {@link Trace} — a plain object literal,
+ * no hashing. Hashing is paid only where a kind actually calls
+ * `toStreamFromTrace(algorithm, trace)`. Bound once in `construct()` to
+ * this one construction's already-resolved `RandomSource`/
+ * `ConstructionTrace` pair (see `Constructor.ts`'s `resolveScope`) —
+ * every leaf calls `toTrace` with only its own structural `path` and
+ * kind, never re-resolving the construction's root itself.
+ * `T.recursive` is the one kind that rebinds `toTrace`: each lazy
+ * expansion opens its own scope on the node's own private forked
+ * `RandomSource` (see `recursive/Fabricator.ts`), so a data-dependent
+ * expansion count can never perturb, or be perturbed by, anything else
+ * built from the same `initialize()` instance —
+ * `RandomSource.fork` (`Random/Types.ts`) is the isolation primitive.
+ *
+ * `algorithm` rather than the `RandomSource` itself: stream derivation
+ * depends on no per-source state, and a leaf has no business with
+ * `toRoot`/`fork`. `clock` is not a field of its own — it is always
+ * `trace.clock`.
+ *
+ * `self` is what makes `case "recursive.self"` resolve to "recurse one
+ * level deeper, right now" — absent outside any active recursion, which
+ * is how `case "recursive.self"` detects and rejects a `self` node used
+ * where none applies.
+ */
+export type ConstructionContext = {
+    toTrace: (path: ReadonlyArray<string>, kind: string) => Trace;
+    algorithm: Algorithm;
+    self?: (() => unknown) | undefined;
+};
+/**
+ * What every kind's `Fabricator(...)` receives in place of a repeated
+ * `(schema, algorithm, trace)` positional list — `Constructor.ts`'s
+ * `make` builds one per dispatched node from its own
+ * `ConstructionContext`. `trace` is already path-bound and built
+ * eagerly, so a kind that never draws still records one without calling
+ * `toStreamFromTrace`. Laziness is load-bearing: `toTrace` is a plain
+ * object literal, and hashing is paid only where a kind actually calls
+ * `toStreamFromTrace(algorithm, trace)`. The guard is the call site's
+ * own `if (meta.produce)` branch (or the equivalent drawing path), not
+ * an unevaluated closure. `algorithm` rather than the `RandomSource`:
+ * derivation depends on no per-source state, and a leaf has no business
+ * with `toRoot`/`fork`. No `clock`: it is `trace.clock`, always. A
+ * kind-specific extra — an array's `element`, an object's `fields`, a
+ * choice's `weightings` — still follows as its own trailing parameter:
+ * those vary per kind and were never part of the shared prefix this
+ * replaces.
+ */
+export type FabricatorContext<$Schema> = {
+    schema: $Schema;
+    algorithm: Algorithm;
+    trace: Trace;
+};
+/**
+ * The most basic interface for a typed Fabricator.
+ * No type introspection is possible.
+ */
+export type NaiveFabricator<$T> = {
+    fabricate: () => $T;
+};
+/**
+ * What every kind's `construct()` produces: a `NaiveFabricator` that
+ * also hands back the Schema it was built from, via the same
+ * `[Kind]`/`[Meta]` a Schema itself carries — so a built Fabricator
+ * can be passed back into `object`/`array`/a registry `.extend()`
+ * anywhere a Schema is expected (see `toSchema`).
+ */
+export type Fabricator<$T> = NaiveFabricator<$T> & {
+    [Kind]: SchemaKind;
+    [Meta]: PlainObject;
+    readonly trace: Trace;
+    /**
+     * Carried over from the Schema by `Constructor.ts`'s `make` — inert to
+     * fabrication, but it has to survive building for an adapter handed a
+     * built Fabricator to see what the Schema declared (see
+     * `Adapter/Types.ts`).
+     */
+    readonly [Adaptation]?: Adaptations;
+};
+/**
+ * The value type a built Fabricator produces — read directly off its
+ * `fabricate` signature. Every kind's `construct()` output shares the
+ * exact same shape (`NaiveFabricator<$T>` plus `[Kind]`/`[Meta]`, see
+ * this file's `Fabricator<$T>`), so there's nothing to dispatch per
+ * kind here — unlike `ValueOf`, which reads a Schema's phantom
+ * `[Produces]` marker for the pre-`construct()` case, this only ever
+ * needs to unwrap an already-uniform `fabricate: () => $T`.
+ */
+export type Fabrication<$Fabricator extends NaiveFabricator<any>> = $Fabricator extends NaiveFabricator<infer $T> ? $T : never;
+/**
+ * Maps a Schema (or an already-built Fabricator of the same kind — see
+ * the `object` branch, and every other branch below since each kind's
+ * `Schema` also carries a required `as` method a built Fabricator never
+ * has) to the precise, kind-specific `Fabricator<...>` type it builds
+ * into. Mirrors `Adapter/TypeBox/index.ts`'s `ToTypeBox` dispatch.
+ * Falls back to the loose base `Fabricator<ValueOf<$Schema>>` for
+ * anything unmatched.
+ *
+ * No branch here needs to do anything about `[Adaptation]`: each
+ * kind's own `Fabricator<$Schema>` reads it back off `$Schema` via
+ * `AdaptationsOf`, so an adapted Schema's Fabricator carries the map
+ * without this dispatch (or an intersection on top of it, which the
+ * warning below would otherwise apply to) having to mention it.
+ * `object.compute` is the one exception, taking its `$Adaptations`
+ * explicitly because its Fabricator is parameterized by the computed
+ * value and source rather than by the Schema.
+ *
+ * Every branch's own `Fabricator<$Schema>` type already carries a
+ * `.schema` field (see each kind's `Core.ts`) — *not* added here via an
+ * extra `& { schema: ... }` intersection: wrapping an already-named
+ * type in a fresh intersection defeats a later `infer` over it (e.g.
+ * each kind's own `Fabrication<$Fabricator>` helper, which narrows via
+ * `extends Fabricator<infer $Schema>`) — TypeScript can't always
+ * decompose the intersection back to recover `$Schema`, and silently
+ * widens to the generic's constraint instead.
+ */
+export type AsFabricator<$Schema> = 
+/**
+ * `<any>`, not bare `Primitive.object.Schema | Primitive.object.Fabricator`:
+ * `Primitive.object.Schema` is an interface whose `refine` method uses
+ * `$Definition` contravariantly (nested inside `Refiner`/`Computer`),
+ * so `Primitive.object.Schema<{ narrow definition }>` doesn't actually extend
+ * the *default*-parameterized bare `Primitive.object.Schema`
+ * (`Definition<AnySchema>`) — comparing against `<any>` sidesteps
+ * that variance check entirely, the same way `ToTypeBox`'s object
+ * branch sidesteps it by never referencing `refine`/`extend` at all
+ * (see its structural `[Meta].definition` check).
+ */
+$Schema extends Primitive.object.Core ? Primitive.object.Fabricator<$Schema> : $Schema extends Primitive.object.compute.Core<infer $Fabricated, infer $Source> ? Primitive.object.compute.Fabricator<$Fabricated, $Source, AdaptationsOf<$Schema>> : $Schema extends Primitive.object.omittable.Core ? Primitive.object.omittable.Fabricator<$Schema> : $Schema extends Primitive.object.optional.Core ? Primitive.object.optional.Fabricator<$Schema> : $Schema extends Primitive.array.Core ? Primitive.array.Fabricator<$Schema> : $Schema extends Primitive.opaque.Core ? Primitive.opaque.Fabricator<$Schema> : $Schema extends Primitive.record.Core ? Primitive.record.Fabricator<$Schema> : $Schema extends Primitive.recursive.Core ? Primitive.recursive.Fabricator<$Schema> : 
+/**
+ * `self` is never independently built in ordinary use — it only ever
+ * appears nested inside a `T.recursive` body, resolved by
+ * `Constructor.ts`'s `make` context, not through this boundary. `[]`
+ * (unbound) is the same default `self.Core` itself falls back to.
+ */
+$Schema extends Primitive.recursive.self.Core ? Primitive.recursive.self.Fabricator<[]> : $Schema extends Primitive.tuple.Core ? Primitive.tuple.Fabricator<$Schema> : $Schema extends Primitive.always.Core ? Primitive.always.Fabricator<$Schema> : $Schema extends Primitive.bigint.Core ? Primitive.bigint.Fabricator<$Schema> : $Schema extends Primitive.boolean.Core ? Primitive.boolean.Fabricator<$Schema> : $Schema extends Primitive.choice.Core ? Primitive.choice.Fabricator<$Schema> : $Schema extends Primitive.enum.Core ? Primitive.enum.Fabricator<$Schema> : $Schema extends Primitive.date.Core ? Primitive.date.Fabricator<$Schema> : $Schema extends Primitive.number.Core ? Primitive.number.Fabricator<$Schema> : $Schema extends Primitive.string.Core ? Primitive.string.Fabricator<$Schema> : $Schema extends Primitive.symbol.Core ? Primitive.symbol.Fabricator<$Schema> : $Schema extends Primitive.undefined.Core ? Primitive.undefined.Fabricator<$Schema> : $Schema extends Primitive.undefinable.Core ? Primitive.undefinable.Fabricator<$Schema> : $Schema extends Primitive.null.Core ? Primitive.null.Fabricator<$Schema> : $Schema extends Primitive.nullable.Core ? Primitive.nullable.Fabricator<$Schema> : $Schema extends Primitive.nullish.Core ? Primitive.nullish.Fabricator<$Schema> : $Schema extends {
+    readonly [Produces]?: unknown;
+} ? Fabricator<ValueOf<$Schema>> : Fabricator<unknown>;

package/dist/types/Instance/Core.d.ts

@@ -0,0 +1,98 @@
+import type { RandomSource } from "../Random/Types";
+import type { PlainObject } from "../Utility/Types";
+import type { Config, Instance, Overlay, Stack } from "./Types";
+/**
+ * `combinatorial`'s default limit — `2**10`, so it admits ten
+ * independent binary axes before requiring the caller to raise it
+ * explicitly. Each enumerated instance costs a full build and
+ * fabricate, so this is as much a wall-clock guard as a combinatorial
+ * one.
+ */
+export declare const DEFAULT_COMBINATORIAL_LIMIT = 1024;
+/**
+ * The single place a `Config` inherits from a base — `initialize` lays
+ * its own config over an empty `{}` base (nothing to inherit, so every
+ * field falls through to a hardcoded default: an empty seed, wall-clock
+ * `clock`, the built-in algorithm, `resolveAttribution(undefined)`'s
+ * `"call site"` resolution, the default registry, the default
+ * combinatorial limit), and `fork` lays its overlay over the instance
+ * it was called on (a full, already-resolved `Config`, so every field
+ * has a real value to fall back to). `base` is typed
+ * `Partial<Config<PlainObject>>` rather than `Config` specifically so
+ * both calls go through the same function.
+ *
+ * `seed` composes onto the base rather than replacing it only when
+ * tagged with `layer(...)` (`{@link isLayered}`) — a bare `seed` (the
+ * ordinary meaning everywhere else in this library) replaces the
+ * base's outright, and an omitted `seed` inherits the base's unchanged
+ * (or, at the root, an empty mixer via `normalizeSeed(undefined)`,
+ * unless an env var supplies one). Wall-clock `clock` is the default
+ * entropy; `seed` is an optional mixer.
+ *
+ * `attribution` resolves through `resolveAttribution` at most once per
+ * call, and only when it's actually needed:
+ * - an explicit `over.attribution` always wins (resolved fresh, so
+ *   `fork({ attribution: { kind: "call site" } })` roots at *that*
+ *   call);
+ * - otherwise an already-resolved `base.attribution` is reused as-is
+ *   — never re-resolved, which keeps a fork from silently re-rooting
+ *   `"call site"` at wherever `fork()` itself happens to be called
+ *   (`resolveCallerFile()` skips this library's own frames, so calling
+ *   it from here still lands on the user's call site either way);
+ * - only when neither is available (the root case, `base.attribution`
+ *   absent) does this fall back to resolving the `"call site"`
+ *   default.
+ * That also keeps `initialize({ attribution: { kind: "none" } })` — or
+ * any other explicit override — from paying for a stack walk whose
+ * result would be immediately discarded.
+ *
+ * `algorithm`/`types`: wholesale replacement when given, matching how
+ * `initialize({ types })` already behaves — no deep merge;
+ * `registry.extend(...)` is the existing tool for that. `limits` is
+ * re-validated through `resolveCombinatorialLimit` whenever given (or
+ * inherited, or defaulted), so a bad limit fails at
+ * `fork()`/`initialize()` time rather than at first use. `clock`
+ * follows the given → inherited → default shape `algorithm` does, but
+ * stays *unresolved* only for the explicit `"seeded"` sentinel: an
+ * explicit `Date` and the unconfigured wall-clock default are stored
+ * as epoch milliseconds (a stated instant, inherited as-is from then
+ * on), while `"seeded"` is left as the sentinel rather than collapsed
+ * to a number, so `resolveClock` can re-derive it from whichever
+ * `seed` is actually in effect at read time. An omitted `clock` on a
+ * `fork`/`wrap` whose seed changed therefore keeps the parent's
+ * instant unless that parent was itself `"seeded"`.
+ */
+export declare function overlay<$Registry extends PlainObject>(base: Partial<Config<PlainObject>>, over: Overlay<$Registry>): Config<$Registry>;
+/**
+ * Builds a `Stack`: closes over a private `Frame[]`, pushing on `enter`
+ * and popping in a `finally` — correct even around a `throw` from
+ * `block`. One per root `initialize()`, threaded — never re-created —
+ * through every `fork`/`wrap` descended from it, so it stays
+ * per-lineage rather than module-level: two unrelated `initialize()`
+ * calls each get their own stack and can never perturb each other,
+ * while every instance sharing one stack (a fork included, no matter
+ * where in the lineage it was created) resolves against the same
+ * active frame.
+ */
+export declare function toStack(): Stack;
+/**
+ * The shared body `initialize` and `fork` both reduce to: build a
+ * `RandomSource` from an already-resolved `Config`, then everything an
+ * `Instance` exposes off of it. Returns the `RandomSource` alongside
+ * the `Instance` — `initialize`/`fork` discard it, `wrap` keeps it to
+ * stash on the `Frame` it pushes, so implicit (ambient) and explicit
+ * (`scope.Fabricator`) construction inside one `wrap` resolve against
+ * the very same source rather than each independently re-deriving one
+ * from the same config (and so silently diverging/duplicating
+ * construction ordinals).
+ *
+ * `stack` is threaded straight through to `Constructor`/`enumerables`
+ * — this function never reads or writes it itself, only passes it
+ * along so every built `Fabricator`/`combinatorial`/`coverage` can
+ * consult whichever frame is active *at the moment each is called*,
+ * not at this moment.
+ */
+export declare function instantiate<$Registry extends PlainObject>(config: Config<$Registry>, stack: Stack): {
+    instance: Instance<$Registry>;
+    source: RandomSource;
+};

package/dist/types/Instance/Types.d.ts

@@ -0,0 +1,167 @@
+import type { Enumerable, Limits } from "../Enumeration/Types";
+import type { Constructor } from "../Fabricator/Constructor";
+import type { Algorithm, Attribution, Layered, RandomSource, Seed } from "../Random/Types";
+import type { PlainObject } from "../Utility/Types";
+/**
+ * A fully resolved instance configuration — every field present, nothing
+ * left to default. `Overlay` is what `fork` accepts; `overlay()`
+ * (`Instance/Core.ts`) is the only thing producing a complete `Config`.
+ *
+ * Two fields are declared at their caller-facing type but always hold
+ * their resolved form once `overlay()` has run: `seed` is `Seed` because
+ * that is what a caller may supply, but always holds the normalized
+ * array (`Instance.seed` is the authoritative read); `attribution` is
+ * `Attribution` for the same reason but always holds a
+ * `ResolvedAttribution`, a subtype. `clock` is different from both:
+ * unlike `seed`/`attribution`, it holds *either* a resolved instant
+ * (epoch milliseconds) or the unresolved `"seeded"` policy — never
+ * collapsed to a number by `overlay()` when `"seeded"`, because that
+ * policy must re-derive whenever the seed it composes changes (a
+ * `fork({ seed: layer(...) })`). The unconfigured default is a wall-
+ * clock number, inherited as-is like an explicit `Date`. `resolveClock`
+ * (`Instance/Core.ts`) is the one place that resolves `"seeded"` to a
+ * number, called fresh wherever the clock actually matters
+ * (`instantiate`, the `context.clock` getter) rather than once here.
+ */
+export type Config<$Registry extends PlainObject> = {
+    readonly seed: Seed;
+    readonly algorithm: Algorithm;
+    readonly attribution: Attribution;
+    readonly types: $Registry;
+    readonly limits: Limits;
+    readonly clock: number | "seeded";
+};
+/**
+ * What `fork` accepts — a `Config` to lay over a base, every field
+ * optional. Identical to `Partial<Config>` but for `seed`, which
+ * additionally accepts a {@link Layered}: a bare `Seed` replaces the
+ * base's seed outright (what `seed` means everywhere else in this
+ * library), `layer(seed)` appends onto it (`[...base.seed, ...seed]`)
+ * — the shape a wrapping integration wants, and what
+ * `ConstructorOptions`' layered form is for a single construction.
+ * Omitting `seed` inherits the base's unchanged. `clock` similarly
+ * accepts the caller-facing `Date | "seeded"` rather than `Config`'s
+ * own resolved `number | "seeded"`, so a caller can hand in a literal
+ * instant without converting it to epoch milliseconds themselves.
+ * `"seeded"` is the explicit opt-in that derives "now" from the
+ * instance seed; omitting `clock` at the root captures wall-clock time
+ * instead.
+ *
+ * `initialize`'s own parameter keeps a plain `seed?: Seed`, so passing
+ * `layer(...)` there is a compile error: there is no base to layer onto
+ * at the root.
+ */
+export type Overlay<$Registry extends PlainObject> = Partial<Omit<Config<$Registry>, "seed" | "clock">> & {
+    readonly seed?: Seed | Layered;
+    readonly clock?: Date | "seeded" | undefined;
+};
+/**
+ * One active `wrap` — its resolved config plus the single `RandomSource`
+ * every build reached inside that `wrap` shares, whether reached
+ * implicitly (any instance in the lineage consulting the active frame)
+ * or explicitly (`scope.Fabricator`, the `Instance` passed to the
+ * block). Storing the scope's own already-built `source` here, rather
+ * than each consumer re-deriving one from `config`, keeps the two
+ * routes resolving against the *same* source — sharing one set of
+ * construction-ordinal counters — instead of each silently starting
+ * its own.
+ */
+export type Frame = {
+    readonly config: Config<PlainObject>;
+    readonly source: RandomSource;
+};
+/**
+ * The per-lineage ambient stack. Created once at a root `initialize()`
+ * and threaded — never re-created — through every `fork`/`wrap`
+ * descended from it (see `instantiate`, `Instance/Core.ts`). Two
+ * unrelated `initialize()` calls stay fully isolated; one lineage's
+ * `wrap` reaches every instance in that lineage — its `Fabricator`,
+ * `combinatorial`, and `coverage` alike — regardless of where in the
+ * lineage that instance was itself created.
+ */
+export type Stack = {
+    current(): Frame | undefined;
+    /**
+     * Push `frame`, run `block`, pop — in a `finally`, so a frame unwinds
+     * correctly even if `block` throws.
+     */
+    enter<$Return>(frame: Frame, block: () => $Return): $Return;
+};
+/**
+ * The configuration in effect *right now* — the innermost active `wrap`
+ * frame, or this instance's own when there is none. Distinct from
+ * `ConstructionContext` (`Fabricator/Types.ts`), which is one
+ * construction's internal dispatch plumbing; this is the caller-facing
+ * "what configuration is in effect."
+ */
+export type Context = {
+    readonly seed: ReadonlyArray<string>;
+    readonly algorithm: Algorithm;
+    readonly attribution: Attribution;
+    readonly clock: number;
+};
+/**
+ * A single initialized library instance: the registry it was given, and
+ * a `construct()` bound to its own isolated randomness — its own seed,
+ * builder, and per-file overrides/streams, held internally and never
+ * shared with any other `initialize()` call. Independently initialized
+ * instances (e.g. parallel tests) can never perturb each other.
+ */
+export interface Instance<$Registry extends PlainObject> extends Pick<RandomSource, "seed"> {
+    /** The registry of type definers this instance was initialized with. */
+    readonly T: $Registry;
+    /**
+     * Turn a Schema built from `T` into a live Fabricator, deriving fresh
+     * randomness from this instance's own seed for whichever leaves
+     * actually need it.
+     */
+    Fabricator: Constructor;
+    /**
+     * Every combination of every enumerable node in `schema` — every enum
+     * member, both sides of an optional field, and so on — as a cartesian
+     * product, lazily. Throws eagerly, before producing anything, if the
+     * count exceeds `limits.combinatorial` (see `initialize`'s config).
+     */
+    combinatorial: Enumerable;
+    /**
+     * The minimum set of instances such that every option of every
+     * enumerable node in `schema` appears at least once — count equal to
+     * the *widest* single axis, not the product, with narrower axes
+     * cycling to fill it. Unbounded: its count can never exceed the
+     * schema as written, so unlike `combinatorial` it carries no limit.
+     */
+    coverage: Enumerable;
+    /**
+     * Derive a new instance laid over this one: anything the overlay names
+     * overrides, anything it omits inherits. A bare `seed` replaces this
+     * instance's seed; `seed: layer(...)` appends onto it. A peer of an
+     * `initialize()` return value in every respect, including its own
+     * `fork`.
+     */
+    fork<const $ForkRegistry extends PlainObject = $Registry>(overlay?: Overlay<$ForkRegistry>): Instance<$ForkRegistry>;
+    /**
+     * `fork(overlay)`, made ambient for the synchronous extent of `block`:
+     * every `new Fabricator(...)`, `combinatorial(...)`, and
+     * `coverage(...)` reached inside — on this instance or any other in
+     * the same lineage — resolves against the fork instead, with nothing
+     * threaded through. The fork is also passed to `block`: use it
+     * explicitly where that reads better, and *necessarily* for any async
+     * work, which the ambient frame does not survive — a build reached
+     * after an `await` inside `block` sees this instance's own
+     * configuration again, not the wrap's.
+     *
+     * A nested `wrap` lays over whichever frame is currently active, not
+     * over the instance it was called on — so `overlay.seed: layer(...)`
+     * accumulates with nesting depth while a bare `seed` still replaces
+     * outright, discarding every enclosing layer.
+     */
+    wrap<$Return, const $WrapRegistry extends PlainObject = $Registry>(overlay: Overlay<$WrapRegistry>, block: (scope: Instance<$WrapRegistry>) => $Return): $Return;
+    /**
+     * The configuration in effect right now: the innermost active `wrap`
+     * frame's, or this instance's own outside any `wrap`. A live view, not
+     * a snapshot — reflects whichever frame is active at the moment each
+     * property is read, since one `Instance` outlives any number of
+     * `wrap`s.
+     */
+    readonly context: Context;
+}

package/dist/types/Primitive/always/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, Value } from "./Types";
+export type Fabrication<$Fabricator extends Fabricator> = $Fabricator extends Fabricator<infer $Schema> ? Fabricated<$Schema[typeof Meta]["value"]> : never;
+export type Fabricator<$Schema extends {
+    [Meta]: ThisMeta;
+} = {
+    [Meta]: ThisMeta;
+}> = NaiveFabricator<Fabricated<$Schema[typeof Meta]["value"]>> & {
+    [Kind]: "always";
+    [Meta]: $Schema[typeof Meta];
+    readonly trace: Trace;
+    readonly [Adaptation]?: AdaptationsOf<$Schema>;
+    schema: Schema<$Schema[typeof Meta]["value"], AdaptationsOf<$Schema>>;
+};
+export declare function Fabricator<$Value extends Value>(context: FabricatorContext<Schema<$Value>>): Fabricator<Schema<$Value>>;

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

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

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

@@ -0,0 +1,19 @@
+import { type AdaptationEntry } from "../../Adapter/Core";
+import type { Adaptations, Adapter, Adapting, WithAdaptations } from "../../Adapter/Types";
+import type { Core, Value } from "./Types";
+/**
+ * A fixed value, so unlike every other kind there is no `.as()` — nothing
+ * left to override about producing it. `adapt` still applies: what a value
+ * *means* to an external schema library is a separate question from what it
+ * fabricates to, and for a value TypeBox cannot pin exactly (a `symbol`, or
+ * any value's *static* type — see `Adapter/TypeBox`'s `toConst`) it is the
+ * only way to close the gap.
+ */
+export interface Schema<$Value extends Value = Value, $Adaptations extends Adaptations = {}> extends Core<$Value, $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<$Value, $Adaptations>>) => $Returnable) => Schema<$Value, WithAdaptations<$Adaptations, AdaptationEntry<$Adapter, $Returnable>>>;
+}
+export declare function Schema<$Value extends Value, $Adaptations extends Adaptations = {}>(schema: Core<$Value, $Adaptations>): Schema<$Value, $Adaptations>;

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

@@ -0,0 +1,23 @@
+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`.
+ *
+ * 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;
+export type Meta<$Value extends Value = Value> = {
+    value: $Value;
+};
+export type Core<$Value extends Value = Value, $Adaptations extends Adaptations = {}> = {
+    [Kind]: "always";
+    [Meta]: Meta<$Value>;
+    readonly [Produces]?: Fabricated<$Value>;
+    readonly [Adaptation]?: $Adaptations;
+};

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

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

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

@@ -0,0 +1,18 @@
+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): {
+    /**
+     * 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.
+     */
+    as: (produce: Produce<Fabricated<$Definition>>) => Schema<$Definition>;
+};

package/dist/types/Primitive/array/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, Definition, Fabricated } from "./Types";
+/**
+ * The buildable recipe for an `array`: a single element Schema, repeated
+ * `whereby.length` times.
+ */
+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.
+     */
+    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.
+     */
+    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>;

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

@@ -0,0 +1,44 @@
+import type { Adaptations } from "../../Adapter/Types";
+import type { Bound, InputBound } from "../../Bound";
+import type { Produce } from "../../Random/Types";
+import type { AnySchema, ValueOf } from "../../Schema/Types";
+import type { Adaptation, Kind, Meta, Produces } from "../../Types";
+export type Definition = AnySchema;
+export type Fabricated<$Definition extends Definition, $Bindings extends unknown[] = []> = Array<ValueOf<$Definition, $Bindings>>;
+export type InputWhereby = {
+    length: number | {
+        max: InputBound<number>;
+        min?: InputBound<number> | undefined;
+    };
+};
+export type Whereby = {
+    length: {
+        min: Bound<number>;
+        max: Bound<number>;
+    };
+};
+/**
+ * `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.
+ */
+export type Meta<$Definition extends Definition = Definition> = {
+    definition: $Definition;
+    whereby: Whereby;
+    produce?: never;
+} | {
+    definition: $Definition;
+    whereby?: Whereby;
+    produce: Produce<Fabricated<$Definition>>;
+};
+export interface Core<$Definition extends Definition = Definition, $Adaptations extends Adaptations = {}> {
+    [Kind]: "array";
+    [Meta]: Meta<$Definition>;
+    bindings?: unknown[];
+    readonly [Produces]?: Fabricated<$Definition, NonNullable<this["bindings"]>>;
+    readonly [Adaptation]?: $Adaptations;
+}

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

@@ -0,0 +1,19 @@
+import type { Produce } from "../../Random/Types";
+import { Kind } from "../../Types";
+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`.
+     */
+    [Kind]: "bigint";
+    whereby: (whereby: InputWhereby) => Schema<{
+        whereby: Whereby;
+    }, {}>;
+    as: (produce: Produce<Fabricated>) => Schema<{
+        produce: Produce<bigint>;
+    }, {}>;
+};
+export default _default;