@databehave/schema 0.1.2 → 0.1.4

package/dist/generator/replay.js

@@ -0,0 +1,61 @@
+/**
+ * Replay / snapshot helpers — thin layer over `mock()` for tests.
+ *
+ * `replay(schema, opts)` returns a function bound to a fixed (seed, input)
+ * pair. Calling it twice always returns deep-equal values; the function is
+ * the canonical way to assert determinism in test suites.
+ *
+ * `expectStable(schema, opts)` runs the generator twice and throws if the
+ * outputs differ — surfaces non-determinism introduced by misuse of
+ * `derivedFrom` (e.g. reading `Date.now()`).
+ */
+import { isDeepStrictEqual } from 'node:util';
+import { mock } from './engine.js';
+/** Build a deterministic, repeatedly-callable generator. */
+export const replay = (schema, options = {}) => {
+    const frozen = deepFreeze({ ...options });
+    const fn = (() => mock(schema, frozen));
+    Object.defineProperty(fn, 'options', { value: frozen, enumerable: true });
+    return fn;
+};
+/** Recursively `Object.freeze` plain objects and arrays so callers cannot
+ *  mutate bound options through nested references (e.g. `options.input`). */
+const deepFreeze = (value) => {
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (Object.isFrozen(value))
+        return value;
+    Object.freeze(value);
+    for (const k of Object.keys(value)) {
+        deepFreeze(value[k]);
+    }
+    return value;
+};
+/**
+ * Run the generator twice with identical inputs and assert deep equality.
+ * Returns the produced value on success; throws on divergence.
+ *
+ * **This is a diagnostic, not a determinism guarantee.** It runs the
+ * schema *twice* with the same seed and compares the outputs
+ * structurally — useful for catching obvious non-determinism (a
+ * `derivedFrom` reading `Date.now()`, a stray `Math.random()`,
+ * iteration over a `Set`), but two iterations cannot prove the entire
+ * RNG sequence is fixed. The strong contract is {@link replay}, which
+ * binds a (seed, input) pair and lets the caller pin the value at the
+ * snapshot site.
+ *
+ * Treat `expectStable` as the equivalent of a smoke test: cheap to
+ * keep in a regression suite, fast to fail loudly when a callback
+ * goes off-piste, but not a substitute for `replay`-backed snapshots
+ * for surfaces that must round-trip across releases.
+ */
+export const expectStable = (schema, options = {}) => {
+    const a = mock(schema, options);
+    const b = mock(schema, options);
+    if (!isDeepStrictEqual(a, b)) {
+        throw new Error('expectStable: generator produced different values for identical seed/input — ' +
+            'likely a non-deterministic derivedFrom callback (e.g. Date.now, Math.random, network).');
+    }
+    return a;
+};
+//# sourceMappingURL=replay.js.map

package/dist/generator/replay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.js","sourceRoot":"","sources":["../../src/generator/replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAE7C,OAAO,EAAE,IAAI,EAAoB,MAAM,aAAa,CAAA;AAWpD,4DAA4D;AAC5D,MAAM,CAAC,MAAM,MAAM,GAAG,CAAmB,MAAS,EAAE,UAAuB,EAAE,EAAa,EAAE;IAC1F,MAAM,MAAM,GAAG,UAAU,CAAC,EAAE,GAAG,OAAO,EAAE,CAAgB,CAAA;IACxD,MAAM,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAyB,CAAA;IAC/D,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAA;IACzE,OAAO,EAAE,CAAA;AACX,CAAC,CAAA;AAED;6EAC6E;AAC7E,MAAM,UAAU,GAAG,CAAI,KAAQ,EAAK,EAAE;IACpC,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IAC7D,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAA;IACxC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IACpB,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAgC,CAAC,EAAE,CAAC;QAC9D,UAAU,CAAE,KAAiC,CAAC,CAAC,CAAC,CAAC,CAAA;IACnD,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAmB,MAAS,EAAE,UAAuB,EAAE,EAAY,EAAE;IAC/F,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,MAAM,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,IAAI,CAAC,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CACb,+EAA+E;YAC7E,wFAAwF,CAC3F,CAAA;IACH,CAAC;IACD,OAAO,CAAC,CAAA;AACV,CAAC,CAAA"}

package/dist/generator/trace.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Trace collector — records which axis fired at each path during a
+ * single `mock()` call.
+ *
+ * The trace is a read-only audit of the generator's decisions: every
+ * produced value is annotated with the axis that won.
+ *
+ * Usage:
+ *
+ *   const trace = createTrace()
+ *   const value = mock(schema, { seed: 's', trace })
+ *   console.log(trace.entries)  // → TraceEntry[]
+ */
+/**
+ * Which axis decided a value at a given path.
+ *
+ *   - `default`        : pure value (`undefined` slot in optional/default)
+ *   - `optional-skip`  : optional field rolled `undefined`
+ *   - `nullable-null`  : nullable field rolled `null`
+ *   - `derived`        : produced by `derivedFrom(...)`
+ *   - `occasionally`   : forced by an `occasionally(...)` override
+ *   - `eventually`     : forced by an `eventually(...)` override (modulo `index`)
+ *   - `invariant-pass` : sampled then accepted by all `invariant(...)`
+ *   - `invariant-fail` : retry exhausted before invariants held
+ *   - `domain`         : sampled from `in([...])` candidate set
+ *   - `distribution`   : sampled via `weighted|normal|typically`
+ *   - `type`           : fell through to type-default sampling
+ */
+export type TraceAxis = 'default' | 'optional-skip' | 'nullable-null' | 'derived' | 'occasionally' | 'eventually' | 'invariant-pass' | 'invariant-fail' | 'domain' | 'distribution' | 'type';
+export type TraceEntry = {
+    readonly path: readonly (string | number)[];
+    readonly axis: TraceAxis;
+    /** Attempts taken before invariants accepted (only meaningful when invariants run). */
+    readonly attempts?: number;
+    /** Free-form annotation (e.g. distribution kind, picked literal). */
+    readonly note?: string;
+};
+export type TraceCollector = {
+    /** Append a single entry. Called by the engine — do not call from user code. */
+    readonly emit: (entry: TraceEntry) => void;
+    /** Read-only view of entries collected so far. */
+    readonly entries: readonly TraceEntry[];
+    /** All paths where a specific axis fired. */
+    readonly axisFiredAt: (axis: TraceAxis) => readonly (readonly (string | number)[])[];
+    /** Pretty multi-line dump (one entry per line, JSON-pointer-style paths). */
+    readonly format: () => string;
+};
+export declare const createTrace: () => TraceCollector;
+//# sourceMappingURL=trace.d.ts.map

package/dist/generator/trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.d.ts","sourceRoot":"","sources":["../../src/generator/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,eAAe,GACf,eAAe,GACf,SAAS,GACT,cAAc,GACd,YAAY,GACZ,gBAAgB,GAChB,gBAAgB,GAChB,QAAQ,GACR,cAAc,GACd,MAAM,CAAA;AAEV,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IAC3C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,uFAAuF;IACvF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,qEAAqE;IACrE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAA;IAC1C,kDAAkD;IAClD,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAA;IACvC,6CAA6C;IAC7C,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,SAAS,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,EAAE,CAAA;IACpF,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,MAAM,MAAM,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,WAAW,QAAO,cAuB9B,CAAA"}

package/dist/generator/trace.js

@@ -0,0 +1,38 @@
+/**
+ * Trace collector — records which axis fired at each path during a
+ * single `mock()` call.
+ *
+ * The trace is a read-only audit of the generator's decisions: every
+ * produced value is annotated with the axis that won.
+ *
+ * Usage:
+ *
+ *   const trace = createTrace()
+ *   const value = mock(schema, { seed: 's', trace })
+ *   console.log(trace.entries)  // → TraceEntry[]
+ */
+export const createTrace = () => {
+    const entries = [];
+    return {
+        emit(entry) {
+            entries.push(entry);
+        },
+        get entries() {
+            return entries;
+        },
+        axisFiredAt(axis) {
+            return entries.filter((e) => e.axis === axis).map((e) => e.path);
+        },
+        format() {
+            return entries
+                .map((e) => {
+                const ptr = '/' + e.path.map((p) => String(p)).join('/');
+                const attempts = e.attempts !== undefined ? ` attempts=${e.attempts}` : '';
+                const note = e.note !== undefined ? ` (${e.note})` : '';
+                return `${ptr.padEnd(40)} ${e.axis}${attempts}${note}`;
+            })
+                .join('\n');
+        },
+    };
+};
+//# sourceMappingURL=trace.js.map

package/dist/generator/trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.js","sourceRoot":"","sources":["../../src/generator/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAkDH,MAAM,CAAC,MAAM,WAAW,GAAG,GAAmB,EAAE;IAC9C,MAAM,OAAO,GAAiB,EAAE,CAAA;IAChC,OAAO;QACL,IAAI,CAAC,KAAK;YACR,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QACrB,CAAC;QACD,IAAI,OAAO;YACT,OAAO,OAAO,CAAA;QAChB,CAAC;QACD,WAAW,CAAC,IAAI;YACd,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;QAClE,CAAC;QACD,MAAM;YACJ,OAAO,OAAO;iBACX,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;gBACT,MAAM,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;gBACxD,MAAM,QAAQ,GAAG,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAA;gBAC1E,MAAM,IAAI,GAAG,CAAC,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAA;gBACvD,OAAO,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,QAAQ,GAAG,IAAI,EAAE,CAAA;YACxD,CAAC,CAAC;iBACD,IAAI,CAAC,IAAI,CAAC,CAAA;QACf,CAAC;KACF,CAAA;AACH,CAAC,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * databehave — Zero-dependency data schema DSL.
+ *
+ * Public surface:
+ *   - schema DSL (primitives, composites, decimal, conditional)
+ *   - data-schema axes (distribution, derived, invariants, domain,
+ *     discriminated unions, dataset with identity, eventually, correlate)
+ *   - generator (`mock`) + validator (`parse`/`safeParse`)
+ *   - debug / determinism (`createTrace`, `replay`, `expectStable`)
+ *   - cross-dataset FK (`relate`)
+ *   - extensibility (`walkSchema`, `fromIR`, low-level PRNG, IR types) for
+ *     third-party packages (CLI, OpenAPI ingestion, zod adapters, …)
+ *
+ * databehave intentionally ships NO HTTP/server/framework integration. Wire it
+ * into your transport of choice (Fastify/Express/msw/node:http) in ~80 LOC.
+ */
+export { str, num, int, bool, null_, StringSchema, NumberSchema, IntSchema, BooleanSchema, NullSchema, } from './schema/primitives.js';
+export { decimal, DecimalSchema } from './schema/decimal.js';
+export { obj, arr, tuple, union, literal, enum_, ObjectSchema, ArraySchema, TupleSchema, UnionSchema, LiteralSchema, EnumSchema, } from './schema/composites.js';
+export { discriminated } from './schema/conditional.js';
+export { mock, type MockOptions, type ModifierProbs, type StableByFn } from './generator/engine.js';
+export type { Rng } from './foundation/prng.js';
+export { parse, safeParse, type SafeParseResult } from './validator/parse.js';
+export { createTrace, type TraceAxis, type TraceCollector, type TraceEntry, } from './generator/trace.js';
+export { replay, expectStable, type Replay } from './generator/replay.js';
+export { mockDataset, identityFor, type DatasetOptions } from './dataset/dataset.js';
+export { relate, type RelateOptions } from './dataset/relate.js';
+export { Schema, type Infer, type Modifiers, type SchemaNode } from './foundation/types.js';
+export type { Axes, DerivedFn, Distribution, DomainConstraint, EventuallyOverride, GenContext, InvariantFn, NormalDistribution, OccasionalOverride, TypicalDistribution, WeightedDistribution, } from './foundation/axes.js';
+export { DataBehaveError, ConformError, SchemaConflictError, type Issue, type IssueCode, } from './foundation/errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EACL,GAAG,EACH,GAAG,EACH,GAAG,EACH,IAAI,EACJ,KAAK,EACL,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,aAAa,EACb,UAAU,GACX,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAC5D,OAAO,EACL,GAAG,EACH,GAAG,EACH,KAAK,EACL,KAAK,EACL,OAAO,EACP,KAAK,EACL,YAAY,EACZ,WAAW,EACX,WAAW,EACX,WAAW,EACX,aAAa,EACb,UAAU,GACX,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAGvD,OAAO,EAAE,IAAI,EAAE,KAAK,WAAW,EAAE,KAAK,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACnG,YAAY,EAAE,GAAG,EAAE,MAAM,sBAAsB,CAAA;AAC/C,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC7E,OAAO,EACL,WAAW,EACX,KAAK,SAAS,EACd,KAAK,cAAc,EACnB,KAAK,UAAU,GAChB,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,KAAK,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAGzE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACpF,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAGhE,OAAO,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,uBAAuB,CAAA;AAC3F,YAAY,EACV,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,EACV,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EACL,eAAe,EACf,YAAY,EACZ,mBAAmB,EACnB,KAAK,KAAK,EACV,KAAK,SAAS,GACf,MAAM,wBAAwB,CAAA"}

package/dist/index.js

@@ -0,0 +1,34 @@
+/**
+ * databehave — Zero-dependency data schema DSL.
+ *
+ * Public surface:
+ *   - schema DSL (primitives, composites, decimal, conditional)
+ *   - data-schema axes (distribution, derived, invariants, domain,
+ *     discriminated unions, dataset with identity, eventually, correlate)
+ *   - generator (`mock`) + validator (`parse`/`safeParse`)
+ *   - debug / determinism (`createTrace`, `replay`, `expectStable`)
+ *   - cross-dataset FK (`relate`)
+ *   - extensibility (`walkSchema`, `fromIR`, low-level PRNG, IR types) for
+ *     third-party packages (CLI, OpenAPI ingestion, zod adapters, …)
+ *
+ * databehave intentionally ships NO HTTP/server/framework integration. Wire it
+ * into your transport of choice (Fastify/Express/msw/node:http) in ~80 LOC.
+ */
+// ── schema DSL ────────────────────────────────────────────────────────────
+export { str, num, int, bool, null_, StringSchema, NumberSchema, IntSchema, BooleanSchema, NullSchema, } from './schema/primitives.js';
+export { decimal, DecimalSchema } from './schema/decimal.js';
+export { obj, arr, tuple, union, literal, enum_, ObjectSchema, ArraySchema, TupleSchema, UnionSchema, LiteralSchema, EnumSchema, } from './schema/composites.js';
+export { discriminated } from './schema/conditional.js';
+// ── generator + validator ─────────────────────────────────────────────────
+export { mock } from './generator/engine.js';
+export { parse, safeParse } from './validator/parse.js';
+export { createTrace, } from './generator/trace.js';
+export { replay, expectStable } from './generator/replay.js';
+// ── dataset ───────────────────────────────────────────────────────────────
+export { mockDataset, identityFor } from './dataset/dataset.js';
+export { relate } from './dataset/relate.js';
+// ── foundation types & axes ───────────────────────────────────────────────
+export { Schema } from './foundation/types.js';
+// ── errors ────────────────────────────────────────────────────────────────
+export { DataBehaveError, ConformError, SchemaConflictError, } from './foundation/errors.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,6EAA6E;AAC7E,OAAO,EACL,GAAG,EACH,GAAG,EACH,GAAG,EACH,IAAI,EACJ,KAAK,EACL,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,aAAa,EACb,UAAU,GACX,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AAC5D,OAAO,EACL,GAAG,EACH,GAAG,EACH,KAAK,EACL,KAAK,EACL,OAAO,EACP,KAAK,EACL,YAAY,EACZ,WAAW,EACX,WAAW,EACX,WAAW,EACX,aAAa,EACb,UAAU,GACX,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAEvD,6EAA6E;AAC7E,OAAO,EAAE,IAAI,EAAyD,MAAM,uBAAuB,CAAA;AAEnG,OAAO,EAAE,KAAK,EAAE,SAAS,EAAwB,MAAM,sBAAsB,CAAA;AAC7E,OAAO,EACL,WAAW,GAIZ,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,MAAM,EAAE,YAAY,EAAe,MAAM,uBAAuB,CAAA;AAEzE,6EAA6E;AAC7E,OAAO,EAAE,WAAW,EAAE,WAAW,EAAuB,MAAM,sBAAsB,CAAA;AACpF,OAAO,EAAE,MAAM,EAAsB,MAAM,qBAAqB,CAAA;AAEhE,6EAA6E;AAC7E,OAAO,EAAE,MAAM,EAA+C,MAAM,uBAAuB,CAAA;AAe3F,6EAA6E;AAC7E,OAAO,EACL,eAAe,EACf,YAAY,EACZ,mBAAmB,GAGpB,MAAM,wBAAwB,CAAA"}

package/dist/internal.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @databehave/schema/internal — low-level extensibility surface.
+ *
+ * Re-exports the IR walker, the IR discriminants, the axis types, and
+ * seeded PRNG primitives that exist for third-party packages (CLI tools,
+ * OpenAPI ingestion, zod adapters, …) to build on. These are versioned
+ * more loosely than the main DSL:
+ *
+ *   • SchemaNode / IR shape changes are MAJOR (see docs/stability.md).
+ *   • PRNG output is deterministic across PATCH/MINOR for a given seed.
+ *
+ * **Do not import from `@databehave/schema/internal` in application code.**
+ * Prefer the high-level `mock()` / `parse()` / `safeParse()` from the package
+ * root. Importing internals couples you to the IR and bypasses fail-loud guards.
+ */
+export { walkSchema, fromIR, serializeSchema, deserializeSchema, IR_VERSION, type SchemaEnvelope, type SchemaVisitor, type WalkPath, } from './foundation/walk.js';
+export { mulberry32, rngFromString, seedFromString, type Rng, } from './foundation/prng.js';
+export { Schema } from './foundation/types.js';
+export type { Infer } from './foundation/types.js';
+export type { ArrayKind, BooleanKind, DecimalKind, DiscriminatedKind, EnumKind, LiteralKind, Modifiers, NullKind, NumberKind, ObjectKind, SchemaCore, SchemaNode, StringFormat, StringKind, TupleKind, UnionKind, } from './foundation/ir.js';
+export type { Axes, DerivedFn, Distribution, DomainConstraint, EventuallyOverride, GenContext, InvariantFn, NormalDistribution, OccasionalOverride, TypicalDistribution, WeightedDistribution, } from './foundation/axes.js';
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,UAAU,EACV,MAAM,EACN,eAAe,EACf,iBAAiB,EACjB,UAAU,EACV,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,QAAQ,GACd,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,UAAU,EACV,aAAa,EACb,cAAc,EACd,KAAK,GAAG,GACT,MAAM,sBAAsB,CAAA;AAS7B,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAC9C,YAAY,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAA;AAElD,YAAY,EAEV,SAAS,EACT,WAAW,EACX,WAAW,EACX,iBAAiB,EACjB,QAAQ,EACR,WAAW,EACX,SAAS,EACT,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,EACV,UAAU,EACV,YAAY,EACZ,UAAU,EACV,SAAS,EACT,SAAS,GACV,MAAM,oBAAoB,CAAA;AAE3B,YAAY,EAEV,IAAI,EACJ,SAAS,EACT,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,UAAU,EACV,WAAW,EACX,kBAAkB,EAClB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,sBAAsB,CAAA"}

package/dist/internal.js

@@ -0,0 +1,25 @@
+/**
+ * @databehave/schema/internal — low-level extensibility surface.
+ *
+ * Re-exports the IR walker, the IR discriminants, the axis types, and
+ * seeded PRNG primitives that exist for third-party packages (CLI tools,
+ * OpenAPI ingestion, zod adapters, …) to build on. These are versioned
+ * more loosely than the main DSL:
+ *
+ *   • SchemaNode / IR shape changes are MAJOR (see docs/stability.md).
+ *   • PRNG output is deterministic across PATCH/MINOR for a given seed.
+ *
+ * **Do not import from `@databehave/schema/internal` in application code.**
+ * Prefer the high-level `mock()` / `parse()` / `safeParse()` from the package
+ * root. Importing internals couples you to the IR and bypasses fail-loud guards.
+ */
+export { walkSchema, fromIR, serializeSchema, deserializeSchema, IR_VERSION, } from './foundation/walk.js';
+export { mulberry32, rngFromString, seedFromString, } from './foundation/prng.js';
+// ── extension-author types ─────────────────────────────────────────
+//
+// Surfaced so extension code (codegen, IR transforms, OpenAPI adapters)
+// can name the IR discriminants and the `_applyAxes` argument shape
+// without reaching into deep paths. Type-only re-exports — they emit
+// no runtime JS.
+export { Schema } from './foundation/types.js';
+//# sourceMappingURL=internal.js.map

package/dist/internal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.js","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,UAAU,EACV,MAAM,EACN,eAAe,EACf,iBAAiB,EACjB,UAAU,GAIX,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,UAAU,EACV,aAAa,EACb,cAAc,GAEf,MAAM,sBAAsB,CAAA;AAE7B,sEAAsE;AACtE,EAAE;AACF,wEAAwE;AACxE,oEAAoE;AACpE,qEAAqE;AACrE,iBAAiB;AAEjB,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/schema/composites.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Composite schema builders: obj, arr, tuple, union, literal, enum_.
+ *
+ * These produce TS types derived from their inputs via mapped / conditional
+ * types so that {@link Infer} yields the exact composite shape.
+ */
+import type { ArrayKind, EnumKind, LiteralKind, ObjectKind, TupleKind, UnionKind } from '../foundation/ir.js';
+import { Discrete, Schema, type Infer } from '../foundation/types.js';
+type Fields = Record<string, Schema>;
+/** Keys whose schema carries `optional: true` become optional in the output. */
+type OptionalKeys<F extends Fields> = {
+    [K in keyof F]: F[K]['_node']['mods'] extends {
+        optional: true;
+    } ? K : never;
+}[keyof F];
+type RequiredKeys<F extends Fields> = Exclude<keyof F, OptionalKeys<F>>;
+export type InferObject<F extends Fields> = {
+    [K in RequiredKeys<F>]: Infer<F[K]>;
+} & {
+    [K in OptionalKeys<F>]?: Infer<F[K]>;
+};
+export declare class ObjectSchema<F extends Fields = Fields> extends Schema<{
+    [K in keyof InferObject<F>]: InferObject<F>[K];
+}> {
+    readonly _node: ObjectKind & {
+        mods?: import('../foundation/ir.js').Modifiers;
+    };
+    readonly _fields: F;
+    constructor(fields: F);
+    /**
+     * Multi-field invariant — a predicate over the whole assembled object.
+     *
+     * Equivalent to `.invariant(...)` but typed against the object's inferred
+     * shape, so cross-field rules (e.g. `start <= end`) get full type-checking.
+     * The engine rejection-samples the object up to MAX_ATTEMPTS until the
+     * predicate holds.
+     */
+    correlate(fn: (row: InferObject<F>) => boolean): this;
+}
+export declare const obj: <F extends Fields>(fields: F) => ObjectSchema<F>;
+export declare class ArraySchema<S extends Schema> extends Schema<Infer<S>[]> {
+    readonly _node: ArrayKind & {
+        mods?: import('../foundation/ir.js').Modifiers;
+    };
+    readonly _item: S;
+    constructor(item: S, opts?: {
+        length?: number;
+        minLength?: number;
+        maxLength?: number;
+    });
+    /**
+     * Rebuild a fresh `ArraySchema` while preserving every previously-set
+     * bound *and* every modifier (axes, occasionally, derivedFrom,
+     * describe, weighted, …). Without this, `.min(2).max(10)` would
+     * silently drop the `min` and `arr(int()).typically(1,5).min(2)`
+     * would lose the distribution axis because the constructor builds
+     * the IR node from scratch. Mods live in `_node.mods`, which is
+     * outside the bounds-only constructor surface, so they have to be
+     * grafted back on after construction via `withMods`.
+     */
+    private rebuild;
+    length(n: number): ArraySchema<S>;
+    min(n: number): ArraySchema<S>;
+    max(n: number): ArraySchema<S>;
+}
+export declare const arr: <S extends Schema>(item: S) => ArraySchema<S>;
+type InferTuple<T extends readonly Schema[]> = {
+    [K in keyof T]: T[K] extends Schema ? Infer<T[K]> : never;
+};
+export declare class TupleSchema<T extends readonly Schema[]> extends Schema<InferTuple<T>> {
+    readonly _node: TupleKind & {
+        mods?: import('../foundation/ir.js').Modifiers;
+    };
+    readonly _items: T;
+    constructor(items: T);
+}
+export declare const tuple: <T extends readonly Schema[]>(...items: T) => TupleSchema<T>;
+type InferUnion<T extends readonly Schema[]> = T[number] extends Schema ? Infer<T[number]> : never;
+export declare class UnionSchema<T extends readonly Schema[]> extends Schema<InferUnion<T>> {
+    readonly _node: UnionKind & {
+        mods?: import('../foundation/ir.js').Modifiers;
+    };
+    readonly _options: T;
+    constructor(options: T);
+}
+export declare const union: <T extends readonly Schema[]>(...options: T) => UnionSchema<T>;
+export declare class LiteralSchema<V extends string | number | boolean | null> extends Schema<V> {
+    readonly _node: LiteralKind & {
+        mods?: import('../foundation/ir.js').Modifiers;
+    };
+    readonly [Discrete]: true;
+}
+export declare const literal: <V extends string | number | boolean | null>(value: V) => LiteralSchema<V>;
+export declare class EnumSchema<V extends string | number> extends Schema<V> {
+    readonly _node: EnumKind & {
+        mods?: import('../foundation/ir.js').Modifiers;
+    };
+    readonly [Discrete]: true;
+    readonly _values: readonly V[];
+    constructor(values: readonly V[]);
+}
+export declare const enum_: <V extends string | number>(values: readonly V[]) => EnumSchema<V>;
+export {};
+//# sourceMappingURL=composites.d.ts.map

package/dist/schema/composites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composites.d.ts","sourceRoot":"","sources":["../../src/schema/composites.ts"],"names":[],"mappings":"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"}

package/dist/schema/composites.js

@@ -0,0 +1,134 @@
+/**
+ * Composite schema builders: obj, arr, tuple, union, literal, enum_.
+ *
+ * These produce TS types derived from their inputs via mapped / conditional
+ * types so that {@link Infer} yields the exact composite shape.
+ */
+import { withMods } from '../foundation/ir.js';
+import { Discrete, Schema } from '../foundation/types.js';
+/** Field names that would clobber Object.prototype or pollute the prototype chain. */
+const FORBIDDEN_FIELD_NAMES = new Set(['__proto__', 'prototype', 'constructor']);
+const assertSafeFieldNames = (fields) => {
+    for (const k of Object.keys(fields)) {
+        if (FORBIDDEN_FIELD_NAMES.has(k)) {
+            throw new RangeError(`obj(): field name ${JSON.stringify(k)} is forbidden ` +
+                `(would shadow Object.prototype; rename the field).`);
+        }
+    }
+};
+export class ObjectSchema extends Schema {
+    _fields;
+    constructor(fields) {
+        assertSafeFieldNames(fields);
+        const irFields = {};
+        for (const k of Object.keys(fields)) {
+            irFields[k] = fields[k]._node;
+        }
+        super({ kind: 'object', fields: irFields });
+        this._fields = fields;
+    }
+    /**
+     * Multi-field invariant — a predicate over the whole assembled object.
+     *
+     * Equivalent to `.invariant(...)` but typed against the object's inferred
+     * shape, so cross-field rules (e.g. `start <= end`) get full type-checking.
+     * The engine rejection-samples the object up to MAX_ATTEMPTS until the
+     * predicate holds.
+     */
+    correlate(fn) {
+        return this.invariant((v) => fn(v));
+    }
+}
+export const obj = (fields) => new ObjectSchema(fields);
+// ──────────────────────────────────────────────────────────────────────────
+// array
+// ──────────────────────────────────────────────────────────────────────────
+export class ArraySchema extends Schema {
+    _item;
+    constructor(item, opts = {}) {
+        const base = {
+            kind: 'array',
+            item: item._node,
+            ...(opts.length !== undefined ? { length: opts.length } : {}),
+            ...(opts.minLength !== undefined ? { minLength: opts.minLength } : {}),
+            ...(opts.maxLength !== undefined ? { maxLength: opts.maxLength } : {}),
+        };
+        super(base);
+        this._item = item;
+    }
+    /**
+     * Rebuild a fresh `ArraySchema` while preserving every previously-set
+     * bound *and* every modifier (axes, occasionally, derivedFrom,
+     * describe, weighted, …). Without this, `.min(2).max(10)` would
+     * silently drop the `min` and `arr(int()).typically(1,5).min(2)`
+     * would lose the distribution axis because the constructor builds
+     * the IR node from scratch. Mods live in `_node.mods`, which is
+     * outside the bounds-only constructor surface, so they have to be
+     * grafted back on after construction via `withMods`.
+     */
+    rebuild(patch) {
+        const node = this._node;
+        const next = new ArraySchema(this._item, {
+            ...(node.length !== undefined ? { length: node.length } : {}),
+            ...(node.minLength !== undefined ? { minLength: node.minLength } : {}),
+            ...(node.maxLength !== undefined ? { maxLength: node.maxLength } : {}),
+            ...patch,
+        });
+        if (node.mods) {
+            // `_node` is declared `readonly` for the public API but we own
+            // both ends of the assignment here — the just-built instance is
+            // not observable to anyone else yet, so re-seating its IR node
+            // is safe and avoids an extra clone.
+            ;
+            next._node = withMods(next._node, node.mods);
+        }
+        return next;
+    }
+    length(n) {
+        return this.rebuild({ length: n });
+    }
+    min(n) {
+        return this.rebuild({ minLength: n });
+    }
+    max(n) {
+        return this.rebuild({ maxLength: n });
+    }
+}
+export const arr = (item) => new ArraySchema(item);
+export class TupleSchema extends Schema {
+    _items;
+    constructor(items) {
+        super({ kind: 'tuple', items: items.map((s) => s._node) });
+        this._items = items;
+    }
+}
+export const tuple = (...items) => new TupleSchema(items);
+export class UnionSchema extends Schema {
+    _options;
+    constructor(options) {
+        if (options.length === 0) {
+            throw new RangeError('union: requires at least one option');
+        }
+        super({ kind: 'union', options: options.map((s) => s._node) });
+        this._options = options;
+    }
+}
+export const union = (...options) => new UnionSchema(options);
+// ──────────────────────────────────────────────────────────────────────────
+// literal / enum
+// ──────────────────────────────────────────────────────────────────────────
+export class LiteralSchema extends Schema {
+}
+export const literal = (value) => new LiteralSchema({ kind: 'literal', value });
+export class EnumSchema extends Schema {
+    _values;
+    constructor(values) {
+        if (values.length === 0) {
+            throw new RangeError('enum: requires at least one value');
+        }
+        super({ kind: 'enum', values });
+        this._values = values;
+    }
+}
+export const enum_ = (values) => new EnumSchema(values);
+//# sourceMappingURL=composites.js.map

package/dist/schema/composites.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composites.js","sourceRoot":"","sources":["../../src/schema/composites.ts"],"names":[],"mappings":"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"}

package/dist/schema/conditional.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Discriminated union.
+ *
+ * `discriminated(key, map)` builds a schema whose branches are selected by
+ * the value of the named discriminator field, both during generation and
+ * during validation.
+ *
+ * Each entry in `map` must be an object-kind schema whose `key` field is a
+ * `literal(...)` matching the map key. This is enforced at build time so
+ * the discriminator is genuinely useful: generation picks one branch and
+ * sets the key; validation reads the key and dispatches to the matching
+ * branch (O(1), with errors keyed on the discriminator).
+ *
+ * ```ts
+ * const Variant = discriminated('kind', {
+ *   alpha: obj({ kind: literal('alpha'), score:  decimal(10, 4) }),
+ *   beta:  obj({ kind: literal('beta'),  weight: decimal(10, 4) }),
+ * })
+ * ```
+ */
+import { Schema, type Infer } from '../foundation/types.js';
+/**
+ * Build a discriminated union keyed on `key`. Each value in `map` must be a
+ * schema (typically `obj({...})`) whose `key` field is a `literal(...)`
+ * matching the map key.
+ */
+export declare const discriminated: <K extends string, M extends Readonly<Record<string, Schema<unknown>>>>(key: K, map: M) => Schema<{ [P in keyof M]: Infer<M[P]>; }[keyof M]>;
+//# sourceMappingURL=conditional.d.ts.map

package/dist/schema/conditional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional.d.ts","sourceRoot":"","sources":["../../src/schema/conditional.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,MAAM,EAAE,KAAK,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAK3D;;;;GAIG;AACH,eAAO,MAAM,aAAa,GACxB,CAAC,SAAS,MAAM,EAGhB,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAEnD,KAAK,CAAC,EACN,KAAK,CAAC,KACL,MAAM,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAE,CAAC,MAAM,CAAC,CAAC,CA+BjD,CAAA"}