@ghostry/fabricator 0.0.1

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

@@ -0,0 +1,44 @@
+import type { Adaptations } from "../Adapter/Types";
+import type { Kind as SchemaKind } from "../Primitive";
+import { Adaptation, Kind, Meta, type Produces } from "../Types";
+import { type PlainObject } from "../Utility/Types";
+/**
+ * Normalize a Schema, a builder namespace, or an already-built
+ * Fabricator into a clean, storable Schema — keeping only `[Kind]`/
+ * `[Meta]`/`[Adaptation]` and discarding `fabricate` and any
+ * builder-method properties. This is what lets `object`/`array` fields,
+ * and registry `.extend()` registrations, accept any of the three
+ * interchangeably while only ever storing inert data: a built
+ * Fabricator's `[Meta]` is exactly the Schema it came from.
+ *
+ * `[Adaptation]` is carried rather than dropped because it is a
+ * property of the schema itself, not of the builder that produced it:
+ * a field adapted with `.adapt(adapter, produce)` has to still be
+ * adapted once normalized into its enclosing `object`/`array`, which
+ * is where every adapter actually reads it from (see
+ * `Adapter/TypeBox`'s `build`, which walks `[Meta].definition`).
+ *
+ * `$SchemaProduces` is threaded through in the type only (never read
+ * or written at runtime) so `ValueOf` stays precise across a
+ * `toSchema` call — dropping it would make every normalized field
+ * (e.g. every `object`/`array` element) fall back to `unknown`.
+ */
+export declare function toSchema<$Kind extends string, $Meta extends PlainObject, $Produces = unknown, $Adaptations extends Adaptations = Adaptations>(value: {
+    [Kind]: $Kind;
+    [Meta]: $Meta;
+    [Produces]?: $Produces;
+    [Adaptation]?: $Adaptations;
+}): {
+    [Kind]: $Kind;
+    [Meta]: $Meta;
+    readonly [Produces]?: $Produces;
+    readonly [Adaptation]?: $Adaptations;
+};
+/**
+ * Whether `value`'s basic JS shape is compatible with `kind` (one of
+ * this library's `[Kind]` literals, e.g. `"string"`, `"object"`,
+ * `"date"`). Stops at "is this the right *kind of value*" (right JS
+ * type/shape), not deeper schema constraints like a number's `whereby`
+ * range, a string's length, or a weighted-enum's member set.
+ */
+export declare function violatesKind(kind: SchemaKind, value: unknown): boolean;

package/dist/types/Schema/Registry.d.ts

@@ -0,0 +1,20 @@
+import * as primitives from "../Primitive";
+import { deepMerge, type DeepMerge } from "../Utility/DeepMerge";
+import { type PlainObject } from "../Utility/Types";
+/**
+ * `Primitive/index.ts` also exports the kind-module namespace as
+ * `Primitive` (`Primitive.boolean.Schema`, …). That is not a builder —
+ * omitting it here is what keeps `T.Primitive` from existing.
+ */
+type Builders = Omit<typeof primitives, "Primitive">;
+type RegistryInterface<$Registry> = {
+    extend: <const $Extension extends PlainObject>(types: (params: {
+        T: $Registry;
+        augment: typeof deepMerge;
+    }) => $Extension) => Registry<DeepMerge<$Registry, $Extension>>;
+};
+export type Registry<$Registry> = {
+    [$K in keyof $Registry as $K extends keyof RegistryInterface<$Registry> ? never : $K]: $Registry[$K];
+} & RegistryInterface<$Registry>;
+export declare const registry: Registry<Builders>;
+export {};

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

@@ -0,0 +1,70 @@
+import type { Adaptations } from "../Adapter/Types";
+import type { Kind as SchemaKind } from "../Primitive";
+import type { Adaptation, Kind, Meta, Produces } from "../Types";
+import type { PlainObject } from "../Utility/Types";
+/**
+ * The broadest Schema constraint: some kind, some config. Used by
+ * compound kinds (`object`/`array`) for their nested fields instead of
+ * the library-wide Schema union `Primitive/index.ts` assembles — that
+ * union imports every kind's `Core.ts`, so importing it back from
+ * within a kind's own `Core.ts` would cycle. Mirrors how
+ * `array.Definition` uses the equally generic `NaiveFabricator<any>`
+ * for the same reason.
+ */
+export type AnySchema = {
+    [Kind]: SchemaKind;
+    [Meta]: PlainObject;
+    [Adaptation]?: Adaptations;
+};
+/**
+ * Extract the value a Schema fabricates to, via the phantom,
+ * runtime-absent `[Produces]` marker every kind's `Schema` carries.
+ * This is what lets `object`/`array`'s per-field type extraction work
+ * uniformly across every kind without importing and enumerating them
+ * (which would cycle, since `object`/`array` can nest any kind,
+ * including each other) — the same role `fabricate: () => $T` already
+ * plays for `NaiveFabricator<infer $T>`, one step earlier, before a
+ * Schema has been built. `[Produces]` is always optional (never
+ * assigned at runtime — see `DeepMerge`'s handling of optional-only
+ * keys for why that matters).
+ *
+ * `$Bindings` is threaded down into every composite kind's children
+ * (each `Core` is an `interface` carrying an optional `bindings`, and
+ * forwards `NonNullable<this["bindings"]>` into its own `[Produces]`).
+ * It is a substitution slot for a self-reference, not a parameter of
+ * the schema the way `$Definition`/`$Value` are — every composite
+ * forwards it unread, so whatever `self` node is buried arbitrarily
+ * deep still receives it. A node whose `[Produces]` reads
+ * `bindings[0]` (`recursive.self.Core`) can then close a type-level
+ * fixed point, which is what makes a self-referential schema resolve
+ * rather than collapse to `unknown`. Mirrors TypeBox's
+ * `Static<T, P> = (T & { params: P })['static']`, renamed because
+ * "params" reads as configuration and this is closer to a
+ * de-Bruijn-style resolution environment — kept as a tuple, as
+ * TypeBox's is, so a second bound self-reference could occupy index 1
+ * later without restructuring, though nothing today defines what that
+ * would mean. `test/ValueOfBindings.types.test.ts` is the only thing
+ * asserting any of it.
+ *
+ * Three details here are load-bearing, and each looks simplifiable:
+ *
+ * - **Indexed access, not a conditional `infer`.** Writing this as
+ *   `($Schema & { bindings: $Bindings }) extends { [Produces]?: infer $T } ? ...`
+ *   fails with `TS2615` — the bindings do not collapse, and the error
+ *   surfaces as `unknown[] & [...]`.
+ * - **`Required<>`, never `Exclude<..., undefined>`.** Both strip the
+ *   `| undefined` that indexing an optional property adds, but
+ *   `Exclude` also strips the *legitimate* `undefined` out of
+ *   `nullish`/`undefinable`/`object.optional`/`undefined`'s own value
+ *   types.
+ * - **The `extends` guard belongs inside, not on the parameter.**
+ *   Constraining `$Schema` instead would force `[Produces]` onto
+ *   `AnySchema` (which deliberately omits it), and that shifts
+ *   variance enough to break `.as`'s contravariant parameter check in
+ *   `Fabrication.types.test.ts`.
+ */
+export type ValueOf<$Schema, $Bindings extends unknown[] = []> = $Schema extends {
+    readonly [Produces]?: unknown;
+} ? Required<$Schema & {
+    bindings: $Bindings;
+}>[typeof Produces] : unknown;

package/dist/types/Types.d.ts

@@ -0,0 +1,78 @@
+import type { Fabricator } from "./Fabricator/Types";
+import type { AnySchema } from "./Schema/Types";
+export declare const Kind: unique symbol;
+export declare const Meta: unique symbol;
+export declare const Produces: unique symbol;
+export declare const Replace: unique symbol;
+export declare const Fixed: unique symbol;
+/**
+ * Tags a `Seed` as composing onto whatever base is in effect, rather
+ * than replacing it — the reading a bare `seed` has everywhere else in
+ * this library. `layer()` (`Random/index.ts`) is the only producer; a
+ * caller never names this symbol, mirroring `[Replace]`. Unlike every
+ * other symbol in this file, it tags a config value (a `Seed`), not a
+ * Schema or Fabricator — see `Random/Types.ts`'s `Layered`.
+ */
+export declare const Layer: unique symbol;
+/**
+ * The Fabricators that exist at build time — whatever
+ * `Constructor.ts`'s `make` already constructed for this node's nested
+ * schemas before handing them to the kind's own `Fabricator()` factory.
+ * Every composite kind whose construction receives already-dispatched
+ * Fabricators carries this: `object` (its `Fields` map), `tuple`
+ * (`elements`, in slot order), `choice` (the dispatched options, in
+ * `[Meta].items` order — weights stay in `[Meta]`), `array` (the single
+ * shared `element`), `record` (`{ key, value }`), and each of
+ * `nullable`/`nullish`/`undefinable`/`object.omittable`/`object.optional`
+ * (the single wrapped `source`).
+ *
+ * The payload shape is kind-private, exactly as `[Meta]` is — nothing
+ * outside a kind's own files interprets another kind's `[Children]`
+ * shape.
+ *
+ * `recursive` carries none: its expansions are a function of draws
+ * made *during* `fabricate()` (`recursive/Fabricator.ts`), one
+ * throwaway Fabricator per `self` occurrence, so there is no stable
+ * child at build time to point at. `body`/`terminal` are already on
+ * `[Meta]` as ordinary sub-Schemas for anything that needs to
+ * introspect them.
+ */
+export declare const Children: unique symbol;
+/**
+ * A per-library map of external-schema overrides
+ * (`{ typebox: (schema) => TSchema }`), written by every kind's
+ * `.adapt(adapter, produce)` builder method and read only by
+ * `src/Adapter/*` — completely inert for fabrication, which never
+ * looks at it. A map rather than a single function so one schema can
+ * map to several external libraries at once; see `Adapter/Types.ts`
+ * for the registry of supported libraries, and `Adapter/TypeBox`'s
+ * `ToTypeBox`/`convert` for the reading end.
+ */
+export declare const Adaptation: unique symbol;
+/**
+ * A public sentinel with two uses that share one meaning — "this key
+ * does not appear in the fabricated object": `object.omittable`'s and
+ * `object.optional`'s Fabricators return it internally when their roll
+ * lands on absence (read by `object/Fabricator.ts`'s fabricate loop,
+ * never surfaced to a caller fabricating normally), and it is also the
+ * value a caller passes in `.override(...)`/`.fabricate(overrides)` to
+ * force an omittable or optional field off — `{ a: undefined }`
+ * present-as-`undefined` is not expressible this way, since that would
+ * conflate with a genuinely present-but-`undefined` value (see
+ * `Primitive/undefined`, and `Primitive/object/optional`, which
+ * distinguishes the two outcomes).
+ */
+export declare const Omitted: unique symbol;
+/**
+ * Everything `construct()`/`toTypeBox()` accept as a starting point: a
+ * not-yet-built Schema, or something already built into a Fabricator.
+ */
+export type Buildable = AnySchema | Fabricator<any>;
+/**
+ * The span of valid `Date` time values: ±8.64e15 ms from the epoch. An
+ * ECMAScript spec fact (`Date`'s own representable range), not a
+ * `date`-kind detail — lives here rather than in `Primitive/date/` so
+ * `Random/index.ts`'s `deriveClock` can use it without importing from
+ * `Primitive/`.
+ */
+export declare const MAX_TIME = 8640000000000000;

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

@@ -0,0 +1,35 @@
+import { Replace } from "../Types";
+import { type PlainObject } from "./Types";
+/**
+ * Syntactic sugar for an IIFE.
+ */
+export declare function inline<$T>(fn: () => $T): $T;
+export declare function never(_: never): never;
+/**
+ * @see https://github.com/microsoft/TypeScript/issues/17002
+ */
+export declare function isArray(candidate: unknown): candidate is Array<unknown> | ReadonlyArray<unknown>;
+export declare function isPollutionKey(key: string): boolean;
+/**
+ * A plain `{}`/`Object.create(null)` object — not an array, `Date`,
+ * class instance, etc.
+ */
+export declare function isPlainObject(value: unknown): value is PlainObject;
+/**
+ * Keys worth carrying across a merge. String keys are subject to the
+ * prototype-pollution guard; symbol keys (e.g. a fabricator's
+ * `[Kind]`/`[Meta]`) are carried through — dropping them would strip a
+ * primitive's identity when it is extended — except `Replace`, which is
+ * a directive consumed here rather than data to propagate.
+ */
+export declare function mergeableKeys(source: PlainObject): Array<string | symbol>;
+/**
+ * Tag an object so a subsequent deep or shallow merge replaces the
+ * left-hand operand wholesale instead of merging into it. The
+ * `[Replace]` directive is consumed by the merge and does not appear
+ * on the result, so callers can wrap a replacement value without ever
+ * naming the symbol.
+ */
+export declare function replace<$T extends PlainObject>(value: $T): $T & {
+    [Replace]: true;
+};

package/dist/types/Utility/DeepMerge.d.ts

@@ -0,0 +1,14 @@
+import { Replace } from "../Types";
+import type { PlainObject, Pretty } from "./Types";
+export type DeepMerge<$A, $B> = $B extends {
+    [Replace]: true;
+} ? Pretty<Omit<$B, typeof Replace>> : Pretty<{
+    [$K in Exclude<keyof $A | keyof $B, typeof Replace>]: $A extends {
+        [_ in $K]?: infer $AV;
+    } ? $B extends {
+        [_ in $K]?: infer $BV;
+    } ? $AV extends PlainObject ? $BV extends PlainObject ? DeepMerge<$AV, $BV> : $BV : $BV : $AV : $B extends {
+        [_ in $K]?: infer $BV;
+    } ? $BV : never;
+}>;
+export declare function deepMerge<$A extends PlainObject, $B extends PlainObject>(a: $A, b: $B): DeepMerge<$A, $B>;

package/dist/types/Utility/Digest.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hash an arbitrary string into four 32-bit seed words via cyrb128, so any
+ * `string` seed can fully seed sfc32's 128 bits of state. A good hash here
+ * matters: it decorrelates similar seeds (`"1"` vs `"2"`) so they produce
+ * unrelated streams rather than near-identical ones.
+ *
+ * @see https://stackoverflow.com/a/47593316
+ */
+export declare function cyrb128(str: string): [number, number, number, number];

package/dist/types/Utility/ShallowMerge.d.ts

@@ -0,0 +1,6 @@
+import { Replace } from "../Types";
+import type { PlainObject, Pretty } from "./Types";
+export type ShallowMerge<$A, $B> = $B extends {
+    [Replace]: true;
+} ? Pretty<Omit<$B, typeof Replace>> : Pretty<Omit<$A, keyof $B> & Omit<$B, typeof Replace>>;
+export declare function shallowMerge<$A extends PlainObject, $B extends PlainObject>(a: $A, b: $B): ShallowMerge<$A, $B>;

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

@@ -0,0 +1,4 @@
+export type Pretty<$T> = {
+    [$K in keyof $T]: $T[$K];
+} & {};
+export type PlainObject<$T = unknown> = Record<string | symbol, $T>;

package/dist/types/index.d.ts

@@ -0,0 +1,186 @@
+import type { Limits } from "./Enumeration/Types";
+import type { Instance } from "./Instance/Types";
+import type { Algorithm, Attribution, Seed } from "./Random/Types";
+import { registry } from "./Schema/Registry";
+import type { PlainObject } from "./Utility/Types";
+export declare function initialize<const $Registry extends PlainObject = typeof registry>(config?: Partial<{
+    /** The registry of type definers to use — `registry` itself. */
+    types: $Registry;
+    /**
+     * Optional mixer composed into every stream beside `clock`. Accepts
+     * a single string, or several — several lets a seed be composed out
+     * of independent, meaningful parts (a user id, a scenario label)
+     * without hand-joining them first. If omitted, the seed is empty
+     * (unless `FABRICATOR_SEED` / `SEED` / `RANDOM_SEED` supplies one):
+     * wall-clock `clock` is the default entropy, so an unconfigured
+     * instance varies by run and replays from `context.clock` alone.
+     * Pass a seed when two instances should share a clock but draw
+     * different universes, or when `clock: "seeded"` should make the
+     * seed itself the reproducibility unit.
+     */
+    seed?: Seed;
+    /**
+     * Bring your own PRNG: a factory that, given a seed, returns a
+     * source of randomness — a `() => number` in `[0, 1)`, a drop-in
+     * for `Math.random`. Defaults to the built-in `sfc32` generator.
+     */
+    algorithm?: Algorithm;
+    /**
+     * How this instance attributes a construction's randomness to the
+     * file it was written in:
+     *
+     * - `{ kind: "rooted", root }` expresses every file relative to
+     *   `root` (an absolute path or a `file://` URL), so the same seed
+     *   reproduces the same data on a checkout at a different absolute
+     *   path.
+     * - `{ kind: "call site" }`, the default, is `"rooted"` at the
+     *   directory of whichever file called `initialize()`.
+     * - `{ kind: "none" }` attributes nothing: every construction of a
+     *   given kind anywhere in the instance shares one stream, keyed
+     *   by kind alone.
+     *
+     * See [Reproducibility](https://ghostry-dev.github.io/fabricator/guides/reproducibility)
+     * for the trade-offs between the three.
+     */
+    attribution?: Attribution;
+    /**
+     * Instance-wide numeric ceilings. `combinatorial` bounds how many
+     * instances `combinatorial(...)` may enumerate — the check is
+     * eager, it throws at call time before any instance is produced.
+     * Defaults to 1024 if omitted. `coverage(...)` carries no entry
+     * here: its count is the widest single axis, so there is nothing
+     * for a limit to protect against.
+     */
+    limits?: Limits;
+    /**
+     * What `T.date.past`/`T.date.future` (and any producer reading
+     * `ProduceContext.clock`) resolve "now" against — and, because it
+     * sits in every leaf's trace, the default entropy for the instance.
+     * Defaults to the wall-clock instant of this `initialize()` call, so
+     * an unconfigured run has realistic dates and varies by process, and
+     * replays from `context.clock` (with the same empty or supplied
+     * `seed`). Pass a fixed `Date` to freeze "now" (and the rest of the
+     * run, unless `seed` also differs). Pass `"seeded"` to derive "now"
+     * from the instance seed instead — an instant drawn across the whole
+     * representable `Date` span, so an implausible date is the expected
+     * outcome of that policy, not a bug. `"seeded"` is what makes `seed`
+     * alone the reproducibility unit.
+     */
+    clock?: Date | "seeded";
+}>): Instance<$Registry>;
+export { Omitted } from "./Types";
+/**
+ * Tags a `Seed` — for `new Fabricator(schema, { seed })`, or `fork`'s
+ * own `Overlay.seed` — as composing onto whatever base is in effect,
+ * rather than replacing it outright.
+ */
+export { layer } from "./Random";
+/**
+ * `layer(...)`'s return type, so a caller building one programmatically
+ * can name it — the same rationale as the existing `Seed`/`Attribution`
+ * exports.
+ */
+export type { Layered } from "./Random/Types";
+/**
+ * Every failure this library raises is an instance of this class — see
+ * `src/Error/index.ts` for the full hierarchy. Only the base is
+ * public; subclasses are distinguished by `.name`.
+ */
+export { FabricatorError } from "./Error";
+/**
+ * The adapter contract, exported because an adapter is a separate
+ * package rather than something registered here: `Adapter`/`Recurse`
+ * are what one declares, `drive` is what its conversion entry point
+ * calls, and `Adaptation`/`AdaptationsOf` are how it reads what a
+ * Schema declared — `[Adaptation]` at runtime, `AdaptationsOf` at the
+ * type level, keyed by its own `key` in both cases.
+ *
+ * This package names no external schema library and depends on none:
+ * every mapping, and every dependency it needs, belongs to the
+ * adapter.
+ *
+ * `Adapting` is the odd one out, facing whoever *writes* an adaptation
+ * rather than whoever implements an adapter: it is the parameter type
+ * of every kind's `.adapt(adapter, produce)` producer, so a caller
+ * writing that producer as a named function can name it — the same
+ * reason `Stream` is exported below.
+ */
+export { drive } from "./Adapter/Core";
+export type { Adaptations, AdaptationsOf, Adapter, Adapting, Recurse, } from "./Adapter/Types";
+export { Adaptation } from "./Types";
+/**
+ * The default registry of type definers, exported so it can be
+ * extended via `registry.extend(({ T }) => ({ ... }))` before being
+ * passed to `initialize({ types })`.
+ */
+export { registry } from "./Schema/Registry";
+/**
+ * Canonical `{ value, exclusive }` endpoint stored on `whereby` min/max,
+ * plus the call-site union that still accepts a scalar (inclusive). Exported
+ * so a named `.whereby(...)` argument or an `.adapt` producer reading `meta`
+ * can type it — the same rationale as `Stream`.
+ */
+export type { Bound, InputBound } from "./Bound";
+export { toBound, effectiveDiscrete } from "./Bound";
+/**
+ * Public because it is the type of `ProduceContext`'s `random` member
+ * — the seeded stream every kind's `.as(produce)` and `T.opaque`'s
+ * producer are handed — so a caller writing either as a named function
+ * can name it.
+ */
+export type { Stream } from "./Random/Types";
+/**
+ * What every kind's `.as(produce)` producer is called with — a single
+ * curated object rather than a positional argument list, so a caller
+ * writing the producer as a named function can name its parameter.
+ * `T.opaque`'s producer takes the same shape.
+ */
+export type { ProduceContext } from "./Random/Types";
+/**
+ * The shape `initialize({ seed })` and `new Fabricator(schema, { seed })`
+ * both accept — a single string, or several — so a caller building one
+ * programmatically (rather than as an inline literal) can name the
+ * type.
+ */
+export type { Seed } from "./Random/Types";
+/**
+ * The shape `initialize({ attribution })` accepts, so a caller building
+ * one programmatically — a rooted policy derived from an env var, say
+ * — can name the type.
+ */
+export type { Attribution } from "./Random/Types";
+/**
+ * Reads the value type a built Fabricator produces straight off its
+ * `fabricate` signature — `Fabrication<typeof Product>` instead of
+ * `ReturnType<typeof Product.fabricate>`.
+ */
+export type { Fabrication } from "./Fabricator/Types";
+/**
+ * Reads the value type a Schema (not yet built) will eventually
+ * produce, via its phantom `[Produces]` marker. Mostly useful for a
+ * helper that accepts a Schema before it's built into a Fabricator.
+ */
+export type { ValueOf } from "./Schema/Types";
+/**
+ * `fabricator.trace`'s type — otherwise unnameable by a caller
+ * wanting to hold onto one, the same reason `Stream` is exported
+ * above.
+ */
+export type { Trace } from "./Random/Types";
+/**
+ * How `file` and `ordinal` on a {@link Trace} were resolved — recorded
+ * so a captured trace is self-describing, including `"counted"`
+ * (replayed for a node taken from inside a `T.recursive` expansion;
+ * not a variant you choose when building).
+ */
+export type { RootKind } from "./Random/Types";
+/**
+ * `fork`/`wrap`'s own config shapes, so a caller building an overlay
+ * programmatically (rather than as an inline literal) can name them —
+ * the same rationale as the existing `Seed`/`Attribution` exports.
+ * `Config` is what `initialize`'s own parameter is a `Partial` of;
+ * `Overlay` is what `fork`/`wrap` accept; `Context` is
+ * `instance.context`'s own type, so a caller writing a helper that
+ * reads it can name the parameter.
+ */
+export type { Config, Context, Overlay } from "./Instance/Types";

package/dist/types/internal.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The "adapter-authoring SDK" entry point — published as the
+ * `@ghostry/fabricator/internal` package export, deliberately *not*
+ * re-exported from `./index.ts`. An external adapter package (e.g.
+ * `@ghostry/fabricator-adapter-typebox-v0`) needs to walk a Schema/
+ * Fabricator structurally and dispatch on each primitive kind's `Core`
+ * shape — see "Match `Core`, never `Schema`, in a dispatch" — which
+ * the end-user-facing `.` export has no reason to carry.
+ *
+ * Also this package's own white-box test suite's route to source: a
+ * test file imports through `@ghostry/fabricator`/
+ * `@ghostry/fabricator/internal` rather than a relative `../src/...`
+ * path specifically so it resolves through the built `dist/` (see the
+ * "Random", "Schema", and "Enumeration" groups below) — the same
+ * reason an adapter needs this entry point, applied to this package's
+ * own tests instead of an external one.
+ *
+ * Everything here is curated, not incidental. When wiring a new leaf
+ * kind into the rest of the system, add its module to
+ * `Primitive/namespace.ts` (re-exported here as `Primitive`), or no
+ * adapter can reach that kind's `Core` type.
+ */
+export type { Fabrication, NaiveFabricator } from "./Fabricator/Types";
+export { Children, Kind, Meta, Produces, type Buildable } from "./Types";
+export { isPlainObject } from "./Utility/Core";
+export type * as Primitive from "./Primitive/namespace";
+/**
+ * `Schema/Types.ts`'s own value-type resolution, needed by tests
+ * asserting `ValueOf<...>` directly rather than through a built
+ * Fabricator's `Fabrication<...>`.
+ */
+export type { ValueOf } from "./Schema/Types";
+/**
+ * `Constructor` is `Instance.Fabricator`'s own type — public in effect
+ * (every `initialize()` caller receives one), just never named
+ * directly by the `.` export, which only ever describes it inline.
+ */
+export type { Constructor } from "./Fabricator/Constructor";
+/**
+ * The enumeration planner's own shapes — `combinatorial`/`coverage`
+ * (the `.` export's public entry points) are built on `plan`/`resolve`,
+ * which a test asserting `axisFor`'s per-kind width/strategy decisions
+ * needs directly.
+ */
+export { plan, resolve } from "./Enumeration/Plan";
+export type { Axis, Enumerable, Pin, Resolvable } from "./Enumeration/Types";
+/**
+ * The randomness layer underneath
+ * `initialize({ seed, algorithm, attribution })` and a Fabricator's
+ * `.trace` — needed by tests exercising stream attribution and
+ * construction directly, beneath the level `initialize()` itself
+ * exposes.
+ */
+export { defaultAlgorithm, encode, randomSeed, toRandomSource, toStream, toStreamFromTrace, } from "./Random";
+export type { Algorithm, ConstructionTrace, ConstructorOptions, ResolvedAttribution, RootKind, RootPins, Seed, Trace, } from "./Random/Types";
+/**
+ * `Random/CallSite.ts`'s pure string helpers. Exported for this
+ * package's own tests: the percent-encoded, `file://`-prefixed, and
+ * backslashed spellings they exist to fold together cannot be produced
+ * by running the suite from an ordinary POSIX checkout, so they have
+ * to be driven with synthetic frame strings instead of real stack
+ * frames.
+ */
+export { directoryOf, normalizeLocation, relativize } from "./Random/CallSite";

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@ghostry/fabricator",
+  "version": "0.0.1",
+  "license": "MIT",
+  "description": "Fabricate typed data from composable schemas.",
+  "keywords": [
+    "factory"
+  ],
+  "author": {
+    "name": "Patrick Rebsch"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ghostry-dev/fabricator",
+    "directory": "pkg/fabricator"
+  },
+  "homepage": "https://github.com/ghostry-dev/fabricator",
+  "bugs": "https://github.com/ghostry-dev/fabricator/issues",
+  "type": "module",
+  "types": "./dist/types/index.d.ts",
+  "module": "./dist/esm/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./internal": {
+      "types": "./dist/types/internal.d.ts",
+      "import": "./dist/esm/internal.js",
+      "default": "./dist/esm/internal.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build:reset": "rm -rf ./dist",
+    "build:compile": "bunx --no-install --bun rslib build --config ./rslib.config.ts",
+    "build:compile:rsdoctor": "RSDOCTOR=true bunx --no-install --bun rslib build --config ./rslib.config.ts",
+    "build:clean": "find ./dist -type f -name '*.tsbuildinfo' -delete",
+    "build": "bun run build:reset && bun run build:compile && bun run build:clean",
+    "build:rsdoctor": "bun run build:reset && bun run build:compile:rsdoctor && bun run build:clean",
+    "check": "tsc --noEmit",
+    "check:ts5": "bun --bun ../../node_modules/typescript-5/lib/tsc.js --noEmit",
+    "prettier": "bunx --no-install --bun prettier .",
+    "test": "bun run check && bun run check:ts5 && bun test"
+  },
+  "files": [
+    "dist"
+  ]
+}