@databehave/schema 0.1.3 → 0.2.0

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"}

package/dist/schema/conditional.js

@@ -0,0 +1,52 @@
+/**
+ * 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 } from '../foundation/types.js';
+const isObjectNode = (n) => n.kind === 'object';
+/**
+ * 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 const discriminated = (key, map) => {
+    const tags = Object.keys(map);
+    if (tags.length === 0) {
+        throw new RangeError(`discriminated("${key}"): map must contain at least one branch`);
+    }
+    const branches = {};
+    for (const tag of tags) {
+        const branch = map[tag]._node;
+        if (!isObjectNode(branch)) {
+            throw new RangeError(`discriminated("${key}"): branch ${JSON.stringify(tag)} must be an obj({...}) schema`);
+        }
+        const keyField = branch.fields[key];
+        if (keyField === undefined) {
+            throw new RangeError(`discriminated("${key}"): branch ${JSON.stringify(tag)} is missing the discriminator field "${key}"`);
+        }
+        if (keyField.kind !== 'literal' || keyField.value !== tag) {
+            throw new RangeError(`discriminated("${key}"): branch ${JSON.stringify(tag)} must declare ` +
+                `${key}: literal(${JSON.stringify(tag)})`);
+        }
+        branches[tag] = branch;
+    }
+    const node = { kind: 'discriminated', key, branches };
+    return new Schema(node);
+};
+//# sourceMappingURL=conditional.js.map

package/dist/schema/conditional.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional.js","sourceRoot":"","sources":["../../src/schema/conditional.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAGH,OAAO,EAAE,MAAM,EAAc,MAAM,wBAAwB,CAAA;AAE3D,MAAM,YAAY,GAAG,CAAC,CAAa,EAAgC,EAAE,CACnE,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAA;AAErB;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAM3B,GAAM,EACN,GAAM,EAC4C,EAAE;IACpD,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IAC7B,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,UAAU,CAAC,kBAAkB,GAAG,0CAA0C,CAAC,CAAA;IACvF,CAAC;IAED,MAAM,QAAQ,GAA+B,EAAE,CAAA;IAC/C,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,MAAM,MAAM,GAAI,GAAG,CAAC,GAAG,CAAY,CAAC,KAAK,CAAA;QACzC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,UAAU,CAClB,kBAAkB,GAAG,cAAc,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,+BAA+B,CACtF,CAAA;QACH,CAAC;QACD,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACnC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,MAAM,IAAI,UAAU,CAClB,kBAAkB,GAAG,cAAc,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,wCAAwC,GAAG,GAAG,CACrG,CAAA;QACH,CAAC;QACD,IAAI,QAAQ,CAAC,IAAI,KAAK,SAAS,IAAI,QAAQ,CAAC,KAAK,KAAK,GAAG,EAAE,CAAC;YAC1D,MAAM,IAAI,UAAU,CAClB,kBAAkB,GAAG,cAAc,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,gBAAgB;gBACpE,GAAG,GAAG,aAAa,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAC5C,CAAA;QACH,CAAC;QACD,QAAQ,CAAC,GAAG,CAAC,GAAG,MAAM,CAAA;IACxB,CAAC;IAED,MAAM,IAAI,GAAsB,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAA;IACxE,OAAO,IAAI,MAAM,CAAC,IAAI,CAAgE,CAAA;AACxF,CAAC,CAAA"}

package/dist/schema/decimal.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Decimal — fixed-point numeric represented as a string for precision safety.
+ *
+ * Targets Snowflake / Postgres NUMERIC(precision, scale). Generated values are
+ * always strings (e.g. `"123.4500000000000000000"` for scale=19) so callers
+ * never lose precision through JavaScript number coercion.
+ *
+ * The inferred type is `string` for ergonomic interop with the rest of the
+ * ecosystem. Callers needing a nominal brand can intersect via `Infer<typeof S>
+ * & Brand` themselves; databehave intentionally avoids forcing a brand to keep
+ * `decimal().default('0.0')` and JSON round-trips friction-free.
+ */
+import type { DecimalKind, Modifiers } from '../foundation/ir.js';
+import { Continuous, Numeric, Schema } from '../foundation/types.js';
+export declare class DecimalSchema extends Schema<string> {
+    readonly _node: DecimalKind & {
+        mods?: Modifiers;
+    };
+    readonly [Numeric]: true;
+    readonly [Continuous]: true;
+    /** Inclusive lower bound. Pass as a numeric string. */
+    min(value: string | number): DecimalSchema;
+    /** Inclusive upper bound. Pass as a numeric string. */
+    max(value: string | number): DecimalSchema;
+}
+/**
+ * Declare a fixed-point decimal column.
+ *
+ * @param precision - total significant digits (1..38 for Snowflake)
+ * @param scale - digits after the decimal point (0..precision)
+ */
+export declare const decimal: (precision: number, scale: number) => DecimalSchema;
+//# sourceMappingURL=decimal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../src/schema/decimal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpE,qBAAa,aAAc,SAAQ,MAAM,CAAC,MAAM,CAAC;IAC/C,SAAiB,KAAK,EAAE,WAAW,GAAG;QAAE,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,CAAA;IAC1D,SAAiB,CAAC,OAAO,CAAC,EAAE,IAAI,CAAA;IAChC,SAAiB,CAAC,UAAU,CAAC,EAAE,IAAI,CAAA;IAEnC,uDAAuD;IACvD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa;IAG1C,uDAAuD;IACvD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,aAAa;CAG3C;AAED;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,WAAW,MAAM,EAAE,OAAO,MAAM,KAAG,aAQ1D,CAAA"}

package/dist/schema/decimal.js

@@ -0,0 +1,39 @@
+/**
+ * Decimal — fixed-point numeric represented as a string for precision safety.
+ *
+ * Targets Snowflake / Postgres NUMERIC(precision, scale). Generated values are
+ * always strings (e.g. `"123.4500000000000000000"` for scale=19) so callers
+ * never lose precision through JavaScript number coercion.
+ *
+ * The inferred type is `string` for ergonomic interop with the rest of the
+ * ecosystem. Callers needing a nominal brand can intersect via `Infer<typeof S>
+ * & Brand` themselves; databehave intentionally avoids forcing a brand to keep
+ * `decimal().default('0.0')` and JSON round-trips friction-free.
+ */
+import { Continuous, Numeric, Schema } from '../foundation/types.js';
+export class DecimalSchema extends Schema {
+    /** Inclusive lower bound. Pass as a numeric string. */
+    min(value) {
+        return new DecimalSchema({ ...this._node, min: String(value) });
+    }
+    /** Inclusive upper bound. Pass as a numeric string. */
+    max(value) {
+        return new DecimalSchema({ ...this._node, max: String(value) });
+    }
+}
+/**
+ * Declare a fixed-point decimal column.
+ *
+ * @param precision - total significant digits (1..38 for Snowflake)
+ * @param scale - digits after the decimal point (0..precision)
+ */
+export const decimal = (precision, scale) => {
+    if (!Number.isInteger(precision) || precision < 1 || precision > 38) {
+        throw new RangeError(`decimal: precision must be integer in [1, 38], got ${precision}`);
+    }
+    if (!Number.isInteger(scale) || scale < 0 || scale > precision) {
+        throw new RangeError(`decimal: scale must be integer in [0, precision], got ${scale}`);
+    }
+    return new DecimalSchema({ kind: 'decimal', precision, scale });
+};
+//# sourceMappingURL=decimal.js.map

package/dist/schema/decimal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal.js","sourceRoot":"","sources":["../../src/schema/decimal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAEpE,MAAM,OAAO,aAAc,SAAQ,MAAc;IAK/C,uDAAuD;IACvD,GAAG,CAAC,KAAsB;QACxB,OAAO,IAAI,aAAa,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IACjE,CAAC;IACD,uDAAuD;IACvD,GAAG,CAAC,KAAsB;QACxB,OAAO,IAAI,aAAa,CAAC,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IACjE,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,SAAiB,EAAE,KAAa,EAAiB,EAAE;IACzE,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,SAAS,GAAG,CAAC,IAAI,SAAS,GAAG,EAAE,EAAE,CAAC;QACpE,MAAM,IAAI,UAAU,CAAC,sDAAsD,SAAS,EAAE,CAAC,CAAA;IACzF,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,GAAG,SAAS,EAAE,CAAC;QAC/D,MAAM,IAAI,UAAU,CAAC,yDAAyD,KAAK,EAAE,CAAC,CAAA;IACxF,CAAC;IACD,OAAO,IAAI,aAAa,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAA;AACjE,CAAC,CAAA"}

package/dist/schema/primitives.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Primitive schema builders: str, num, int, bool, null_.
+ *
+ * Each returns a {@link Schema} instance whose phantom `_type` reflects the
+ * generated TypeScript type, and whose `_node` is the serializable IR.
+ */
+import type { Modifiers, NumberKind, StringKind } from '../foundation/ir.js';
+import { Continuous, Discrete, Numeric, Schema } from '../foundation/types.js';
+export declare class StringSchema extends Schema<string> {
+    readonly _node: StringKind & {
+        mods?: Modifiers;
+    };
+    readonly [Discrete]: true;
+    min(n: number): StringSchema;
+    max(n: number): StringSchema;
+    pattern(re: RegExp | string): StringSchema;
+}
+export declare const str: () => StringSchema;
+export declare class NumberSchema extends Schema<number> {
+    readonly _node: NumberKind & {
+        mods?: Modifiers;
+    };
+    min(n: number): this;
+    max(n: number): this;
+    protected cloneWithNode(node: NumberKind & {
+        mods?: Modifiers;
+    }): this;
+}
+/** `int()`-flavoured number — discrete, no Gaussian. Extends `NumberSchema`. */
+export declare class IntSchema extends NumberSchema {
+    readonly [Discrete]: true;
+}
+export declare const num: () => NumberSchema & {
+    readonly [Numeric]: true;
+    readonly [Continuous]: true;
+};
+export declare const int: () => IntSchema & {
+    readonly [Numeric]: true;
+};
+export declare class BooleanSchema extends Schema<boolean> {
+    readonly [Discrete]: true;
+}
+export declare class NullSchema extends Schema<null> {
+}
+export declare const bool: () => BooleanSchema;
+export declare const null_: () => NullSchema;
+//# sourceMappingURL=primitives.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../src/schema/primitives.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAC5E,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAM9E,qBAAa,YAAa,SAAQ,MAAM,CAAC,MAAM,CAAC;IAC9C,SAAiB,KAAK,EAAE,UAAU,GAAG;QAAE,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,CAAA;IACzD,SAAiB,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAA;IAEjC,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAG5B,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAG5B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,YAAY;CAM3C;AAED,eAAO,MAAM,GAAG,QAAO,YACgC,CAAA;AA4BvD,qBAAa,YAAa,SAAQ,MAAM,CAAC,MAAM,CAAC;IAC9C,SAAiB,KAAK,EAAE,UAAU,GAAG;QAAE,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,CAAA;IAEzD,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAGpB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAIpB,SAAS,CAAC,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG;QAAE,IAAI,CAAC,EAAE,SAAS,CAAA;KAAE,GAAG,IAAI;CAKvE;AAED,gFAAgF;AAChF,qBAAa,SAAU,SAAQ,YAAY;IACzC,SAAiB,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAA;CAClC;AAED,eAAO,MAAM,GAAG,QAAO,YAAY,GAAG;IACpC,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,CAAA;IACxB,QAAQ,CAAC,CAAC,UAAU,CAAC,EAAE,IAAI,CAAA;CAK1B,CAAA;AAEH,eAAO,MAAM,GAAG,QAAO,SAAS,GAAG;IAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,CAAA;CAG1D,CAAA;AAMH,qBAAa,aAAc,SAAQ,MAAM,CAAC,OAAO,CAAC;IAChD,SAAiB,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAA;CAClC;AAED,qBAAa,UAAW,SAAQ,MAAM,CAAC,IAAI,CAAC;CAAG;AAE/C,eAAO,MAAM,IAAI,QAAO,aAAuD,CAAA;AAE/E,eAAO,MAAM,KAAK,QAAO,UAA8C,CAAA"}

package/dist/schema/primitives.js

@@ -0,0 +1,78 @@
+/**
+ * Primitive schema builders: str, num, int, bool, null_.
+ *
+ * Each returns a {@link Schema} instance whose phantom `_type` reflects the
+ * generated TypeScript type, and whose `_node` is the serializable IR.
+ */
+import { Continuous, Discrete, Numeric, Schema } from '../foundation/types.js';
+// ──────────────────────────────────────────────────────────────────────────
+// string
+// ──────────────────────────────────────────────────────────────────────────
+export class StringSchema extends Schema {
+    min(n) {
+        return new StringSchema({ ...this._node, min: n });
+    }
+    max(n) {
+        return new StringSchema({ ...this._node, max: n });
+    }
+    pattern(re) {
+        return new StringSchema({
+            ...this._node,
+            pattern: typeof re === 'string' ? re : re.source,
+        });
+    }
+}
+export const str = () => new StringSchema({ kind: 'string', format: 'plain' });
+// ──────────────────────────────────────────────────────────────────────────
+// number / int
+//
+// `NumberSchema` is the base class for both float-shaped (`num()`) and
+// integer-shaped (`int()`) numeric schemas — the IR-level distinction is
+// `_node.int`, this hierarchy is just a type-system reflection of it.
+//
+// Capability markers are NOT declared on the `NumberSchema` class because
+// they need to differ between the two factories without violating subclass
+// override constraints:
+//   - `num()` returns `NumberSchema & { [Numeric]: true; [Continuous]: true }`
+//     — gets `.normal` / `.typically`, but NOT `.weighted` (continuous
+//     values can't be enumerated).
+//   - `int()` returns `IntSchema & { [Numeric]: true }` (with `[Discrete]`
+//     declared on the class) — gets `.weighted` and `.typically` (the
+//     latter clamps and rounds), but NOT `.normal` (Gaussian on integers
+//     would silently lose σ to rounding).
+//   - `decimal()` (in `./decimal.ts`) carries `[Numeric]` AND `[Continuous]`
+//     by class declaration, mirroring `num()`.
+//
+// `min` / `max` use `this`-typed returns (rather than the explicit class
+// type) so the marker intersection is preserved through chains:
+//   `num().min(0).normal(0, 1)`            ✓
+//   `int().min(1).max(5).weighted([...])`  ✓
+// ──────────────────────────────────────────────────────────────────────────
+export class NumberSchema extends Schema {
+    min(n) {
+        return this.cloneWithNode({ ...this._node, min: n });
+    }
+    max(n) {
+        return this.cloneWithNode({ ...this._node, max: n });
+    }
+    cloneWithNode(node) {
+        const next = Object.create(Object.getPrototypeOf(this));
+        Object.assign(next, this, { _node: node });
+        return next;
+    }
+}
+/** `int()`-flavoured number — discrete, no Gaussian. Extends `NumberSchema`. */
+export class IntSchema extends NumberSchema {
+}
+export const num = () => new NumberSchema({ kind: 'number', int: false });
+export const int = () => new IntSchema({ kind: 'number', int: true });
+// ──────────────────────────────────────────────────────────────────────────
+// boolean / null
+// ──────────────────────────────────────────────────────────────────────────
+export class BooleanSchema extends Schema {
+}
+export class NullSchema extends Schema {
+}
+export const bool = () => new BooleanSchema({ kind: 'boolean' });
+export const null_ = () => new NullSchema({ kind: 'null' });
+//# sourceMappingURL=primitives.js.map

package/dist/schema/primitives.js.map

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

package/dist/standard/behaviors.d.ts

@@ -0,0 +1,6 @@
+import type { BehaviorDescriptor } from '../runtime/contracts.js';
+/** Preserve JSON data and reject every closure, cycle and lossy JSON value. */
+export declare const jsonData: (value: unknown, path?: readonly (string | number)[], seen?: Set<object>) => unknown;
+/** Standard behavior descriptors; order preserves eventually before occasionally. */
+export declare const standardBehaviors: readonly BehaviorDescriptor[];
+//# sourceMappingURL=behaviors.d.ts.map

package/dist/standard/behaviors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"behaviors.d.ts","sourceRoot":"","sources":["../../src/standard/behaviors.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,kBAAkB,EAInB,MAAM,yBAAyB,CAAA;AA0BhC,+EAA+E;AAC/E,eAAO,MAAM,QAAQ,GACnB,OAAO,OAAO,EACd,OAAM,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAO,EACvC,kBAAwB,KACvB,OAuBF,CAAA;AA0UD,qFAAqF;AACrF,eAAO,MAAM,iBAAiB,EAAE,SAAS,kBAAkB,EAQzD,CAAA"}