@nekostack/schema 1.0.0

package/dist/src/runtime/compile.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Cached IR → Zod compiler (Decision #7 of v0.6 plan).
+ *
+ * The runtime entry points (`parse` / `safeParse` / `validate`, landing
+ * in later commits) call `compile(node)` to obtain a live `ZodTypeAny`.
+ * Repeated calls with the **same** `SchemaNode` instance return the
+ * **same** compiled Zod value — built once, reused thereafter.
+ *
+ * Cache key is `SchemaNode` *identity*, not IR equality. Two builder
+ * outputs with byte-identical IR but different instance identity are
+ * NOT shared (per Decision #7); explicit dedup via `irHash` (v0.2)
+ * remains a v0.7 registry concern, not a runtime one. The IR is frozen
+ * by the builder, so storing the live Zod schema next to its key is
+ * safe — the IR cannot mutate out from under the cached value.
+ *
+ * Compile is lazy on first call (Decision #9). Schemas that are
+ * defined-but-never-validated never build their Zod schema.
+ *
+ * The `WeakMap` lets the entire `(node, compiled)` pair be GC'd when
+ * the consumer drops its reference to the schema. Long-running
+ * processes that build per-request schemas (anti-pattern, but possible)
+ * therefore don't leak.
+ *
+ * Concurrency: Node is single-threaded, so first-call wins by default
+ * and there is no race. A future worker-threads consumer that shares a
+ * `SchemaNode` across threads would get a per-thread cache; that
+ * trade-off is documented in `docs/RUNTIME.md` (step 9). No v0.6
+ * mitigation.
+ */
+import type { ZodTypeAny } from "zod";
+import type { SchemaNode } from "../ir/nodes.js";
+/**
+ * Return the compiled Zod schema for `node`, building (and caching)
+ * it on the first call. Subsequent calls with the same `SchemaNode`
+ * instance return the same `ZodTypeAny` reference.
+ */
+export declare function compile(node: SchemaNode): ZodTypeAny;
+//# sourceMappingURL=compile.d.ts.map

package/dist/src/runtime/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../../src/runtime/compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAKjD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAMpD"}

package/dist/src/runtime/compile.js

@@ -0,0 +1,45 @@
+/**
+ * Cached IR → Zod compiler (Decision #7 of v0.6 plan).
+ *
+ * The runtime entry points (`parse` / `safeParse` / `validate`, landing
+ * in later commits) call `compile(node)` to obtain a live `ZodTypeAny`.
+ * Repeated calls with the **same** `SchemaNode` instance return the
+ * **same** compiled Zod value — built once, reused thereafter.
+ *
+ * Cache key is `SchemaNode` *identity*, not IR equality. Two builder
+ * outputs with byte-identical IR but different instance identity are
+ * NOT shared (per Decision #7); explicit dedup via `irHash` (v0.2)
+ * remains a v0.7 registry concern, not a runtime one. The IR is frozen
+ * by the builder, so storing the live Zod schema next to its key is
+ * safe — the IR cannot mutate out from under the cached value.
+ *
+ * Compile is lazy on first call (Decision #9). Schemas that are
+ * defined-but-never-validated never build their Zod schema.
+ *
+ * The `WeakMap` lets the entire `(node, compiled)` pair be GC'd when
+ * the consumer drops its reference to the schema. Long-running
+ * processes that build per-request schemas (anti-pattern, but possible)
+ * therefore don't leak.
+ *
+ * Concurrency: Node is single-threaded, so first-call wins by default
+ * and there is no race. A future worker-threads consumer that shares a
+ * `SchemaNode` across threads would get a per-thread cache; that
+ * trade-off is documented in `docs/RUNTIME.md` (step 9). No v0.6
+ * mitigation.
+ */
+import { compileZodSchema } from "./zod-compile.js";
+const cache = new WeakMap();
+/**
+ * Return the compiled Zod schema for `node`, building (and caching)
+ * it on the first call. Subsequent calls with the same `SchemaNode`
+ * instance return the same `ZodTypeAny` reference.
+ */
+export function compile(node) {
+    const cached = cache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const built = compileZodSchema(node);
+    cache.set(node, built);
+    return built;
+}
+//# sourceMappingURL=compile.js.map

package/dist/src/runtime/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","sourceRoot":"","sources":["../../../src/runtime/compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,KAAK,GAAG,IAAI,OAAO,EAA0B,CAAC;AAEpD;;;;GAIG;AACH,MAAM,UAAU,OAAO,CAAC,IAAgB;IACtC,MAAM,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,MAAM,KAAK,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACrC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACvB,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/src/runtime/errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `ParseError` — thrown by `parse(schema, input)` when validation
+ * fails. Carries the full normalized `Issue` list so handlers can
+ * `catch (e) { if (e instanceof ParseError) ... }` and inspect every
+ * issue without re-running the parse.
+ *
+ * `safeParse` and `validate` do NOT throw this — they return a
+ * `Result<...>`. The throw exists for the parse path because that's
+ * the friction-causing default: code that doesn't explicitly want to
+ * handle issues should get loud failure, not silent `undefined`.
+ *
+ * The `code` field is stable for switching (`"parse_failed"`); tests
+ * assert on `code` / `name` / `issues` / `instanceof`, never on the
+ * human-readable `message`.
+ *
+ * Internal-only at this step. The `parse` entry point lands in step 6;
+ * the public `src/index.ts` re-export of `ParseError` lands in step 13.
+ */
+import type { Issue } from "../errors/issue.js";
+export declare class ParseError extends Error {
+    readonly code: "parse_failed";
+    readonly issues: readonly Issue[];
+    constructor(issues: readonly Issue[], message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/runtime/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/runtime/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,qBAAa,UAAW,SAAQ,KAAK;IACnC,QAAQ,CAAC,IAAI,EAAG,cAAc,CAAU;IACxC,QAAQ,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,CAAC;gBAEtB,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM;CASvD"}

package/dist/src/runtime/errors.js

@@ -0,0 +1,43 @@
+/**
+ * `ParseError` — thrown by `parse(schema, input)` when validation
+ * fails. Carries the full normalized `Issue` list so handlers can
+ * `catch (e) { if (e instanceof ParseError) ... }` and inspect every
+ * issue without re-running the parse.
+ *
+ * `safeParse` and `validate` do NOT throw this — they return a
+ * `Result<...>`. The throw exists for the parse path because that's
+ * the friction-causing default: code that doesn't explicitly want to
+ * handle issues should get loud failure, not silent `undefined`.
+ *
+ * The `code` field is stable for switching (`"parse_failed"`); tests
+ * assert on `code` / `name` / `issues` / `instanceof`, never on the
+ * human-readable `message`.
+ *
+ * Internal-only at this step. The `parse` entry point lands in step 6;
+ * the public `src/index.ts` re-export of `ParseError` lands in step 13.
+ */
+export class ParseError extends Error {
+    code = "parse_failed";
+    issues;
+    constructor(issues, message) {
+        super(message ?? defaultMessage(issues));
+        this.name = "ParseError";
+        // Defensive copy — callers may mutate the array they passed in
+        // (rare, but a `safeParse` implementation that batches issues in
+        // a working array would otherwise leak that mutability into the
+        // thrown error). Storing a frozen copy keeps the contract crisp.
+        this.issues = Object.freeze(issues.slice());
+    }
+}
+function defaultMessage(issues) {
+    // Stable enough for humans without being something tests assert on.
+    // The leading count gives a quick signal in logs; the first path /
+    // code pair points the reader at the most relevant issue.
+    const head = issues[0];
+    if (head === undefined)
+        return "Parse failed (no issues)";
+    const where = head.path.length > 0 ? head.path.join(".") : "<root>";
+    const extra = issues.length > 1 ? ` (+${issues.length - 1} more)` : "";
+    return `Parse failed: ${head.code} at ${where}${extra}`;
+}
+//# sourceMappingURL=errors.js.map

package/dist/src/runtime/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/runtime/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,MAAM,OAAO,UAAW,SAAQ,KAAK;IAC1B,IAAI,GAAG,cAAuB,CAAC;IAC/B,MAAM,CAAmB;IAElC,YAAY,MAAwB,EAAE,OAAgB;QACpD,KAAK,CAAC,OAAO,IAAI,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;QACzC,IAAI,CAAC,IAAI,GAAG,YAAY,CAAC;QACzB,+DAA+D;QAC/D,iEAAiE;QACjE,gEAAgE;QAChE,iEAAiE;QACjE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;IAC9C,CAAC;CACF;AAED,SAAS,cAAc,CAAC,MAAwB;IAC9C,oEAAoE;IACpE,mEAAmE;IACnE,0DAA0D;IAC1D,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACvB,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,0BAA0B,CAAC;IAC1D,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;IACpE,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,MAAM,CAAC,MAAM,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;IACvE,OAAO,iBAAiB,IAAI,CAAC,IAAI,OAAO,KAAK,GAAG,KAAK,EAAE,CAAC;AAC1D,CAAC"}

package/dist/src/runtime/normalize-issues.d.ts

@@ -0,0 +1,65 @@
+/**
+ * ZodError → readonly Issue[] normalization (Decision #12 of v0.6 plan).
+ *
+ * This is the contract layer between Zod's internal error vocabulary
+ * and NekoStack's stable, machine-readable `IssueCode` set. Downstream
+ * consumers (form display, API responses, admin diagnostics) read
+ * `Issue` only — they never see a `ZodError`. Per the "engine
+ * swap-safe" invariant added in v0.6: replacing the runtime engine
+ * later must be a no-op for those consumers, so this mapping is the
+ * load-bearing translation.
+ *
+ * **Mapping table (Decision #12, locked).**
+ *
+ *   invalid_type (received: undefined, expected != undefined) → missing_required
+ *   invalid_type (other)                                      → invalid_type
+ *   unrecognized_keys                                         → one unknown_key per key
+ *   invalid_literal                                           → invalid_literal
+ *   invalid_enum_value                                        → invalid_enum
+ *   invalid_union                                             → invalid_union
+ *   invalid_union_discriminator                               → invalid_union  (folded;
+ *                                                                no v0.6 public surface)
+ *   invalid_arguments / invalid_return_type                   → invalid_type   (function
+ *                                                                schemas not in v0.6
+ *                                                                scope; metadata carries
+ *                                                                the original code)
+ *   too_small                                                 → too_small
+ *   too_big                                                   → too_big
+ *   invalid_string                                            → invalid_format
+ *   invalid_date                                              → invalid_type   (DateNode
+ *                                                                has no v0.6 builder)
+ *   custom                                                    → custom_refinement_failed
+ *   anything not listed                                       → custom_refinement_failed
+ *                                                                (+ metadata.source="zod",
+ *                                                                 metadata.zodCode=<orig>)
+ *
+ * The fallback row exists so adding a new Zod code in a future Zod
+ * release does not crash the normalizer; the original code is
+ * preserved on `metadata.zodCode` for traceability.
+ *
+ * **Preserved verbatim.** `path`, `message`, `expected`, `received`
+ * come straight from Zod (no re-serialization). `schemaId` /
+ * `schemaVersion` come from `schema.metadata` when present.
+ * `severity` is always `"error"` in v0.6.
+ *
+ * Internal-only. Not exported from `src/index.ts` — the public
+ * surface ships `Issue` / `IssueCode` / `Result` (already in v0.1).
+ */
+import type { ZodError } from "zod";
+import type { SchemaNode } from "../ir/nodes.js";
+import type { Issue } from "../errors/issue.js";
+/**
+ * Normalize a `ZodError` into the NekoStack issue vocabulary.
+ *
+ * `schema` is the top-level `SchemaNode` whose validation produced
+ * the error. Its `metadata.id` / `metadata.version` (when present)
+ * are stamped on every emitted issue so consumers can route by
+ * schema without re-correlating.
+ *
+ * `unrecognized_keys` is expanded into one `unknown_key` issue per
+ * offending key — Zod batches the keys on a single issue, but the
+ * NekoStack contract is one issue per key so downstream UIs render
+ * cleanly.
+ */
+export declare function normalizeIssues(error: ZodError, schema: SchemaNode): readonly Issue[];
+//# sourceMappingURL=normalize-issues.d.ts.map

package/dist/src/runtime/normalize-issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-issues.d.ts","sourceRoot":"","sources":["../../../src/runtime/normalize-issues.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,KAAK,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,UAAU,GACjB,SAAS,KAAK,EAAE,CAQlB"}

package/dist/src/runtime/normalize-issues.js

@@ -0,0 +1,208 @@
+/**
+ * ZodError → readonly Issue[] normalization (Decision #12 of v0.6 plan).
+ *
+ * This is the contract layer between Zod's internal error vocabulary
+ * and NekoStack's stable, machine-readable `IssueCode` set. Downstream
+ * consumers (form display, API responses, admin diagnostics) read
+ * `Issue` only — they never see a `ZodError`. Per the "engine
+ * swap-safe" invariant added in v0.6: replacing the runtime engine
+ * later must be a no-op for those consumers, so this mapping is the
+ * load-bearing translation.
+ *
+ * **Mapping table (Decision #12, locked).**
+ *
+ *   invalid_type (received: undefined, expected != undefined) → missing_required
+ *   invalid_type (other)                                      → invalid_type
+ *   unrecognized_keys                                         → one unknown_key per key
+ *   invalid_literal                                           → invalid_literal
+ *   invalid_enum_value                                        → invalid_enum
+ *   invalid_union                                             → invalid_union
+ *   invalid_union_discriminator                               → invalid_union  (folded;
+ *                                                                no v0.6 public surface)
+ *   invalid_arguments / invalid_return_type                   → invalid_type   (function
+ *                                                                schemas not in v0.6
+ *                                                                scope; metadata carries
+ *                                                                the original code)
+ *   too_small                                                 → too_small
+ *   too_big                                                   → too_big
+ *   invalid_string                                            → invalid_format
+ *   invalid_date                                              → invalid_type   (DateNode
+ *                                                                has no v0.6 builder)
+ *   custom                                                    → custom_refinement_failed
+ *   anything not listed                                       → custom_refinement_failed
+ *                                                                (+ metadata.source="zod",
+ *                                                                 metadata.zodCode=<orig>)
+ *
+ * The fallback row exists so adding a new Zod code in a future Zod
+ * release does not crash the normalizer; the original code is
+ * preserved on `metadata.zodCode` for traceability.
+ *
+ * **Preserved verbatim.** `path`, `message`, `expected`, `received`
+ * come straight from Zod (no re-serialization). `schemaId` /
+ * `schemaVersion` come from `schema.metadata` when present.
+ * `severity` is always `"error"` in v0.6.
+ *
+ * Internal-only. Not exported from `src/index.ts` — the public
+ * surface ships `Issue` / `IssueCode` / `Result` (already in v0.1).
+ */
+/**
+ * Normalize a `ZodError` into the NekoStack issue vocabulary.
+ *
+ * `schema` is the top-level `SchemaNode` whose validation produced
+ * the error. Its `metadata.id` / `metadata.version` (when present)
+ * are stamped on every emitted issue so consumers can route by
+ * schema without re-correlating.
+ *
+ * `unrecognized_keys` is expanded into one `unknown_key` issue per
+ * offending key — Zod batches the keys on a single issue, but the
+ * NekoStack contract is one issue per key so downstream UIs render
+ * cleanly.
+ */
+export function normalizeIssues(error, schema) {
+    const schemaId = schema.metadata?.id;
+    const schemaVersion = schema.metadata?.version;
+    const out = [];
+    for (const zi of error.issues) {
+        appendNormalized(out, zi, schemaId, schemaVersion);
+    }
+    return out;
+}
+function appendNormalized(out, zi, schemaId, schemaVersion) {
+    const base = {
+        path: zi.path.slice(),
+        message: zi.message,
+        severity: "error",
+        ...(schemaId !== undefined ? { schemaId } : {}),
+        ...(schemaVersion !== undefined ? { schemaVersion } : {}),
+    };
+    switch (zi.code) {
+        case "invalid_type": {
+            // "field is absent" beats "field has wrong type": Zod reports
+            // a missing object property as invalid_type / received="undefined",
+            // but the consumer-facing distinction is whether the value was
+            // there at all. See Decision #12 first row.
+            const isMissing = zi.received === "undefined" && zi.expected !== "undefined";
+            out.push({
+                ...base,
+                code: isMissing ? "missing_required" : "invalid_type",
+                expected: zi.expected,
+                received: zi.received,
+            });
+            return;
+        }
+        case "invalid_literal": {
+            out.push({
+                ...base,
+                code: "invalid_literal",
+                expected: zi.expected,
+                received: zi.received,
+            });
+            return;
+        }
+        case "unrecognized_keys": {
+            // Zod batches all offending keys on a single issue; the
+            // NekoStack contract emits one issue per key so a UI can
+            // highlight each field independently.
+            for (const key of zi.keys) {
+                out.push({
+                    ...base,
+                    path: [...zi.path, key],
+                    code: "unknown_key",
+                    received: key,
+                });
+            }
+            return;
+        }
+        case "invalid_enum_value": {
+            out.push({
+                ...base,
+                code: "invalid_enum",
+                expected: zi.options,
+                received: zi.received,
+            });
+            return;
+        }
+        case "invalid_union":
+        case "invalid_union_discriminator": {
+            // Folded — v0.6 has no public discriminated-union surface.
+            out.push({ ...base, code: "invalid_union" });
+            return;
+        }
+        case "invalid_arguments":
+        case "invalid_return_type": {
+            // Function schemas are not in v0.6 scope. If Zod somehow emits
+            // these (e.g., a downstream hand-written schema), surface as
+            // invalid_type with the original code on metadata for triage.
+            out.push({
+                ...base,
+                code: "invalid_type",
+                metadata: { source: "zod", zodCode: zi.code },
+            });
+            return;
+        }
+        case "too_small": {
+            out.push({
+                ...base,
+                code: "too_small",
+                metadata: {
+                    minimum: zi.minimum,
+                    inclusive: zi.inclusive,
+                    ...(zi.exact !== undefined ? { exact: zi.exact } : {}),
+                    type: zi.type,
+                },
+            });
+            return;
+        }
+        case "too_big": {
+            out.push({
+                ...base,
+                code: "too_big",
+                metadata: {
+                    maximum: zi.maximum,
+                    inclusive: zi.inclusive,
+                    ...(zi.exact !== undefined ? { exact: zi.exact } : {}),
+                    type: zi.type,
+                },
+            });
+            return;
+        }
+        case "invalid_string": {
+            // email / url / uuid / regex / etc. all collapse to invalid_format;
+            // the specific validator name is preserved on metadata for UIs
+            // that want to render a tailored hint.
+            out.push({
+                ...base,
+                code: "invalid_format",
+                metadata: { validation: zi.validation },
+            });
+            return;
+        }
+        case "invalid_date": {
+            // DateNode has no v0.6 builder; fall through to invalid_type per
+            // the locked table.
+            out.push({ ...base, code: "invalid_type" });
+            return;
+        }
+        case "custom": {
+            out.push({ ...base, code: "custom_refinement_failed" });
+            return;
+        }
+        default: {
+            // Fallback (round-2 amendment to Decision #12): any code we
+            // do not explicitly map — `invalid_intersection_types`,
+            // `not_multiple_of`, `not_finite`, or any future Zod code —
+            // surfaces as `custom_refinement_failed` while preserving the
+            // original code on `metadata.zodCode` so it is recoverable
+            // downstream. `metadata.source = "zod"` is the discriminator
+            // consumers key off to decide whether to trust the field.
+            const code = zi.code ?? "unknown";
+            out.push({
+                ...base,
+                code: "custom_refinement_failed",
+                metadata: { source: "zod", zodCode: code },
+            });
+            return;
+        }
+    }
+}
+//# sourceMappingURL=normalize-issues.js.map

package/dist/src/runtime/normalize-issues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-issues.js","sourceRoot":"","sources":["../../../src/runtime/normalize-issues.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAMH;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,eAAe,CAC7B,KAAe,EACf,MAAkB;IAElB,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC;IACrC,MAAM,aAAa,GAAG,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC/C,MAAM,GAAG,GAAY,EAAE,CAAC;IACxB,KAAK,MAAM,EAAE,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QAC9B,gBAAgB,CAAC,GAAG,EAAE,EAAE,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC;IACrD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,gBAAgB,CACvB,GAAY,EACZ,EAAY,EACZ,QAA4B,EAC5B,aAAiC;IAEjC,MAAM,IAAI,GAAG;QACX,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE;QACrB,OAAO,EAAE,EAAE,CAAC,OAAO;QACnB,QAAQ,EAAE,OAAgB;QAC1B,GAAG,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/C,GAAG,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC1D,CAAC;IAEF,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC;QAChB,KAAK,cAAc,CAAC,CAAC,CAAC;YACpB,8DAA8D;YAC9D,oEAAoE;YACpE,+DAA+D;YAC/D,4CAA4C;YAC5C,MAAM,SAAS,GACb,EAAE,CAAC,QAAQ,KAAK,WAAW,IAAI,EAAE,CAAC,QAAQ,KAAK,WAAW,CAAC;YAC7D,GAAG,CAAC,IAAI,CAAC;gBACP,GAAG,IAAI;gBACP,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,cAAc;gBACrD,QAAQ,EAAE,EAAE,CAAC,QAAQ;gBACrB,QAAQ,EAAE,EAAE,CAAC,QAAQ;aACtB,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,KAAK,iBAAiB,CAAC,CAAC,CAAC;YACvB,GAAG,CAAC,IAAI,CAAC;gBACP,GAAG,IAAI;gBACP,IAAI,EAAE,iBAAiB;gBACvB,QAAQ,EAAE,EAAE,CAAC,QAAQ;gBACrB,QAAQ,EAAE,EAAE,CAAC,QAAQ;aACtB,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,KAAK,mBAAmB,CAAC,CAAC,CAAC;YACzB,wDAAwD;YACxD,yDAAyD;YACzD,sCAAsC;YACtC,KAAK,MAAM,GAAG,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;gBAC1B,GAAG,CAAC,IAAI,CAAC;oBACP,GAAG,IAAI;oBACP,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC;oBACvB,IAAI,EAAE,aAAa;oBACnB,QAAQ,EAAE,GAAG;iBACd,CAAC,CAAC;YACL,CAAC;YACD,OAAO;QACT,CAAC;QAED,KAAK,oBAAoB,CAAC,CAAC,CAAC;YAC1B,GAAG,CAAC,IAAI,CAAC;gBACP,GAAG,IAAI;gBACP,IAAI,EAAE,cAAc;gBACpB,QAAQ,EAAE,EAAE,CAAC,OAAO;gBACpB,QAAQ,EAAE,EAAE,CAAC,QAAQ;aACtB,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,KAAK,eAAe,CAAC;QACrB,KAAK,6BAA6B,CAAC,CAAC,CAAC;YACnC,2DAA2D;YAC3D,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC,CAAC;YAC7C,OAAO;QACT,CAAC;QAED,KAAK,mBAAmB,CAAC;QACzB,KAAK,qBAAqB,CAAC,CAAC,CAAC;YAC3B,+DAA+D;YAC/D,6DAA6D;YAC7D,8DAA8D;YAC9D,GAAG,CAAC,IAAI,CAAC;gBACP,GAAG,IAAI;gBACP,IAAI,EAAE,cAAc;gBACpB,QAAQ,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,IAAI,EAAE;aAC9C,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,KAAK,WAAW,CAAC,CAAC,CAAC;YACjB,GAAG,CAAC,IAAI,CAAC;gBACP,GAAG,IAAI;gBACP,IAAI,EAAE,WAAW;gBACjB,QAAQ,EAAE;oBACR,OAAO,EAAE,EAAE,CAAC,OAAO;oBACnB,SAAS,EAAE,EAAE,CAAC,SAAS;oBACvB,GAAG,CAAC,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;oBACtD,IAAI,EAAE,EAAE,CAAC,IAAI;iBACd;aACF,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,KAAK,SAAS,CAAC,CAAC,CAAC;YACf,GAAG,CAAC,IAAI,CAAC;gBACP,GAAG,IAAI;gBACP,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE;oBACR,OAAO,EAAE,EAAE,CAAC,OAAO;oBACnB,SAAS,EAAE,EAAE,CAAC,SAAS;oBACvB,GAAG,CAAC,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;oBACtD,IAAI,EAAE,EAAE,CAAC,IAAI;iBACd;aACF,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,KAAK,gBAAgB,CAAC,CAAC,CAAC;YACtB,oEAAoE;YACpE,+DAA+D;YAC/D,uCAAuC;YACvC,GAAG,CAAC,IAAI,CAAC;gBACP,GAAG,IAAI;gBACP,IAAI,EAAE,gBAAgB;gBACtB,QAAQ,EAAE,EAAE,UAAU,EAAE,EAAE,CAAC,UAAU,EAAE;aACxC,CAAC,CAAC;YACH,OAAO;QACT,CAAC;QAED,KAAK,cAAc,CAAC,CAAC,CAAC;YACpB,iEAAiE;YACjE,oBAAoB;YACpB,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,CAAC,CAAC;YAC5C,OAAO;QACT,CAAC;QAED,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,0BAA0B,EAAE,CAAC,CAAC;YACxD,OAAO;QACT,CAAC;QAED,OAAO,CAAC,CAAC,CAAC;YACR,4DAA4D;YAC5D,wDAAwD;YACxD,4DAA4D;YAC5D,8DAA8D;YAC9D,2DAA2D;YAC3D,6DAA6D;YAC7D,0DAA0D;YAC1D,MAAM,IAAI,GAAI,EAAwB,CAAC,IAAI,IAAI,SAAS,CAAC;YACzD,GAAG,CAAC,IAAI,CAAC;gBACP,GAAG,IAAI;gBACP,IAAI,EAAE,0BAA0B;gBAChC,QAAQ,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE;aAC3C,CAAC,CAAC;YACH,OAAO;QACT,CAAC;IACH,CAAC;AACH,CAAC"}

package/dist/src/runtime/parse.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Runtime API entry points (Step 6 of v0.6 plan).
+ *
+ * Wires together the Decision #6 value consumer, the Decision #7
+ * compile cache, the Decision #8 validate-only variant, the
+ * Decision #12 issue normalizer, and `ParseError`.
+ *
+ * **Three entry points, one engine.**
+ *
+ *   parse(schema, input)     -> s.output<S>             | throws ParseError
+ *   safeParse(schema, input) -> Result<s.output<S>>
+ *   validate(schema, input)  -> Result<s.input<S>>
+ *
+ * `parse` is the friction-causing default — code that doesn't
+ * explicitly want to handle issues gets loud failure. `safeParse` is
+ * the Result-returning alternative for callers that branch on
+ * success/failure. `validate` is the structural check that does NOT
+ * apply defaults or transforms — see Decision #8 for the absence-
+ * semantics rationale.
+ *
+ * **Validate-variant cache.** `stripDefaultsForValidate(node)` returns
+ * a new tree each call, which would defeat the Step 2 compile cache
+ * (the cache keys on `SchemaNode` identity). To keep validate paths
+ * cache-friendly, we memoize the stripped variant by original-node
+ * identity here. Subsequent `validate(schema, ...)` calls reuse the
+ * same variant `SchemaNode` and therefore the same compiled Zod
+ * schema.
+ *
+ * **Issue normalization.** Every failure path runs through
+ * `normalizeIssues(error, schema.node)`. We pass the *original*
+ * schema node — not the validate variant — so `schemaId` /
+ * `schemaVersion` come from the consumer's source-of-truth metadata,
+ * regardless of which compile path produced the failure.
+ *
+ * Internal-only at this step. Public re-exports of `parse` /
+ * `safeParse` / `validate` / `ParseError` land in step 13.
+ */
+import type { AnySchema } from "../builders/schema.js";
+import type { Input, Output } from "../types.js";
+import type { Result } from "../errors/issue.js";
+/**
+ * Parse `input` against `schema`. Returns the output shape (defaults
+ * applied, transforms run) on success; throws `ParseError` with the
+ * full normalized issue list on failure.
+ */
+export declare function parse<S extends AnySchema>(schema: S, input: unknown): Output<S>;
+/**
+ * Like `parse`, but returns a `Result` rather than throwing. Use
+ * when the caller wants to branch on success/failure inline.
+ */
+export declare function safeParse<S extends AnySchema>(schema: S, input: unknown): Result<Output<S>>;
+/**
+ * Structural validation. Compiles against the validate-only IR
+ * variant (defaults stripped, default-bearing fields flipped to
+ * optional per Decision #8). Returns `Result<s.input<S>>` — defaults
+ * are NOT filled, transforms are NOT run.
+ *
+ * Use when the caller wants to know whether the input would parse,
+ * without paying for transforms or accepting a default-filled output.
+ */
+export declare function validate<S extends AnySchema>(schema: S, input: unknown): Result<Input<S>>;
+//# sourceMappingURL=parse.d.ts.map

package/dist/src/runtime/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../src/runtime/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAqBjD;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,SAAS,EACvC,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,GACb,MAAM,CAAC,CAAC,CAAC,CAKX;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,SAAS,EAC3C,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,GACb,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAUnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,SAAS,EAC1C,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,GACb,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAclB"}

package/dist/src/runtime/parse.js

@@ -0,0 +1,107 @@
+/**
+ * Runtime API entry points (Step 6 of v0.6 plan).
+ *
+ * Wires together the Decision #6 value consumer, the Decision #7
+ * compile cache, the Decision #8 validate-only variant, the
+ * Decision #12 issue normalizer, and `ParseError`.
+ *
+ * **Three entry points, one engine.**
+ *
+ *   parse(schema, input)     -> s.output<S>             | throws ParseError
+ *   safeParse(schema, input) -> Result<s.output<S>>
+ *   validate(schema, input)  -> Result<s.input<S>>
+ *
+ * `parse` is the friction-causing default — code that doesn't
+ * explicitly want to handle issues gets loud failure. `safeParse` is
+ * the Result-returning alternative for callers that branch on
+ * success/failure. `validate` is the structural check that does NOT
+ * apply defaults or transforms — see Decision #8 for the absence-
+ * semantics rationale.
+ *
+ * **Validate-variant cache.** `stripDefaultsForValidate(node)` returns
+ * a new tree each call, which would defeat the Step 2 compile cache
+ * (the cache keys on `SchemaNode` identity). To keep validate paths
+ * cache-friendly, we memoize the stripped variant by original-node
+ * identity here. Subsequent `validate(schema, ...)` calls reuse the
+ * same variant `SchemaNode` and therefore the same compiled Zod
+ * schema.
+ *
+ * **Issue normalization.** Every failure path runs through
+ * `normalizeIssues(error, schema.node)`. We pass the *original*
+ * schema node — not the validate variant — so `schemaId` /
+ * `schemaVersion` come from the consumer's source-of-truth metadata,
+ * regardless of which compile path produced the failure.
+ *
+ * Internal-only at this step. Public re-exports of `parse` /
+ * `safeParse` / `validate` / `ParseError` land in step 13.
+ */
+import { compile } from "./compile.js";
+import { stripDefaultsForValidate } from "./strip-defaults.js";
+import { normalizeIssues } from "./normalize-issues.js";
+import { ParseError } from "./errors.js";
+/**
+ * Memoize the validate-only variant by original `SchemaNode` identity.
+ * Without this, `validate(sameSchema, ...)` would rebuild the
+ * stripped tree on every call and miss the Step 2 compile cache.
+ */
+const validateNodeCache = new WeakMap();
+function getValidateNode(node) {
+    const cached = validateNodeCache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const variant = stripDefaultsForValidate(node);
+    validateNodeCache.set(node, variant);
+    return variant;
+}
+/**
+ * Parse `input` against `schema`. Returns the output shape (defaults
+ * applied, transforms run) on success; throws `ParseError` with the
+ * full normalized issue list on failure.
+ */
+export function parse(schema, input) {
+    const zod = compile(schema.node);
+    const result = zod.safeParse(input);
+    if (result.success)
+        return result.data;
+    throw new ParseError(normalizeIssues(result.error, schema.node));
+}
+/**
+ * Like `parse`, but returns a `Result` rather than throwing. Use
+ * when the caller wants to branch on success/failure inline.
+ */
+export function safeParse(schema, input) {
+    const zod = compile(schema.node);
+    const result = zod.safeParse(input);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return {
+        success: false,
+        issues: normalizeIssues(result.error, schema.node),
+    };
+}
+/**
+ * Structural validation. Compiles against the validate-only IR
+ * variant (defaults stripped, default-bearing fields flipped to
+ * optional per Decision #8). Returns `Result<s.input<S>>` — defaults
+ * are NOT filled, transforms are NOT run.
+ *
+ * Use when the caller wants to know whether the input would parse,
+ * without paying for transforms or accepting a default-filled output.
+ */
+export function validate(schema, input) {
+    const variant = getValidateNode(schema.node);
+    const zod = compile(variant);
+    const result = zod.safeParse(input);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    // Pass the *original* schema node so schemaId / schemaVersion come
+    // from the user-authored metadata regardless of which compile path
+    // (parse or validate) produced the failure.
+    return {
+        success: false,
+        issues: normalizeIssues(result.error, schema.node),
+    };
+}
+//# sourceMappingURL=parse.js.map

package/dist/src/runtime/parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../../src/runtime/parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAMH,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;GAIG;AACH,MAAM,iBAAiB,GAAG,IAAI,OAAO,EAA0B,CAAC;AAEhE,SAAS,eAAe,CAAC,IAAgB;IACvC,MAAM,MAAM,GAAG,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC3C,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACxC,MAAM,OAAO,GAAG,wBAAwB,CAAC,IAAI,CAAC,CAAC;IAC/C,iBAAiB,CAAC,GAAG,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACrC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,KAAK,CACnB,MAAS,EACT,KAAc;IAEd,MAAM,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACpC,IAAI,MAAM,CAAC,OAAO;QAAE,OAAO,MAAM,CAAC,IAAiB,CAAC;IACpD,MAAM,IAAI,UAAU,CAAC,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;AACnE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,SAAS,CACvB,MAAS,EACT,KAAc;IAEd,MAAM,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjC,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACpC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAiB,EAAE,CAAC;IAC3D,CAAC;IACD,OAAO;QACL,OAAO,EAAE,KAAK;QACd,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC;KACnD,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,QAAQ,CACtB,MAAS,EACT,KAAc;IAEd,MAAM,OAAO,GAAG,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC7C,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7B,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACpC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;QACnB,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAgB,EAAE,CAAC;IAC1D,CAAC;IACD,mEAAmE;IACnE,mEAAmE;IACnE,4CAA4C;IAC5C,OAAO;QACL,OAAO,EAAE,KAAK;QACd,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC;KACnD,CAAC;AACJ,CAAC"}