@zmdb/validator 1.0.0-beta.1

package/README.md

@@ -0,0 +1,35 @@
+# @zmdb/validator
+
+`@zmdb/validator` is zmdb's compiler-free validation and serialization runtime. Generated application code calls this package's errors and helpers; it does not load TypeScript, filesystem tooling,
+build plugins, Metro, or lint hosts.
+
+Part of **[zmdb](https://github.com/ambasta/zmdb)**. The TypeScript front end, reflection, emitters, project compilation, and host adapters live in `@zmdb/compiler`.
+
+## Install
+
+```bash
+yarn add @zmdb/validator@1.0.0-beta.1
+```
+
+> **Prerelease** (`1.0.0-beta.1`). Requires **Node.js 26+** and is **ESM-only**.
+
+## Entry points
+
+- `@zmdb/validator`
+- `@zmdb/validator/advanced`
+- `@zmdb/validator/errors`
+- `@zmdb/validator/serialization`
+
+For build-time reflection and AOT compilation:
+
+```bash
+yarn add --dev @zmdb/compiler@1.0.0-beta.1 typescript@^7
+```
+
+## Documentation
+
+Full docs: **https://ambasta.github.io/zmdb/**
+
+## License
+
+GNU General Public License v3.0 or later (GPL-3.0-or-later) — see [LICENSE](./LICENSE).

package/dist/advanced/index.d.ts

@@ -0,0 +1,53 @@
+import { type Rule, type ValidationIssue } from '../index.js';
+export type { ValidationIssue };
+declare const __brand: unique symbol;
+export type Brand<Base, Tag extends string> = Base & {
+    readonly [__brand]: Tag;
+};
+export type RefinePredicate = (v: unknown) => boolean;
+export type TransformFn = (v: unknown) => unknown;
+/**
+ * A refinement rule: a real predicate plus its intrinsic source text for inspection.
+ *
+ * The predicate is passed in as a *function value*, not a source string that we
+ * compile or interpret at import time. A string form creates a second executable
+ * language whose property and call reachability must be secured; a function is
+ * instead typechecked at the call site. `source` records the function's intrinsic
+ * text for inspection; the current emitter does not consume advanced-rule source
+ * (PRD §9.5).
+ */
+export interface RefineRule extends Rule {
+    readonly kind: 'refine';
+    readonly source: string;
+    readonly message: string;
+    readonly predicate: RefinePredicate;
+}
+/** A post-validation conversion. Same function-not-source rule as {@link RefineRule}. */
+export interface TransformRule extends Rule {
+    readonly kind: 'transform';
+    readonly source: string;
+    readonly apply: TransformFn;
+}
+export interface UnionRule extends Rule {
+    readonly kind: 'union';
+    readonly branches: readonly Rule[];
+}
+export interface DiscriminatedRule extends Rule {
+    readonly kind: 'discriminated';
+    readonly key: string;
+    readonly map: Record<string, Rule>;
+}
+export declare function refine(predicate: RefinePredicate, message: string): RefineRule;
+export declare function transform(apply: TransformFn): TransformRule;
+export declare function union(...rules: readonly Rule[]): UnionRule;
+export declare function discriminated(key: string, map: Record<string, Rule>): DiscriminatedRule;
+export declare function evalRule(rule: Rule, value: unknown): boolean;
+export declare const coerce: {
+    readonly number: (expr: unknown) => number;
+};
+export type ObjectMode = 'strict' | 'strip' | 'passthrough';
+export declare function validateObject(value: unknown, rules: Record<string, Rule>, mode: ObjectMode): {
+    success: boolean;
+    issues: readonly ValidationIssue[];
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/advanced/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/advanced/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9D,YAAY,EAAE,eAAe,EAAE,CAAC;AAKhC,OAAO,CAAC,MAAM,OAAO,EAAE,OAAO,MAAM,CAAC;AACrC,MAAM,MAAM,KAAK,CAAC,IAAI,EAAE,GAAG,SAAS,MAAM,IAAI,IAAI,GAAG;IAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC;AAOjF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;AAElD;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAW,SAAQ,IAAI;IACtC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC;CACrC;AACD,yFAAyF;AACzF,MAAM,WAAW,aAAc,SAAQ,IAAI;IACzC,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;CAC7B;AACD,MAAM,WAAW,SAAU,SAAQ,IAAI;IACrC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,SAAS,IAAI,EAAE,CAAC;CACpC;AACD,MAAM,WAAW,iBAAkB,SAAQ,IAAI;IAC7C,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;CACpC;AAED,wBAAgB,MAAM,CAAC,SAAS,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,CAY9E;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,CAW3D;AAED,wBAAgB,KAAK,CAAC,GAAG,KAAK,EAAE,SAAS,IAAI,EAAE,GAAG,SAAS,CAE1D;AAED,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,iBAAiB,CAOvF;AAgBD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAW5D;AAED,eAAO,MAAM,MAAM;aACjB,MAAM,SAAO,OAAO,KAAG,MAAM;CAKrB,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,aAAa,CAAC;AA2B5D,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,EAC3B,IAAI,EAAE,UAAU,GACf;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAA;CAAE,CA0B1D"}

package/dist/advanced/index.js

@@ -0,0 +1,132 @@
+// Advanced validation — implementation.
+// #46 refinement compilation (refine + refinement-aware validateObject with
+// exact error paths). Coercion + object strictness (#49) are co-implemented
+// because the same validateObject drives them. #47 transform remains a rule
+// constructor only; no validator path applies it.
+import {} from '../index.js';
+/** True for a non-null, non-array object — proves a keyed read is safe. */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function refine(predicate, message) {
+    if (typeof predicate !== 'function') {
+        throw new TypeError('refine() requires a function value; source strings are not supported');
+    }
+    const source = Function.prototype.toString.call(predicate);
+    return Object.freeze({
+        kind: 'refine',
+        args: Object.freeze([source, message]),
+        source,
+        message,
+        predicate,
+    });
+}
+export function transform(apply) {
+    if (typeof apply !== 'function') {
+        throw new TypeError('transform() requires a function value; source strings are not supported');
+    }
+    const source = Function.prototype.toString.call(apply);
+    return Object.freeze({
+        kind: 'transform',
+        args: Object.freeze([source]),
+        source,
+        apply,
+    });
+}
+export function union(...rules) {
+    return Object.freeze({ kind: 'union', args: Object.freeze(rules), branches: rules });
+}
+export function discriminated(key, map) {
+    return Object.freeze({
+        kind: 'discriminated',
+        args: Object.freeze([key]),
+        key,
+        map,
+    });
+}
+// `Rule` is an open interface (any package may add a kind), so `rule.kind === x`
+// cannot narrow it the way a closed union would. These guards check the tag *and*
+// the payload it implies, which is what makes the narrowing sound without a cast.
+function isRefine(rule) {
+    return rule.kind === 'refine' && 'predicate' in rule && typeof rule.predicate === 'function';
+}
+function isUnion(rule) {
+    return rule.kind === 'union' && 'branches' in rule && Array.isArray(rule.branches);
+}
+function isDiscriminated(rule) {
+    return rule.kind === 'discriminated' && 'key' in rule && typeof rule.key === 'string' && 'map' in rule;
+}
+// Runtime evaluator for the rule-value API. The type-first emitter is a separate path.
+export function evalRule(rule, value) {
+    if (isUnion(rule))
+        return rule.branches.some(b => evalRule(b, value));
+    if (isDiscriminated(rule)) {
+        if (!isRecord(value))
+            return false;
+        const disc = value[rule.key];
+        if (typeof disc !== 'string')
+            return false;
+        const branch = rule.map[disc];
+        if (!branch)
+            return false;
+        return evalRule(branch, value.value);
+    }
+    return checkRule(rule, value).ok;
+}
+export const coerce = {
+    number(expr) {
+        const n = Number(expr);
+        if (Number.isNaN(n))
+            throw new TypeError(`cannot coerce to number: ${String(expr)}`);
+        return n;
+    },
+};
+function checkRule(rule, value) {
+    // Refinement rule.
+    if (isRefine(rule)) {
+        return { ok: rule.predicate(value), expected: rule.source, message: rule.message };
+    }
+    // Primitive tag rules (mirror the aot-validator runtime fallback).
+    const [arg] = rule.args;
+    switch (rule.kind) {
+        case 'Min':
+            return {
+                ok: typeof value === 'number' && typeof arg === 'number' && value >= arg,
+                expected: `number >= ${String(arg)}`,
+                message: `must be >= ${String(arg)}`,
+            };
+        case 'MaxLength':
+            return {
+                ok: typeof value === 'string' && typeof arg === 'number' && value.length <= arg,
+                expected: `string length <= ${String(arg)}`,
+                message: `length must be <= ${String(arg)}`,
+            };
+        default:
+            return { ok: true, expected: rule.kind, message: '' };
+    }
+}
+export function validateObject(value, rules, mode) {
+    const issues = [];
+    const obj = isRecord(value) ? value : {};
+    // Excess-key handling for strict mode.
+    if (mode === 'strict') {
+        for (const key of Object.keys(obj)) {
+            if (!(key in rules)) {
+                issues.push({
+                    path: `input.${key}`,
+                    expected: 'no excess property',
+                    value: obj[key],
+                    message: `unexpected property "${key}"`,
+                });
+            }
+        }
+    }
+    for (const [key, rule] of Object.entries(rules)) {
+        const res = checkRule(rule, obj[key]);
+        if (!res.ok) {
+            issues.push({ path: `input.${key}`, expected: res.expected, value: obj[key], message: res.message });
+        }
+    }
+    return { success: issues.length === 0, issues };
+}
+//# sourceMappingURL=index.js.map

package/dist/advanced/index.js.map

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

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+import { type ValidationIssue } from './index.js';
+export declare class AssertError extends Error {
+    readonly issues: readonly ValidationIssue[];
+    constructor(message: string, issues?: readonly ValidationIssue[]);
+}
+/** Throw an `AssertError` carrying `issues`; the first issue supplies the message. */
+export declare function failWith(issues: readonly ValidationIssue[]): never;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,CAAC;IAE5C,YAAY,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,SAAS,eAAe,EAAO,EAInE;CACF;AAED,sFAAsF;AACtF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,eAAe,EAAE,GAAG,KAAK,CAGlE"}

package/dist/errors.js

@@ -0,0 +1,24 @@
+// The one thing emitted code imports at runtime.
+//
+// `assert<T>(x)` has to throw something, and the interesting question is *what*. A
+// hoisted class in the emitted prelude would make `err instanceof AssertError` false in
+// a built bundle and true in dev — the exact class of bug the AOT path exists to avoid,
+// since the two paths are supposed to be indistinguishable (REQ-AV-4).
+//
+// So the emitted prelude imports this module, and it is kept in its own file precisely
+// so that import costs a few lines rather than the whole runtime walker.
+import {} from './index.js';
+export class AssertError extends Error {
+    issues;
+    constructor(message, issues = []) {
+        super(message);
+        this.name = 'AssertError';
+        this.issues = issues;
+    }
+}
+/** Throw an `AssertError` carrying `issues`; the first issue supplies the message. */
+export function failWith(issues) {
+    const first = issues[0];
+    throw new AssertError(first ? first.message : 'validation failed', issues);
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,iDAAiD;AACjD,EAAE;AACF,mFAAmF;AACnF,wFAAwF;AACxF,wFAAwF;AACxF,uEAAuE;AACvE,EAAE;AACF,uFAAuF;AACvF,yEAAyE;AAEzE,OAAO,EAAwB,MAAM,YAAY,CAAC;AAElD,MAAM,OAAO,WAAY,SAAQ,KAAK;IAC3B,MAAM,CAA6B;IAE5C,YAAY,OAAe,EAAE,MAAM,GAA+B,EAAE;QAClE,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,aAAa,CAAC;QAC1B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CACF;AAED,sFAAsF;AACtF,MAAM,UAAU,QAAQ,CAAC,MAAkC;IACzD,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACxB,MAAM,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;AAC7E,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+export { AssertError, failWith } from './errors.js';
+export { getCachedRegExp, MAX_REGEX_CACHE_SIZE, validatePatternComplexity } from './regex-complexity.js';
+export interface Rule {
+    readonly kind: string;
+    readonly args: readonly unknown[];
+}
+export declare const tags: {
+    readonly Min: (n: number) => Rule;
+    readonly Max: (n: number) => Rule;
+    readonly MinLength: (n: number) => Rule;
+    readonly MaxLength: (n: number) => Rule;
+    readonly Pattern: (re: string) => Rule;
+    readonly Enum: (...values: readonly string[]) => Rule;
+};
+export declare function getRegExp(pattern: string): RegExp;
+export declare function getEnumSet(values: readonly unknown[]): Set<unknown>;
+export declare function validateRule(r: Rule, expr: unknown): boolean;
+export { ValidationError, claimsValidationIssues, validationIssuesOf } from './validation-error.js';
+export type { ValidationIssue } from './validation-error.js';
+export * from './utilities/index.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":"AASA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;AAEzG,MAAM,WAAW,IAAI;IACnB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,OAAO,EAAE,CAAC;CACnC;AAYD,eAAO,MAAM,IAAI;aACf,GAAG,MAAI,MAAM,KAAG,IAAI;aAGpB,GAAG,MAAI,MAAM,KAAG,IAAI;aAGpB,SAAS,MAAI,MAAM,KAAG,IAAI;aAG1B,SAAS,MAAI,MAAM,KAAG,IAAI;aAG1B,OAAO,OAAK,MAAM,KAAG,IAAI;aAIzB,IAAI,cAAY,SAAS,MAAM,EAAE,KAAG,IAAI;CAGhC,CAAC;AAIX,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAgBjD;AAGD,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,CAAC,CAOnE;AAID,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CA6B5D;AAED,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACpG,YAAY,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,102 @@
+// @zmdb/validator — the runtime half.
+//
+// Nothing reachable from this entry point may import `typescript`. The compiler is a
+// build-time dependency, and an application that imports `tags` to declare a
+// constraint must not pull it into a runtime bundle. Compiler ownership lives in
+// `@zmdb/compiler`; `.github/scripts/verify-exports.mjs` enforces the split.
+import { getCachedRegExp, MAX_REGEX_CACHE_SIZE, validatePatternComplexity } from './regex-complexity.js';
+export { AssertError, failWith } from './errors.js';
+export { getCachedRegExp, MAX_REGEX_CACHE_SIZE, validatePatternComplexity } from './regex-complexity.js';
+function rule(kind, ...args) {
+    return Object.freeze({ kind, args: Object.freeze(args) });
+}
+// One spelling per constraint, and it is the tag's. `Min`/`Max` used to be `Minimum`/
+// `Maximum` here while the type-level tag has always been `Min<N>`/`Max<N>`, which left
+// `ir/index.ts` folding case *and* mapping two names onto one kind. Now that a constraint
+// is declared as `number & Min<18>`, the `tags.Min(18)` call has no declaration role
+// left — the `Rule` object is the AOT's pre-transform fallback representation — so the
+// name that stays is the one you write in a type.
+export const tags = {
+    Min(n) {
+        return rule('Min', n);
+    },
+    Max(n) {
+        return rule('Max', n);
+    },
+    MinLength(n) {
+        return rule('MinLength', n);
+    },
+    MaxLength(n) {
+        return rule('MaxLength', n);
+    },
+    Pattern(re) {
+        validatePatternComplexity(re);
+        return rule('Pattern', re);
+    },
+    Enum(...values) {
+        return rule('Enum', ...values);
+    },
+};
+// Caches for zero-allocation fallback validation.
+const regexCache = new Map();
+export function getRegExp(pattern) {
+    let re = regexCache.get(pattern);
+    if (re) {
+        regexCache.delete(pattern);
+        regexCache.set(pattern, re);
+        return re;
+    }
+    if (regexCache.size >= MAX_REGEX_CACHE_SIZE) {
+        const oldestKey = regexCache.keys().next().value;
+        if (oldestKey !== undefined) {
+            regexCache.delete(oldestKey);
+        }
+    }
+    re = new RegExp(pattern);
+    regexCache.set(pattern, re);
+    return re;
+}
+const enumSetCache = new WeakMap();
+export function getEnumSet(values) {
+    let set = enumSetCache.get(values);
+    if (!set) {
+        set = new Set(values);
+        enumSetCache.set(values, set);
+    }
+    return set;
+}
+// Runtime-safety fallback: identical boolean semantics to the inlined form.
+// This is what executes pre-transform (dev / ts-node).
+export function validateRule(r, expr) {
+    // `args` is `readonly unknown[]` (any package may define a kind), so the bound
+    // is re-checked rather than asserted: `typeof arg === 'number'` costs nothing a
+    // JIT can't fold, and this is the fallback path — the AOT emission is what the
+    // benchmarks measure.
+    const [arg] = r.args;
+    switch (r.kind) {
+        case 'Min':
+            return typeof expr === 'number' && typeof arg === 'number' && expr >= arg;
+        case 'Max':
+            return typeof expr === 'number' && typeof arg === 'number' && expr <= arg;
+        case 'MinLength':
+            return typeof expr === 'string' && typeof arg === 'number' && expr.length >= arg;
+        case 'MaxLength':
+            return typeof expr === 'string' && typeof arg === 'number' && expr.length <= arg;
+        case 'Pattern':
+            // No input-length cap. There used to be one — 10 000 characters, and a throw past it
+            // — but the inlined form is `/pat/.test(x)` with no such limit, so the same call
+            // answered `false` in a build and threw in dev. REQ-AV-4 does not allow that, and of
+            // the two behaviours the cap is the one with no counterpart to move it to.
+            // Re-checked, not asserted, for the reason above: an unchecked `args[0]` would have
+            // reached `new RegExp` and been coerced, so `Pattern` with a number in it compiled a
+            // pattern rather than answering `false` like every other rule with a bad argument.
+            return typeof expr === 'string' && typeof arg === 'string' && getCachedRegExp(arg).test(expr);
+        case 'Enum':
+            return getEnumSet(r.args).has(expr);
+        default:
+            throw new Error(`unknown rule kind: ${r.kind}`);
+    }
+}
+export { ValidationError, claimsValidationIssues, validationIssuesOf } from './validation-error.js';
+export * from './utilities/index.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":"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"}

package/dist/regex-complexity.d.ts

@@ -0,0 +1,6 @@
+import { ValidationError } from './index.js';
+export { ValidationError };
+export declare function validatePatternComplexity(pattern: string): void;
+export declare const MAX_REGEX_CACHE_SIZE = 1000;
+export declare function getCachedRegExp(pattern: string): RegExp;
+//# sourceMappingURL=regex-complexity.d.ts.map

package/dist/regex-complexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex-complexity.d.ts","sourceRoot":"","sources":["../src/regex-complexity.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAO/D;AAED,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAGzC,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAiBvD"}

package/dist/regex-complexity.js

@@ -0,0 +1,42 @@
+// Regular expression syntax validation and a bounded compiled-RegExp cache.
+//
+// This validates syntax only; there is no static ReDoS analysis here, and the name is a
+// leftover from when there was meant to be.
+//
+// There used to also be a `safeTestPattern` that refused inputs over 10 000 characters. It
+// is gone, because the emitted form of the same check is `/pat/.test(x)` and has no such
+// limit: keeping it meant one call site answering `false` after a build and throwing before
+// one, which is precisely the divergence REQ-AV-4 exists to rule out. A cap that only one
+// of the two paths can honour is not a safety feature.
+import { ValidationError } from './index.js';
+export { ValidationError };
+export function validatePatternComplexity(pattern) {
+    try {
+        RegExp(pattern);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new ValidationError(`Invalid regular expression pattern: ${msg}`);
+    }
+}
+export const MAX_REGEX_CACHE_SIZE = 1000;
+const patternCache = new Map();
+export function getCachedRegExp(pattern) {
+    let re = patternCache.get(pattern);
+    if (re) {
+        patternCache.delete(pattern);
+        patternCache.set(pattern, re);
+        return re;
+    }
+    validatePatternComplexity(pattern);
+    if (patternCache.size >= MAX_REGEX_CACHE_SIZE) {
+        const oldestKey = patternCache.keys().next().value;
+        if (oldestKey !== undefined) {
+            patternCache.delete(oldestKey);
+        }
+    }
+    re = new RegExp(pattern);
+    patternCache.set(pattern, re);
+    return re;
+}
+//# sourceMappingURL=regex-complexity.js.map

package/dist/regex-complexity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex-complexity.js","sourceRoot":"","sources":["../src/regex-complexity.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,EAAE;AACF,wFAAwF;AACxF,4CAA4C;AAC5C,EAAE;AACF,2FAA2F;AAC3F,yFAAyF;AACzF,4FAA4F;AAC5F,0FAA0F;AAC1F,uDAAuD;AAEvD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,OAAO,EAAE,eAAe,EAAE,CAAC;AAE3B,MAAM,UAAU,yBAAyB,CAAC,OAAe;IACvD,IAAI,CAAC;QACH,MAAM,CAAC,OAAO,CAAC,CAAC;IAClB,CAAC;IAAC,OAAO,GAAY,EAAE,CAAC;QACtB,MAAM,GAAG,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC7D,MAAM,IAAI,eAAe,CAAC,uCAAuC,GAAG,EAAE,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CAAC;AACzC,MAAM,YAAY,GAAG,IAAI,GAAG,EAAkB,CAAC;AAE/C,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,IAAI,EAAE,GAAG,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,EAAE,EAAE,CAAC;QACP,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC7B,YAAY,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAC9B,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,yBAAyB,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,YAAY,CAAC,IAAI,IAAI,oBAAoB,EAAE,CAAC;QAC9C,MAAM,SAAS,GAAG,YAAY,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;QACnD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IACD,EAAE,GAAG,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC;IACzB,YAAY,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;IAC9B,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/dist/serialization/index.d.ts

@@ -0,0 +1,20 @@
+import { type ValidationIssue } from '../advanced/index.js';
+import { type TypeIR } from '../index.js';
+export declare function stringify(value: unknown): string;
+export declare function assertStringify(value: unknown, schema?: TypeIR): string;
+export interface ParseResult<T> {
+    readonly success: boolean;
+    readonly data?: T;
+    readonly issues?: readonly ValidationIssue[];
+}
+/**
+ * Parse JSON without rebuilding the object graph. Reports malformed input as
+ * structured issues instead of throwing.
+ *
+ * `T` is an *unvalidated* claim about the payload — exactly as much as
+ * `JSON.parse` gives you, and no more. Use {@link decode} when you need the
+ * claim checked against a schema.
+ */
+export declare function parse<T = unknown>(text: string): ParseResult<T>;
+export declare function decode<T = unknown>(text: string, schema?: TypeIR): ParseResult<T>;
+//# sourceMappingURL=index.d.ts.map

package/dist/serialization/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serialization/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAuB,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAI/D,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAKhD;AAID,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvE;AAED,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;CAC9C;AAED;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAmB/D;AAKD,wBAAgB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,CAUjF"}

package/dist/serialization/index.js

@@ -0,0 +1,64 @@
+// JSON serialization and validated parsing.
+import {} from '../advanced/index.js';
+import { assert, AssertError } from '../index.js';
+// Native JSON owns property traversal and toJSON calls. Primitive bigint is
+// rejected before a root toJSON hook can run; native JSON rejects nested bigint.
+export function stringify(value) {
+    if (typeof value === 'bigint') {
+        throw new TypeError('Do not know how to serialize a BigInt');
+    }
+    return JSON.stringify(value);
+}
+// `TypeIR`: the witness a user has is the generated one, and there is no longer a
+// hand-written form of it to accept (REQ-TF-9).
+export function assertStringify(value, schema) {
+    // Validate first (throws AssertError on failure), then serialize.
+    assert(value, schema);
+    return stringify(value);
+}
+/**
+ * Parse JSON without rebuilding the object graph. Reports malformed input as
+ * structured issues instead of throwing.
+ *
+ * `T` is an *unvalidated* claim about the payload — exactly as much as
+ * `JSON.parse` gives you, and no more. Use {@link decode} when you need the
+ * claim checked against a schema.
+ */
+export function parse(text) {
+    try {
+        // boundary: JSON.parse is `any` by definition; the caller's `T` is asserted,
+        // not proven. `decode` is the proving variant.
+        const data = JSON.parse(text);
+        return { success: true, data };
+    }
+    catch (err) {
+        return {
+            success: false,
+            issues: [
+                {
+                    path: 'input',
+                    expected: 'valid JSON',
+                    value: text,
+                    message: err instanceof Error ? err.message : 'invalid JSON',
+                },
+            ],
+        };
+    }
+}
+// #54 — typed parse/decode: parse JSON then validate into T against a schema.
+// Malformed JSON or a validation failure yields success:false with structured
+// issues (exact paths).
+export function decode(text, schema) {
+    const parsed = parse(text);
+    if (!parsed.success)
+        return parsed;
+    try {
+        const data = assert(parsed.data, schema);
+        return { success: true, data };
+    }
+    catch (err) {
+        const issues = err instanceof AssertError ? err.issues : [];
+        return { success: false, issues };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/serialization/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/serialization/index.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,OAAO,EAAwB,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,WAAW,EAAe,MAAM,aAAa,CAAC;AAE/D,4EAA4E;AAC5E,iFAAiF;AACjF,MAAM,UAAU,SAAS,CAAC,KAAc;IACtC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,MAAM,IAAI,SAAS,CAAC,uCAAuC,CAAC,CAAC;IAC/D,CAAC;IACD,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED,kFAAkF;AAClF,gDAAgD;AAChD,MAAM,UAAU,eAAe,CAAC,KAAc,EAAE,MAAe;IAC7D,kEAAkE;IAClE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IACtB,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC;AAC1B,CAAC;AAQD;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CAAc,IAAY;IAC7C,IAAI,CAAC;QACH,6EAA6E;QAC7E,+CAA+C;QAC/C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAM,CAAC;QACnC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACjC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO;YACL,OAAO,EAAE,KAAK;YACd,MAAM,EAAE;gBACN;oBACE,IAAI,EAAE,OAAO;oBACb,QAAQ,EAAE,YAAY;oBACtB,KAAK,EAAE,IAAI;oBACX,OAAO,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,cAAc;iBAC7D;aACF;SACF,CAAC;IACJ,CAAC;AACH,CAAC;AAED,8EAA8E;AAC9E,8EAA8E;AAC9E,wBAAwB;AACxB,MAAM,UAAU,MAAM,CAAc,IAAY,EAAE,MAAe;IAC/D,MAAM,MAAM,GAAG,KAAK,CAAI,IAAI,CAAC,CAAC;IAC9B,IAAI,CAAC,MAAM,CAAC,OAAO;QAAE,OAAO,MAAM,CAAC;IACnC,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,CAAI,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC5C,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACjC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,MAAM,GAAG,GAAG,YAAY,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5D,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IACpC,CAAC;AACH,CAAC"}

package/dist/utilities/index.d.ts

@@ -0,0 +1,29 @@
+import { type TypeIR } from '@zmdb/schema/ir';
+import { type ValidationIssue } from '../index.js';
+export { AssertError, failWith } from '../errors.js';
+export interface ValidateResult<T> {
+    readonly success: boolean;
+    readonly data?: T;
+    readonly errors?: readonly ValidationIssue[];
+}
+export declare function is<T = unknown>(input: unknown, schema?: TypeIR): input is T;
+export declare function assert<T = unknown>(input: unknown, schema?: TypeIR): T;
+export declare function validate<T = unknown>(input: unknown, schema?: TypeIR): ValidateResult<T>;
+/**
+ * Validate only through depth `D`; an ordinary call is replaced at build time.
+ *
+ * The optional witness and runtime depth exist for tests and generated fallback
+ * modules. A real untransformed call has neither and throws `MISSING`, exactly as
+ * the full-depth utility family does.
+ */
+export declare function isShallow<T = unknown, D extends number = 1>(input: unknown, schema?: TypeIR, depth?: D): input is T;
+export declare function assertShallow<T = unknown, D extends number = 1>(input: unknown, schema?: TypeIR, depth?: D): T;
+export declare function validateShallow<T = unknown, D extends number = 1>(input: unknown, schema?: TypeIR, depth?: D): ValidateResult<T>;
+export declare function equals<T = unknown>(input: unknown, schema?: TypeIR): input is T;
+export declare function assertEquals<T = unknown>(input: unknown, schema?: TypeIR): T;
+export declare function random<T = unknown>(schema?: TypeIR, rng?: () => number): T;
+/** Every issue, for a caller that wants them without a `ValidateResult` wrapper. */
+export declare function issuesFor(input: unknown, schema: TypeIR, path?: string): readonly ValidationIssue[];
+export type { TypeIR };
+export type { ValidationIssue };
+//# sourceMappingURL=index.d.ts.map

package/dist/utilities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utilities/index.ts"],"names":[],"mappings":"AAyBA,OAAO,EAWL,KAAK,MAAM,EAEZ,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAGnD,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAOrD,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAClB,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,eAAe,EAAE,CAAC;CAC9C;AAqkBD,wBAAgB,EAAE,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,IAAI,CAAC,CAG3E;AAED,wBAAgB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,CAAC,CAWtE;AAED,wBAAgB,QAAQ,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,CAOxF;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,SAAS,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,CAAC,CAGnH;AAED,wBAAgB,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,SAAS,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,CAQ9G;AAED,wBAAgB,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,SAAS,MAAM,GAAG,CAAC,EAC/D,KAAK,EAAE,OAAO,EACd,MAAM,CAAC,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,CAAC,GACR,cAAc,CAAC,CAAC,CAAC,CAQnB;AAED,wBAAgB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,IAAI,CAAC,CAI/E;AAED,wBAAgB,YAAY,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,CAAC,CAe5E;AAED,wBAAgB,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,MAAM,GAAG,CAAC,CAW1E;AAED,oFAAoF;AACpF,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,SAAU,GAAG,SAAS,eAAe,EAAE,CAKpG;AAKD,YAAY,EAAE,MAAM,EAAE,CAAC;AACvB,YAAY,EAAE,eAAe,EAAE,CAAC"}