typesea 0.1.0 → 0.2.0

package/dist/compile/check-scalar.d.ts

@@ -1,24 +1,102 @@
 /**
  * @file compile/check-scalar.ts
  * @brief Scalar diagnostic validator snippets.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
  */
 import { SchemaTag } from "../kind/index.js";
 import { type LiteralValue, type Schema } from "../schema/index.js";
 import type { EmitContext } from "./types.js";
 /**
  * @brief emit string check.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param schema String schema with scalar checks.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns JavaScript source for root string diagnostics.
  */
 export declare function emitStringCheck(schema: Extract<Schema, {
     readonly tag: typeof SchemaTag.String;
 }>, value: string, path: string, issues: string, context: EmitContext): string;
+/**
+ * @brief emit leaf check at one appended path segment.
+ * @details This path is used by object-field diagnostics to avoid building a
+ * mutable path frame and calling a child collector for scalar schemas.
+ * @param schema Candidate leaf schema.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param segmentExpression Generated expression for the appended path segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Inline diagnostic source, or undefined when a full child collector is required.
+ */
+export declare function emitLeafCheckAtSegment(schema: Schema, value: string, path: string, segmentExpression: string, issues: string, context: EmitContext): string | undefined;
+/**
+ * @brief emit leaf check for a proven undefined value at one path segment.
+ * @details Array and tuple holes are known to be undefined. Emitting only the
+ * reachable type or literal issue keeps generated collectors smaller and avoids
+ * cold constraint branches that V8 still has to parse.
+ * @param schema Candidate leaf schema.
+ * @param path Generated expression for the current diagnostic path.
+ * @param segmentExpression Generated expression for the appended path segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Inline diagnostic source, or undefined when a full child collector is required.
+ */
+export declare function emitUndefinedLeafCheckAtSegment(schema: Schema, path: string, segmentExpression: string, issues: string, context: EmitContext): string | undefined;
+/**
+ * @brief emit leaf check at two appended path segments.
+ * @details Used by object-field array/record diagnostics to avoid push/pop path
+ * mutation when both parent key and child key are known in generated source.
+ * @param schema Candidate leaf schema.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param firstSegmentExpression Generated expression for the parent segment.
+ * @param secondSegmentExpression Generated expression for the child segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Inline diagnostic source, or undefined when a full child collector is required.
+ */
+export declare function emitLeafCheckAtTwoSegments(schema: Schema, value: string, path: string, firstSegmentExpression: string, secondSegmentExpression: string, issues: string, context: EmitContext): string | undefined;
+/**
+ * @brief emit leaf check for a proven undefined value at two path segments.
+ * @details Array and tuple holes under object fields are known to be undefined,
+ * so the emitter can skip value reads and emit only reachable leaf issues.
+ * @param schema Candidate leaf schema.
+ * @param path Generated expression for the current diagnostic path.
+ * @param firstSegmentExpression Generated expression for the parent segment.
+ * @param secondSegmentExpression Generated expression for the child segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Inline diagnostic source, or undefined when a full child collector is required.
+ */
+export declare function emitUndefinedLeafCheckAtTwoSegments(schema: Schema, path: string, firstSegmentExpression: string, secondSegmentExpression: string, issues: string, context: EmitContext): string | undefined;
 /**
  * @brief emit number check.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param schema Number schema with scalar checks.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param issues Generated expression for the issue buffer.
+ * @returns JavaScript source for root number diagnostics.
  */
 export declare function emitNumberCheck(schema: Extract<Schema, {
     readonly tag: typeof SchemaTag.Number;
 }>, value: string, path: string, issues: string): string;
 /**
  * @brief emit literal check.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param value Literal expected by the schema.
+ * @param checked Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns JavaScript source for root literal diagnostics.
  */
 export declare function emitLiteralCheck(value: LiteralValue, checked: string, path: string, issues: string, context: EmitContext): string;
 //# sourceMappingURL=check-scalar.d.ts.map

package/dist/compile/check-scalar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-scalar.d.ts","sourceRoot":"","sources":["../../src/compile/check-scalar.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAEL,SAAS,EAEV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,MAAM,EACZ,MAAM,oBAAoB,CAAC;AAQ5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;GAEG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,SAAS,CAAC,MAAM,CAAA;CAAE,CAAC,EAClE,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,GACnB,MAAM,CA4CR;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,SAAS,CAAC,MAAM,CAAA;CAAE,CAAC,EAClE,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,MAAM,CA+CR;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,GACnB,MAAM,CASR"}
+{"version":3,"file":"check-scalar.d.ts","sourceRoot":"","sources":["../../src/compile/check-scalar.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAEH,SAAS,EAEZ,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAEH,KAAK,YAAY,EACjB,KAAK,MAAM,EACd,MAAM,oBAAoB,CAAC;AAe5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC3B,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,SAAS,CAAC,MAAM,CAAA;CAAE,CAAC,EAClE,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,GACrB,MAAM,CAgDR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,GACrB,MAAM,GAAG,SAAS,CAkFpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC3C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,GACrB,MAAM,GAAG,SAAS,CAqEpB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,sBAAsB,EAAE,MAAM,EAC9B,uBAAuB,EAAE,MAAM,EAC/B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,GACrB,MAAM,GAAG,SAAS,CAsFpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mCAAmC,CAC/C,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,sBAAsB,EAAE,MAAM,EAC9B,uBAAuB,EAAE,MAAM,EAC/B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,GACrB,MAAM,GAAG,SAAS,CA4EpB;AA4MD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC3B,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,SAAS,CAAC,MAAM,CAAA;CAAE,CAAC,EAClE,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACf,MAAM,CAmDR;AA+KD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC5B,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,WAAW,GACrB,MAAM,CAaR"}

package/dist/compile/check-scalar.js

@@ -1,20 +1,35 @@
 /**
  * @file compile/check-scalar.ts
  * @brief Scalar diagnostic validator snippets.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
  */
 import { NumberCheckTag, SchemaTag, StringCheckTag } from "../kind/index.js";
 import { UUID_PATTERN } from "../schema/index.js";
 import { pushLiteral } from "./context.js";
-import { emitIssue, emitIssueExpr, emitPatternIssue } from "./issue.js";
+import { emitIssue, emitIssueAtSegment, emitIssueAtTwoSegments, emitIssueExpr, emitIssueExprAtSegment, emitIssueExprAtTwoSegments, emitPatternIssueAtSegment, emitPatternIssueAtTwoSegments, emitPatternIssue } from "./issue.js";
 import { stringLiteral } from "./names.js";
+import { emitUnion } from "./predicate.js";
 /**
  * @brief emit string check.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param schema String schema with scalar checks.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns JavaScript source for root string diagnostics.
  */
 export function emitStringCheck(schema, value, path, issues, context) {
     const parts = [
         `if(typeof ${value}!=="string"){${emitIssue(issues, path, "expected_string", "string", `a(${value})`)}return;}`
     ];
     const checks = schema.checks;
+    /*
+     * Constraint diagnostics run only after the type guard returns. This avoids
+     * meaningless length or pattern reads on non-string values.
+     */
     for (let index = 0; index < checks.length; index += 1) {
         const check = checks[index];
         if (check === undefined) {
@@ -37,14 +52,261 @@ export function emitStringCheck(schema, value, path, issues, context) {
     }
     return parts.join("");
 }
+/**
+ * @brief emit leaf check at one appended path segment.
+ * @details This path is used by object-field diagnostics to avoid building a
+ * mutable path frame and calling a child collector for scalar schemas.
+ * @param schema Candidate leaf schema.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param segmentExpression Generated expression for the appended path segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Inline diagnostic source, or undefined when a full child collector is required.
+ */
+export function emitLeafCheckAtSegment(schema, value, path, segmentExpression, issues, context) {
+    switch (schema.tag) {
+        case SchemaTag.Unknown:
+            return "";
+        case SchemaTag.Never:
+            return emitIssueAtSegment(issues, path, segmentExpression, "expected_never", "never", `a(${value})`);
+        case SchemaTag.String:
+            return emitStringCheckAtSegment(schema, value, path, segmentExpression, issues, context);
+        case SchemaTag.Number:
+            return emitNumberCheckAtSegment(schema, value, path, segmentExpression, issues);
+        case SchemaTag.BigInt:
+            return `if(typeof ${value}!=="bigint"){${emitIssueAtSegment(issues, path, segmentExpression, "expected_bigint", "bigint", `a(${value})`)}}`;
+        case SchemaTag.Symbol:
+            return `if(typeof ${value}!=="symbol"){${emitIssueAtSegment(issues, path, segmentExpression, "expected_symbol", "symbol", `a(${value})`)}}`;
+        case SchemaTag.Boolean:
+            return `if(typeof ${value}!=="boolean"){${emitIssueAtSegment(issues, path, segmentExpression, "expected_boolean", "boolean", `a(${value})`)}}`;
+        case SchemaTag.Literal:
+            return emitLiteralCheckAtSegment(schema.value, value, path, segmentExpression, issues, context);
+        case SchemaTag.Union:
+            /*
+             * Primitive unions are cheap enough to inline. Complex union branches
+             * already delegate through emitUnion and child predicate helpers.
+             */
+            return `if(!${emitUnion(schema.options, value, context)}){${emitIssueAtSegment(issues, path, segmentExpression, "expected_union", "union", `a(${value})`)}}`;
+        default:
+            return undefined;
+    }
+}
+/**
+ * @brief emit leaf check for a proven undefined value at one path segment.
+ * @details Array and tuple holes are known to be undefined. Emitting only the
+ * reachable type or literal issue keeps generated collectors smaller and avoids
+ * cold constraint branches that V8 still has to parse.
+ * @param schema Candidate leaf schema.
+ * @param path Generated expression for the current diagnostic path.
+ * @param segmentExpression Generated expression for the appended path segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Inline diagnostic source, or undefined when a full child collector is required.
+ */
+export function emitUndefinedLeafCheckAtSegment(schema, path, segmentExpression, issues, context) {
+    switch (schema.tag) {
+        case SchemaTag.Unknown:
+            return "";
+        case SchemaTag.Never:
+            return emitIssueAtSegment(issues, path, segmentExpression, "expected_never", "never", stringLiteral("undefined"));
+        case SchemaTag.String:
+            return emitIssueAtSegment(issues, path, segmentExpression, "expected_string", "string", stringLiteral("undefined"));
+        case SchemaTag.Number:
+            return emitIssueAtSegment(issues, path, segmentExpression, "expected_number", "number", stringLiteral("undefined"));
+        case SchemaTag.BigInt:
+            return emitIssueAtSegment(issues, path, segmentExpression, "expected_bigint", "bigint", stringLiteral("undefined"));
+        case SchemaTag.Symbol:
+            return emitIssueAtSegment(issues, path, segmentExpression, "expected_symbol", "symbol", stringLiteral("undefined"));
+        case SchemaTag.Boolean:
+            return emitIssueAtSegment(issues, path, segmentExpression, "expected_boolean", "boolean", stringLiteral("undefined"));
+        case SchemaTag.Literal:
+            return emitUndefinedLiteralCheckAtSegment(schema.value, path, segmentExpression, issues, context);
+        default:
+            return undefined;
+    }
+}
+/**
+ * @brief emit leaf check at two appended path segments.
+ * @details Used by object-field array/record diagnostics to avoid push/pop path
+ * mutation when both parent key and child key are known in generated source.
+ * @param schema Candidate leaf schema.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param firstSegmentExpression Generated expression for the parent segment.
+ * @param secondSegmentExpression Generated expression for the child segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Inline diagnostic source, or undefined when a full child collector is required.
+ */
+export function emitLeafCheckAtTwoSegments(schema, value, path, firstSegmentExpression, secondSegmentExpression, issues, context) {
+    switch (schema.tag) {
+        case SchemaTag.Unknown:
+            return "";
+        case SchemaTag.Never:
+            return emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_never", "never", `a(${value})`);
+        case SchemaTag.String:
+            return emitStringCheckAtTwoSegments(schema, value, path, firstSegmentExpression, secondSegmentExpression, issues, context);
+        case SchemaTag.Number:
+            return emitNumberCheckAtTwoSegments(schema, value, path, firstSegmentExpression, secondSegmentExpression, issues);
+        case SchemaTag.BigInt:
+            return `if(typeof ${value}!=="bigint"){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_bigint", "bigint", `a(${value})`)}}`;
+        case SchemaTag.Symbol:
+            return `if(typeof ${value}!=="symbol"){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_symbol", "symbol", `a(${value})`)}}`;
+        case SchemaTag.Boolean:
+            return `if(typeof ${value}!=="boolean"){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_boolean", "boolean", `a(${value})`)}}`;
+        case SchemaTag.Literal:
+            return emitLiteralCheckAtTwoSegments(schema.value, value, path, firstSegmentExpression, secondSegmentExpression, issues, context);
+        case SchemaTag.Union:
+            return `if(!${emitUnion(schema.options, value, context)}){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_union", "union", `a(${value})`)}}`;
+        default:
+            return undefined;
+    }
+}
+/**
+ * @brief emit leaf check for a proven undefined value at two path segments.
+ * @details Array and tuple holes under object fields are known to be undefined,
+ * so the emitter can skip value reads and emit only reachable leaf issues.
+ * @param schema Candidate leaf schema.
+ * @param path Generated expression for the current diagnostic path.
+ * @param firstSegmentExpression Generated expression for the parent segment.
+ * @param secondSegmentExpression Generated expression for the child segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Inline diagnostic source, or undefined when a full child collector is required.
+ */
+export function emitUndefinedLeafCheckAtTwoSegments(schema, path, firstSegmentExpression, secondSegmentExpression, issues, context) {
+    switch (schema.tag) {
+        case SchemaTag.Unknown:
+            return "";
+        case SchemaTag.Never:
+            return emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_never", "never", stringLiteral("undefined"));
+        case SchemaTag.String:
+            return emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_string", "string", stringLiteral("undefined"));
+        case SchemaTag.Number:
+            return emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_number", "number", stringLiteral("undefined"));
+        case SchemaTag.BigInt:
+            return emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_bigint", "bigint", stringLiteral("undefined"));
+        case SchemaTag.Symbol:
+            return emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_symbol", "symbol", stringLiteral("undefined"));
+        case SchemaTag.Boolean:
+            return emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_boolean", "boolean", stringLiteral("undefined"));
+        case SchemaTag.Literal:
+            return emitUndefinedLiteralCheckAtTwoSegments(schema.value, path, firstSegmentExpression, secondSegmentExpression, issues, context);
+        default:
+            return undefined;
+    }
+}
+/**
+ * @brief emit string check at one appended path segment.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param schema String schema with scalar checks.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param segmentExpression Generated expression for the appended path segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns JavaScript source for one-segment string diagnostics.
+ */
+function emitStringCheckAtSegment(schema, value, path, segmentExpression, issues, context) {
+    const checks = schema.checks;
+    if (checks.length === 0) {
+        /*
+         * No constraints means no else block is needed. The generated collector
+         * stays as a single type branch.
+         */
+        return `if(typeof ${value}!=="string"){${emitIssueAtSegment(issues, path, segmentExpression, "expected_string", "string", `a(${value})`)}}`;
+    }
+    const parts = [
+        `if(typeof ${value}!=="string"){${emitIssueAtSegment(issues, path, segmentExpression, "expected_string", "string", `a(${value})`)}}else{`
+    ];
+    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(`if(${value}.length<${String(check.value)}){${emitIssueAtSegment(issues, path, segmentExpression, "expected_min_length", `length >= ${String(check.value)}`, `"length "+String(${value}.length)`)}}`);
+                break;
+            case StringCheckTag.Max:
+                parts.push(`if(${value}.length>${String(check.value)}){${emitIssueAtSegment(issues, path, segmentExpression, "expected_max_length", `length <= ${String(check.value)}`, `"length "+String(${value}.length)`)}}`);
+                break;
+            case StringCheckTag.Regex:
+                parts.push(emitPatternIssueAtSegment(value, path, segmentExpression, issues, check.regex, check.name, context));
+                break;
+            case StringCheckTag.Uuid:
+                parts.push(emitPatternIssueAtSegment(value, path, segmentExpression, issues, UUID_PATTERN, "uuid", context));
+                break;
+        }
+    }
+    parts.push("}");
+    return parts.join("");
+}
+/**
+ * @brief emit string check at two appended path segments.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param schema String schema with scalar checks.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param firstSegmentExpression Generated expression for the parent segment.
+ * @param secondSegmentExpression Generated expression for the child segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns JavaScript source for two-segment string diagnostics.
+ */
+function emitStringCheckAtTwoSegments(schema, value, path, firstSegmentExpression, secondSegmentExpression, issues, context) {
+    const checks = schema.checks;
+    if (checks.length === 0) {
+        return `if(typeof ${value}!=="string"){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_string", "string", `a(${value})`)}}`;
+    }
+    const parts = [
+        `if(typeof ${value}!=="string"){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_string", "string", `a(${value})`)}}else{`
+    ];
+    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(`if(${value}.length<${String(check.value)}){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_min_length", `length >= ${String(check.value)}`, `"length "+String(${value}.length)`)}}`);
+                break;
+            case StringCheckTag.Max:
+                parts.push(`if(${value}.length>${String(check.value)}){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_max_length", `length <= ${String(check.value)}`, `"length "+String(${value}.length)`)}}`);
+                break;
+            case StringCheckTag.Regex:
+                parts.push(emitPatternIssueAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, check.regex, check.name, context));
+                break;
+            case StringCheckTag.Uuid:
+                parts.push(emitPatternIssueAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, UUID_PATTERN, "uuid", context));
+                break;
+        }
+    }
+    parts.push("}");
+    return parts.join("");
+}
 /**
  * @brief emit number check.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param schema Number schema with scalar checks.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param issues Generated expression for the issue buffer.
+ * @returns JavaScript source for root number diagnostics.
  */
 export function emitNumberCheck(schema, value, path, issues) {
     const parts = [
         `if(typeof ${value}!=="number"||!Number.isFinite(${value})){${emitIssue(issues, path, "expected_number", "number", `a(${value})`)}return;}`
     ];
     const checks = schema.checks;
+    /*
+     * Bounds and integer diagnostics are emitted only after the finite-number
+     * guard, so generated code never compares non-number values to bounds.
+     */
     for (let index = 0; index < checks.length; index += 1) {
         const check = checks[index];
         if (check === undefined) {
@@ -64,10 +326,179 @@ export function emitNumberCheck(schema, value, path, issues) {
     }
     return parts.join("");
 }
+/**
+ * @brief emit number check at one appended path segment.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param schema Number schema with scalar checks.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param segmentExpression Generated expression for the appended path segment.
+ * @param issues Generated expression for the issue buffer.
+ * @returns JavaScript source for one-segment number diagnostics.
+ */
+function emitNumberCheckAtSegment(schema, value, path, segmentExpression, issues) {
+    const checks = schema.checks;
+    if (checks.length === 0) {
+        /*
+         * Plain number schemas need only the finite-number guard. Emitting an
+         * else block would add cold code with no diagnostic work.
+         */
+        return `if(typeof ${value}!=="number"||!Number.isFinite(${value})){${emitIssueAtSegment(issues, path, segmentExpression, "expected_number", "number", `a(${value})`)}}`;
+    }
+    const parts = [
+        `if(typeof ${value}!=="number"||!Number.isFinite(${value})){${emitIssueAtSegment(issues, path, segmentExpression, "expected_number", "number", `a(${value})`)}}else{`
+    ];
+    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(`if(!Number.isInteger(${value})){${emitIssueExprAtSegment(issues, path, segmentExpression, "expected_integer", stringLiteral("integer"), stringLiteral("number"))}}`);
+                break;
+            case NumberCheckTag.Gte:
+                parts.push(`if(${value}<${String(check.value)}){${emitIssueAtSegment(issues, path, segmentExpression, "expected_gte", `>= ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+            case NumberCheckTag.Lte:
+                parts.push(`if(${value}>${String(check.value)}){${emitIssueAtSegment(issues, path, segmentExpression, "expected_lte", `<= ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+        }
+    }
+    parts.push("}");
+    return parts.join("");
+}
+/**
+ * @brief emit number check at two appended path segments.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param schema Number schema with scalar checks.
+ * @param value Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param firstSegmentExpression Generated expression for the parent segment.
+ * @param secondSegmentExpression Generated expression for the child segment.
+ * @param issues Generated expression for the issue buffer.
+ * @returns JavaScript source for two-segment number diagnostics.
+ */
+function emitNumberCheckAtTwoSegments(schema, value, path, firstSegmentExpression, secondSegmentExpression, issues) {
+    const checks = schema.checks;
+    if (checks.length === 0) {
+        return `if(typeof ${value}!=="number"||!Number.isFinite(${value})){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_number", "number", `a(${value})`)}}`;
+    }
+    const parts = [
+        `if(typeof ${value}!=="number"||!Number.isFinite(${value})){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_number", "number", `a(${value})`)}}else{`
+    ];
+    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(`if(!Number.isInteger(${value})){${emitIssueExprAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_integer", stringLiteral("integer"), stringLiteral("number"))}}`);
+                break;
+            case NumberCheckTag.Gte:
+                parts.push(`if(${value}<${String(check.value)}){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_gte", `>= ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+            case NumberCheckTag.Lte:
+                parts.push(`if(${value}>${String(check.value)}){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_lte", `<= ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+        }
+    }
+    parts.push("}");
+    return parts.join("");
+}
 /**
  * @brief emit literal check.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param value Literal expected by the schema.
+ * @param checked Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns JavaScript source for root literal diagnostics.
  */
 export function emitLiteralCheck(value, checked, path, issues, context) {
     const index = pushLiteral(context, value);
+    /*
+     * Object.is preserves JavaScript literal edge cases such as NaN and -0.
+     * The expected value stays in the literal side table rather than source text.
+     */
     return `if(!Object.is(${checked},l[${String(index)}])){${emitIssueExpr(issues, path, "expected_literal", `le(l[${String(index)}])`, `a(${checked})`)}}`;
 }
+/**
+ * @brief emit literal check at one appended path segment.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param value Literal expected by the schema.
+ * @param checked Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param segmentExpression Generated expression for the appended path segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns JavaScript source for one-segment literal diagnostics.
+ */
+function emitLiteralCheckAtSegment(value, checked, path, segmentExpression, issues, context) {
+    const index = pushLiteral(context, value);
+    return `if(!Object.is(${checked},l[${String(index)}])){${emitIssueExprAtSegment(issues, path, segmentExpression, "expected_literal", `le(l[${String(index)}])`, `a(${checked})`)}}`;
+}
+/**
+ * @brief emit literal check at two appended path segments.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param value Literal expected by the schema.
+ * @param checked Generated expression for the candidate value.
+ * @param path Generated expression for the current diagnostic path.
+ * @param firstSegmentExpression Generated expression for the parent segment.
+ * @param secondSegmentExpression Generated expression for the child segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns JavaScript source for two-segment literal diagnostics.
+ */
+function emitLiteralCheckAtTwoSegments(value, checked, path, firstSegmentExpression, secondSegmentExpression, issues, context) {
+    const index = pushLiteral(context, value);
+    return `if(!Object.is(${checked},l[${String(index)}])){${emitIssueExprAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_literal", `le(l[${String(index)}])`, `a(${checked})`)}}`;
+}
+/**
+ * @brief emit undefined literal check at one appended path segment.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param value Literal expected by the schema.
+ * @param path Generated expression for the current diagnostic path.
+ * @param segmentExpression Generated expression for the appended path segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Empty source when undefined is the expected literal, otherwise an issue.
+ */
+function emitUndefinedLiteralCheckAtSegment(value, path, segmentExpression, issues, context) {
+    if (value === undefined) {
+        /*
+         * A sparse hole has already produced the exact expected literal. There is
+         * no diagnostic work left to emit.
+         */
+        return "";
+    }
+    const index = pushLiteral(context, value);
+    return emitIssueExprAtSegment(issues, path, segmentExpression, "expected_literal", `le(l[${String(index)}])`, stringLiteral("undefined"));
+}
+/**
+ * @brief emit undefined literal check at two appended path segments.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param value Literal expected by the schema.
+ * @param path Generated expression for the current diagnostic path.
+ * @param firstSegmentExpression Generated expression for the parent segment.
+ * @param secondSegmentExpression Generated expression for the child segment.
+ * @param issues Generated expression for the issue buffer.
+ * @param context Shared code-generation context.
+ * @returns Empty source when undefined is the expected literal, otherwise an issue.
+ */
+function emitUndefinedLiteralCheckAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, context) {
+    if (value === undefined) {
+        return "";
+    }
+    const index = pushLiteral(context, value);
+    return emitIssueExprAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_literal", `le(l[${String(index)}])`, stringLiteral("undefined"));
+}

package/dist/compile/check.d.ts

@@ -1,15 +1,27 @@
 /**
  * @file compile/check.ts
  * @brief Diagnostic validator function table emitter.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
  */
 import type { Schema } from "../schema/index.js";
 import type { EmitContext } from "./types.js";
 /**
  * @brief emit check function.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param schema Schema whose diagnostics should be emitted.
+ * @param context Shared code-generation context.
+ * @returns Generated diagnostic function name.
+ * @invariant The same schema object maps to one diagnostic function per bundle.
  */
 export declare function emitCheckFunction(schema: Schema, context: EmitContext): string;
 /**
  * @brief emit check functions.
+ * @details Generated-source helpers keep the side-table ABI and JavaScript source shape
+ * stable across runtime and AOT emission.
+ * @param context Shared code-generation context with accumulated check sources.
+ * @returns Concatenated JavaScript function declarations.
  */
 export declare function emitCheckFunctions(context: EmitContext): string;
 //# sourceMappingURL=check.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/compile/check.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAgBjD,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,YAAY,CAAC;AAE9D;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,MAAM,CAc9E;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAU/D"}
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/compile/check.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAgBjD,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,YAAY,CAAC;AAE9D;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,GAAG,MAAM,CAkB9E;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAU/D"}