typesea 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compile/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,iBAAiB,EACjB,OAAO,EACR,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,wBAAwB,EACzB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,cAAc,EACd,aAAa,EACb,oBAAoB,EACrB,MAAM,YAAY,CAAC"}

package/dist/compile/index.js

@@ -0,0 +1,6 @@
+/**
+ * @file compile/index.ts
+ * @brief Public compile module barrel.
+ */
+export { CompiledBaseGuard, compile } from "./guard.js";
+export { emitCompiledSourceBundle } from "./source.js";

package/dist/compile/issue.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file compile/issue.ts
+ * @brief Diagnostic issue source snippets.
+ */
+import type { EmitContext } from "./types.js";
+/**
+ * @brief emit pattern issue.
+ */
+export declare function emitPatternIssue(value: string, path: string, issues: string, regex: RegExp, name: string, context: EmitContext): string;
+/**
+ * @brief emit issue.
+ */
+export declare function emitIssue(issues: string, path: string, code: string, expected: string, actualExpression: string): string;
+/**
+ * @brief emit issue expr.
+ */
+export declare function emitIssueExpr(issues: string, path: string, code: string, expectedExpression: string, actualExpression: string): string;
+//# sourceMappingURL=issue.d.ts.map

package/dist/compile/issue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issue.d.ts","sourceRoot":"","sources":["../../src/compile/issue.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,WAAW,GACnB,MAAM,CAWR;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAQR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,kBAAkB,EAAE,MAAM,EAC1B,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAER"}

package/dist/compile/issue.js

@@ -0,0 +1,28 @@
+/**
+ * @file compile/issue.ts
+ * @brief Diagnostic issue source snippets.
+ */
+import { UUID_PATTERN } from "../schema/index.js";
+import { pushRegex, stringRef } from "./context.js";
+import { stringLiteral } from "./names.js";
+/**
+ * @brief emit pattern issue.
+ */
+export function emitPatternIssue(value, path, issues, regex, name, context) {
+    const source = regex === UUID_PATTERN ? UUID_PATTERN : regex;
+    const index = pushRegex(context, source);
+    const access = `r[${String(index)}]`;
+    return `if(((${access}.lastIndex=0),!${access}.test(${value}))){${emitIssueExpr(issues, path, "expected_pattern", stringRef(context, name), stringLiteral("string"))}}`;
+}
+/**
+ * @brief emit issue.
+ */
+export function emitIssue(issues, path, code, expected, actualExpression) {
+    return emitIssueExpr(issues, path, code, stringLiteral(expected), actualExpression);
+}
+/**
+ * @brief emit issue expr.
+ */
+export function emitIssueExpr(issues, path, code, expectedExpression, actualExpression) {
+    return `q(${issues},${path},${stringLiteral(code)},${expectedExpression},${actualExpression});`;
+}

package/dist/compile/names.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @file compile-names.ts
+ * @brief Generated function-name and string literal helpers.
+ *
+ * @invariant User-provided names never enter generated source until they are
+ * reduced to a strict-mode-safe identifier with a fixed length bound.
+ */
+/**
+ * @brief safe function name.
+ */
+export declare function safeFunctionName(value: string): string;
+/**
+ * @brief string literal.
+ */
+export declare function stringLiteral(value: string): string;
+//# sourceMappingURL=names.d.ts.map

package/dist/compile/names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/compile/names.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAYtD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/compile/names.js

@@ -0,0 +1,82 @@
+/**
+ * @file compile-names.ts
+ * @brief Generated function-name and string literal helpers.
+ *
+ * @invariant User-provided names never enter generated source until they are
+ * reduced to a strict-mode-safe identifier with a fixed length bound.
+ */
+const MAX_GENERATED_FUNCTION_NAME_LENGTH = 96;
+/**
+ * @brief safe function name.
+ */
+export function safeFunctionName(value) {
+    const replaced = value.replace(/[^$_a-zA-Z0-9]/gu, "_");
+    const bounded = replaced.length > MAX_GENERATED_FUNCTION_NAME_LENGTH
+        ? replaced.slice(0, MAX_GENERATED_FUNCTION_NAME_LENGTH)
+        : replaced;
+    if (/^[$_a-zA-Z]/u.test(bounded) && !reservedFunctionNames.has(bounded)) {
+        return bounded;
+    }
+    const prefixed = `_${bounded}`;
+    return prefixed.length > MAX_GENERATED_FUNCTION_NAME_LENGTH
+        ? prefixed.slice(0, MAX_GENERATED_FUNCTION_NAME_LENGTH)
+        : prefixed;
+}
+/**
+ * @brief string literal.
+ */
+export function stringLiteral(value) {
+    return JSON.stringify(value);
+}
+/**
+ * @brief reserved function names.
+ */
+const reservedFunctionNames = new Set([
+    "arguments",
+    "await",
+    "break",
+    "ca" + "tch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "eval",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "interface",
+    "let",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "tr" + "y",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield"
+]);

package/dist/compile/predicate.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @file compile/predicate.ts
+ * @brief Boolean validator source emitter.
+ */
+import { type Schema } from "../schema/index.js";
+import type { EmitContext } from "./types.js";
+/**
+ * @brief emit function.
+ */
+export declare function emitFunction(schema: Schema, context: EmitContext): string;
+/**
+ * @brief emit functions.
+ */
+export declare function emitFunctions(context: EmitContext): string;
+/**
+ * @brief emit expression.
+ */
+export declare function emitExpression(schema: Schema, value: string, context: EmitContext): string;
+/**
+ * @brief emit union.
+ */
+export declare function emitUnion(options: readonly Schema[], value: string, context: EmitContext): string;
+//# sourceMappingURL=predicate.d.ts.map

package/dist/compile/predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../../src/compile/predicate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,EAGL,KAAK,MAAM,EACZ,MAAM,oBAAoB,CAAC;AAO5B,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,YAAY,CAAC;AAE9D;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,MAAM,CAczE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAU1D;AAsBD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,WAAW,GACnB,MAAM,CA+CR;AA0PD;;GAEG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,WAAW,GACnB,MAAM,CAYR"}

package/dist/compile/predicate.js

@@ -0,0 +1,317 @@
+/**
+ * @file compile/predicate.ts
+ * @brief Boolean validator source emitter.
+ */
+import { NumberCheckTag, ObjectModeTag, PresenceTag, SchemaTag, StringCheckTag } from "../kind/index.js";
+import { UUID_PATTERN } from "../schema/index.js";
+import { pushLiteral, pushRegex, pushSchema, stringRef } from "./context.js";
+/**
+ * @brief emit function.
+ */
+export function emitFunction(schema, context) {
+    const cached = context.functionNames.get(schema);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const name = `p${String(context.functions.length)}`;
+    const source = {
+        name,
+        body: ""
+    };
+    context.functionNames.set(schema, name);
+    context.functions.push(source);
+    source.body = emitBody(schema, "v", context);
+    return name;
+}
+/**
+ * @brief emit functions.
+ */
+export function emitFunctions(context) {
+    const chunks = new Array(context.functions.length);
+    for (let index = 0; index < context.functions.length; index += 1) {
+        const source = context.functions[index];
+        if (source === undefined) {
+            continue;
+        }
+        chunks[index] = `function ${source.name}(v){${source.body}}`;
+    }
+    return chunks.join("");
+}
+/**
+ * @brief emit body.
+ */
+function emitBody(schema, value, context) {
+    switch (schema.tag) {
+        case SchemaTag.Array:
+            return emitArrayBody(schema.item, value, context);
+        case SchemaTag.Tuple:
+            return emitTupleBody(schema.items, value, context);
+        case SchemaTag.Record:
+            return emitRecordBody(schema.value, value, context);
+        case SchemaTag.Object:
+            return emitObjectBody(schema, value, context);
+        case SchemaTag.DiscriminatedUnion:
+            return emitDiscriminatedUnionBody(schema.key, schema.cases, value, context);
+        default:
+            return `return ${emitExpression(schema, value, context)};`;
+    }
+}
+/**
+ * @brief emit expression.
+ */
+export function emitExpression(schema, value, context) {
+    switch (schema.tag) {
+        case SchemaTag.Unknown:
+            return "true";
+        case SchemaTag.Never:
+            return "false";
+        case SchemaTag.String:
+            return emitString(schema, value, context);
+        case SchemaTag.Number:
+            return emitNumber(schema, value);
+        case SchemaTag.BigInt:
+            return `(typeof ${value}==="bigint")`;
+        case SchemaTag.Symbol:
+            return `(typeof ${value}==="symbol")`;
+        case SchemaTag.Boolean:
+            return `(typeof ${value}==="boolean")`;
+        case SchemaTag.Literal:
+            return `Object.is(${value},l[${String(pushLiteral(context, schema.value))}])`;
+        case SchemaTag.Array:
+            return `${emitFunction(schema, context)}(${value})`;
+        case SchemaTag.Tuple:
+            return `${emitFunction(schema, context)}(${value})`;
+        case SchemaTag.Record:
+            return `${emitFunction(schema, context)}(${value})`;
+        case SchemaTag.Object:
+            return `${emitFunction(schema, context)}(${value})`;
+        case SchemaTag.Union:
+            return emitUnion(schema.options, value, context);
+        case SchemaTag.Intersection:
+            return `(${emitExpression(schema.left, value, context)}&&${emitExpression(schema.right, value, context)})`;
+        case SchemaTag.Optional:
+        case SchemaTag.Undefinedable:
+            return `(${value}===undefined||${emitExpression(schema.inner, value, context)})`;
+        case SchemaTag.Nullable:
+            return `(${value}===null||${emitExpression(schema.inner, value, context)})`;
+        case SchemaTag.DiscriminatedUnion:
+            return `${emitFunction(schema, context)}(${value})`;
+        case SchemaTag.Brand:
+            return emitExpression(schema.inner, value, context);
+        case SchemaTag.Lazy:
+        case SchemaTag.Refine:
+            return `d(${String(pushSchema(context, schema))},${value})`;
+    }
+}
+/**
+ * @brief emit array body.
+ */
+function emitArrayBody(item, value, context) {
+    const itemFunction = emitFunction(item, context);
+    return [
+        `if(!Array.isArray(${value}))return false;`,
+        `for(let i=0;i<${value}.length;i+=1){`,
+        `const d=gp(${value},i);`,
+        `if(d!==undefined&&!h.call(d,"value"))return false;`,
+        `if(!${itemFunction}(d===undefined?undefined:d.value))return false;`,
+        "}",
+        "return true;"
+    ].join("");
+}
+/**
+ * @brief emit record body.
+ */
+function emitRecordBody(item, value, context) {
+    const itemFunction = emitFunction(item, context);
+    return [
+        `if(!o(${value}))return false;`,
+        `const ks=Object.keys(${value});`,
+        "for(let i=0;i<ks.length;i+=1){",
+        "const key=ks[i];",
+        `const d=key===undefined?undefined:gp(${value},key);`,
+        `if(d===undefined||!h.call(d,"value")||!${itemFunction}(d.value))return false;`,
+        "}",
+        "return true;"
+    ].join("");
+}
+/**
+ * @brief emit tuple body.
+ * @details Emits tuple validation as straight-line descriptor reads and early returns.
+ * @returns Generated tuple predicate body.
+ */
+function emitTupleBody(items, value, context) {
+    const chunks = [
+        `if(!Array.isArray(${value})||${value}.length!==${String(items.length)})return false;`
+    ];
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (item === undefined) {
+            continue;
+        }
+        const descriptor = `d${String(index)}`;
+        const itemValue = `v${String(index)}`;
+        chunks.push(`const ${descriptor}=gp(${value},${String(index)});`, `if(${descriptor}!==undefined&&!h.call(${descriptor},"value"))return false;`, `const ${itemValue}=${descriptor}===undefined?undefined:${descriptor}.value;`, `if(!${emitExpression(item, itemValue, context)})return false;`);
+    }
+    chunks.push("return true;");
+    return chunks.join("");
+}
+/**
+ * @brief emit object body.
+ * @details Emits object validation as Ajv-style straight-line code with local descriptor variables.
+ * @returns Generated object predicate body.
+ */
+function emitObjectBody(schema, value, context) {
+    const chunks = [`if(!o(${value}))return false;`];
+    chunks.push(emitStrictObjectKeyBody(schema, value, context));
+    const entries = schema.entries;
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry === undefined) {
+            continue;
+        }
+        const key = stringRef(context, entry.key);
+        const descriptor = `d${String(index)}`;
+        const itemValue = `v${String(index)}`;
+        chunks.push(`const ${descriptor}=gp(${value},${key});`);
+        if (entry.presence === PresenceTag.Optional) {
+            chunks.push(`if(${descriptor}!==undefined){`, `if(!h.call(${descriptor},"value"))return false;`, `const ${itemValue}=${descriptor}.value;`, `if(!${emitExpression(entry.schema, itemValue, context)})return false;`, `}else if(h.call(${value},${key}))return false;`);
+        }
+        else {
+            chunks.push(`if(${descriptor}===undefined||!h.call(${descriptor},"value"))return false;`, `const ${itemValue}=${descriptor}.value;`, `if(!${emitExpression(entry.schema, itemValue, context)})return false;`);
+        }
+    }
+    chunks.push("return true;");
+    return chunks.join("");
+}
+/**
+ * @brief emit strict object key body.
+ * @details Emits a low-allocation known-key check specialized for one object shape.
+ * @returns Generated strict-key prelude, or an empty string for passthrough objects.
+ */
+function emitStrictObjectKeyBody(schema, value, context) {
+    if (schema.mode !== ObjectModeTag.Strict) {
+        return "";
+    }
+    const entries = schema.entries;
+    const comparisons = [];
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry !== undefined) {
+            comparisons.push(`key!==${stringRef(context, entry.key)}`);
+        }
+    }
+    if (comparisons.length === 0) {
+        return `if(Reflect.ownKeys(${value}).length!==0)return false;`;
+    }
+    return [
+        `const xs=Reflect.ownKeys(${value});`,
+        "for(let i=0;i<xs.length;i+=1){",
+        "const key=xs[i];",
+        `if(typeof key!=="string"||(${comparisons.join("&&")}))return false;`,
+        "}"
+    ].join("");
+}
+/**
+ * @brief emit discriminated union body.
+ * @details Emits discriminant selection once and dispatches to branch validators.
+ * @returns Generated discriminated-union predicate body.
+ */
+function emitDiscriminatedUnionBody(key, cases, value, context) {
+    const keyRef = stringRef(context, key);
+    const chunks = [
+        `if(!o(${value}))return false;`,
+        `const d=gp(${value},${keyRef});`,
+        `if(d===undefined||!h.call(d,"value"))return false;`,
+        "const dv=d.value;",
+        `if(typeof dv!=="string")return false;`
+    ];
+    for (let index = 0; index < cases.length; index += 1) {
+        const unionCase = cases[index];
+        if (unionCase === undefined) {
+            continue;
+        }
+        chunks.push(`if(Object.is(dv,l[${String(pushLiteral(context, unionCase.literal))}]))return ${emitExpression(unionCase.schema, value, context)};`);
+    }
+    chunks.push("return false;");
+    return chunks.join("");
+}
+/**
+ * @brief emit string.
+ */
+function emitString(schema, value, context) {
+    const parts = [`(typeof ${value}==="string")`];
+    const checks = schema.checks;
+    for (let index = 0; index < checks.length; index += 1) {
+        const check = checks[index];
+        if (check === undefined) {
+            continue;
+        }
+        switch (check.tag) {
+            case StringCheckTag.Min:
+                parts.push(`(${value}.length>=${String(check.value)})`);
+                break;
+            case StringCheckTag.Max:
+                parts.push(`(${value}.length<=${String(check.value)})`);
+                break;
+            case StringCheckTag.Regex:
+                parts.push(emitRegex(value, check.regex, context));
+                break;
+            case StringCheckTag.Uuid:
+                parts.push(emitRegex(value, UUID_PATTERN, context));
+                break;
+        }
+    }
+    return `(${parts.join("&&")})`;
+}
+/**
+ * @brief emit number.
+ */
+function emitNumber(schema, value) {
+    const parts = [
+        `(typeof ${value}==="number")`,
+        `Number.isFinite(${value})`
+    ];
+    const checks = schema.checks;
+    for (let index = 0; index < checks.length; index += 1) {
+        const check = checks[index];
+        if (check === undefined) {
+            continue;
+        }
+        switch (check.tag) {
+            case NumberCheckTag.Integer:
+                parts.push(`Number.isInteger(${value})`);
+                break;
+            case NumberCheckTag.Gte:
+                parts.push(`(${value}>=${String(check.value)})`);
+                break;
+            case NumberCheckTag.Lte:
+                parts.push(`(${value}<=${String(check.value)})`);
+                break;
+        }
+    }
+    return `(${parts.join("&&")})`;
+}
+/**
+ * @brief emit union.
+ */
+export function emitUnion(options, value, context) {
+    const parts = [];
+    for (let index = 0; index < options.length; index += 1) {
+        const option = options[index];
+        if (option !== undefined) {
+            parts.push(emitExpression(option, value, context));
+        }
+    }
+    if (parts.length === 0) {
+        return "false";
+    }
+    return `(${parts.join("||")})`;
+}
+/**
+ * @brief emit regex.
+ */
+function emitRegex(value, regex, context) {
+    const index = pushRegex(context, regex);
+    const access = `r[${String(index)}]`;
+    return `((${access}.lastIndex=0),${access}.test(${value}))`;
+}

package/dist/compile/runtime.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @file compile-runtime.ts
+ * @brief Runtime support passed into generated validator factories.
+ *
+ * @section side_tables Side-table ABI
+ * Generated validators receive literals, regexps, keysets, strings, and
+ * dynamic schema fallbacks as indexed tables. The emitted source contains only
+ * numeric table slots and compact helper names.
+ */
+import type { Issue, PathSegment } from "../issue/index.js";
+import type { LiteralValue, Schema } from "../schema/index.js";
+/**
+ * @brief boolean predicate.
+ */
+export type BooleanPredicate = (value: unknown) => boolean;
+/**
+ * @brief issue collector root.
+ */
+export type IssueCollectorRoot = (value: unknown) => readonly Issue[];
+/**
+ * @brief dynamic check.
+ */
+export type DynamicCheck = (schemaIndex: number, value: unknown) => boolean;
+/**
+ * @brief dynamic issue check.
+ */
+export type DynamicIssueCheck = (schemaIndex: number, value: unknown, path: readonly PathSegment[], issues: Issue[]) => void;
+/**
+ * @brief strict keys check.
+ */
+export type StrictKeysCheck = (value: unknown, keys: readonly string[]) => boolean;
+/**
+ * @brief runtime bundle.
+ */
+export interface RuntimeBundle {
+    readonly is: BooleanPredicate;
+    readonly check: IssueCollectorRoot;
+}
+/**
+ * @brief is factory.
+ */
+export type IsFactory = (literals: readonly LiteralValue[], regexps: readonly RegExp[], keysets: readonly (readonly string[])[], strings: readonly string[], dynamicCheck: DynamicCheck, dynamicIssueCheck: DynamicIssueCheck, strictKeys: StrictKeysCheck) => RuntimeBundle;
+/**
+ * @brief make dynamic check.
+ */
+export declare function makeDynamicCheck(schemas: readonly Schema[]): DynamicCheck;
+/**
+ * @brief make dynamic issue check.
+ */
+export declare function makeDynamicIssueCheck(schemas: readonly Schema[]): DynamicIssueCheck;
+/**
+ * @brief strict keys.
+ */
+export declare function strictKeys(value: unknown, keys: readonly string[]): boolean;
+//# sourceMappingURL=runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/compile/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAE/D;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,KAAK,EAAE,CAAC;AAEtE;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;AAE5E;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,MAAM,EAAE,KAAK,EAAE,KACZ,IAAI,CAAC;AAEV;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,CAC5B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,SAAS,MAAM,EAAE,KACpB,OAAO,CAAC;AAEb;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAC;IAC9B,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;CACpC;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CACtB,QAAQ,EAAE,SAAS,YAAY,EAAE,EACjC,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,OAAO,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACvC,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,YAAY,EAAE,YAAY,EAC1B,iBAAiB,EAAE,iBAAiB,EACpC,UAAU,EAAE,eAAe,KACxB,aAAa,CAAC;AAEnB;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAKzE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,iBAAiB,CA6BnB;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,OAAO,CAYT"}

package/dist/compile/runtime.js

@@ -0,0 +1,63 @@
+/**
+ * @file compile-runtime.ts
+ * @brief Runtime support passed into generated validator factories.
+ *
+ * @section side_tables Side-table ABI
+ * Generated validators receive literals, regexps, keysets, strings, and
+ * dynamic schema fallbacks as indexed tables. The emitted source contains only
+ * numeric table slots and compact helper names.
+ */
+import { checkSchema, isSchema } from "../evaluate/index.js";
+/**
+ * @brief make dynamic check.
+ */
+export function makeDynamicCheck(schemas) {
+    return (schemaIndex, value) => {
+        const schema = schemas[schemaIndex];
+        return schema !== undefined && isSchema(schema, value);
+    };
+}
+/**
+ * @brief make dynamic issue check.
+ */
+export function makeDynamicIssueCheck(schemas) {
+    return (schemaIndex, value, path, issues) => {
+        const schema = schemas[schemaIndex];
+        if (schema === undefined) {
+            return;
+        }
+        const result = checkSchema(schema, value);
+        if (result.ok) {
+            return;
+        }
+        const nested = result.error;
+        for (let index = 0; index < nested.length; index += 1) {
+            const issue = nested[index];
+            if (issue !== undefined) {
+                issues.push({
+                    path: path.concat(issue.path),
+                    code: issue.code,
+                    expected: issue.expected,
+                    actual: issue.actual,
+                    message: issue.message
+                });
+            }
+        }
+    };
+}
+/**
+ * @brief strict keys.
+ */
+export function strictKeys(value, keys) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const present = Reflect.ownKeys(value);
+    for (let index = 0; index < present.length; index += 1) {
+        const key = present[index];
+        if (typeof key !== "string" || !keys.includes(key)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/compile/source.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file compile/source.ts
+ * @brief Generated validator source bundle assembly.
+ */
+import type { Schema } from "../schema/index.js";
+import type { CompiledSourceBundle } from "./types.js";
+/**
+ * @brief emit compiled source bundle.
+ */
+export declare function emitCompiledSourceBundle(schema: Schema, name: string): CompiledSourceBundle;
+//# sourceMappingURL=source.d.ts.map

package/dist/compile/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/compile/source.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAKjD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,GACX,oBAAoB,CAuCtB"}