typesea 0.1.0 → 0.3.0

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 { DateCheckTag, NumberCheckTag, SchemaTag, StringCheckTag } from "../kind/index.js";
+import { EMAIL_PATTERN, IPV4_PATTERN, IPV6_PATTERN, ISO_DATETIME_PATTERN, ISO_DATE_PATTERN, ULID_PATTERN, URL_PATTERN, 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) {
@@ -33,18 +48,374 @@ export function emitStringCheck(schema, value, path, issues, context) {
             case StringCheckTag.Uuid:
                 parts.push(emitPatternIssue(value, path, issues, UUID_PATTERN, "uuid", context));
                 break;
+            case StringCheckTag.Email:
+                parts.push(emitPatternIssue(value, path, issues, EMAIL_PATTERN, "email", context));
+                break;
+            case StringCheckTag.Url:
+                parts.push(emitPatternIssue(value, path, issues, URL_PATTERN, "url", context));
+                break;
+            case StringCheckTag.IsoDate:
+                parts.push(emitPatternIssue(value, path, issues, ISO_DATE_PATTERN, "iso_date", context));
+                break;
+            case StringCheckTag.IsoDateTime:
+                parts.push(emitPatternIssue(value, path, issues, ISO_DATETIME_PATTERN, "iso_datetime", context));
+                break;
+            case StringCheckTag.Ulid:
+                parts.push(emitPatternIssue(value, path, issues, ULID_PATTERN, "ulid", context));
+                break;
+            case StringCheckTag.Ipv4:
+                parts.push(emitPatternIssue(value, path, issues, IPV4_PATTERN, "ipv4", context));
+                break;
+            case StringCheckTag.Ipv6:
+                parts.push(emitPatternIssue(value, path, issues, IPV6_PATTERN, "ipv6", context));
+                break;
+        }
+    }
+    return parts.join("");
+}
+/**
+ * @brief Emit Date diagnostics.
+ * @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 Date diagnostics.
+ */
+export function emitDateCheck(schema, value, path, issues) {
+    const invalid = `!dg(${value})`;
+    const checks = schema.checks;
+    if (checks.length === 0) {
+        return `if(${invalid}){${emitIssue(issues, path, "expected_date", "valid Date", `a(${value})`)}}`;
+    }
+    const parts = [`if(${invalid}){${emitIssue(issues, path, "expected_date", "valid Date", `a(${value})`)}}else{`];
+    for (let index = 0; index < checks.length; index += 1) {
+        const check = checks[index];
+        if (check === undefined) {
+            continue;
+        }
+        const actual = `new Date(dt(${value})).toISOString()`;
+        switch (check.tag) {
+            case DateCheckTag.Min:
+                parts.push(`if(dt(${value})<${String(check.value)}){${emitIssue(issues, path, "expected_gte", `>= ${new Date(check.value).toISOString()}`, actual)}}`);
+                break;
+            case DateCheckTag.Max:
+                parts.push(`if(dt(${value})>${String(check.value)}){${emitIssue(issues, path, "expected_lte", `<= ${new Date(check.value).toISOString()}`, actual)}}`);
+                break;
+        }
+    }
+    parts.push("}");
+    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.Date:
+            if (schema.checks.length !== 0) {
+                return undefined;
+            }
+            return `if(!dg(${value})){${emitIssueAtSegment(issues, path, segmentExpression, "expected_date", "valid Date", `a(${value})`)}}`;
+        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.Date:
+            return emitIssueAtSegment(issues, path, segmentExpression, "expected_date", "valid Date", 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.Date:
+            if (schema.checks.length !== 0) {
+                return undefined;
+            }
+            return `if(!dg(${value})){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_date", "valid Date", `a(${value})`)}}`;
+        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.Date:
+            return emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_date", "valid Date", 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;
+            case StringCheckTag.Email:
+                parts.push(emitPatternIssueAtSegment(value, path, segmentExpression, issues, EMAIL_PATTERN, "email", context));
+                break;
+            case StringCheckTag.Url:
+                parts.push(emitPatternIssueAtSegment(value, path, segmentExpression, issues, URL_PATTERN, "url", context));
+                break;
+            case StringCheckTag.IsoDate:
+                parts.push(emitPatternIssueAtSegment(value, path, segmentExpression, issues, ISO_DATE_PATTERN, "iso_date", context));
+                break;
+            case StringCheckTag.IsoDateTime:
+                parts.push(emitPatternIssueAtSegment(value, path, segmentExpression, issues, ISO_DATETIME_PATTERN, "iso_datetime", context));
+                break;
+            case StringCheckTag.Ulid:
+                parts.push(emitPatternIssueAtSegment(value, path, segmentExpression, issues, ULID_PATTERN, "ulid", context));
+                break;
+            case StringCheckTag.Ipv4:
+                parts.push(emitPatternIssueAtSegment(value, path, segmentExpression, issues, IPV4_PATTERN, "ipv4", context));
+                break;
+            case StringCheckTag.Ipv6:
+                parts.push(emitPatternIssueAtSegment(value, path, segmentExpression, issues, IPV6_PATTERN, "ipv6", 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;
+            case StringCheckTag.Email:
+                parts.push(emitPatternIssueAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, EMAIL_PATTERN, "email", context));
+                break;
+            case StringCheckTag.Url:
+                parts.push(emitPatternIssueAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, URL_PATTERN, "url", context));
+                break;
+            case StringCheckTag.IsoDate:
+                parts.push(emitPatternIssueAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, ISO_DATE_PATTERN, "iso_date", context));
+                break;
+            case StringCheckTag.IsoDateTime:
+                parts.push(emitPatternIssueAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, ISO_DATETIME_PATTERN, "iso_datetime", context));
+                break;
+            case StringCheckTag.Ulid:
+                parts.push(emitPatternIssueAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, ULID_PATTERN, "ulid", context));
+                break;
+            case StringCheckTag.Ipv4:
+                parts.push(emitPatternIssueAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, IPV4_PATTERN, "ipv4", context));
+                break;
+            case StringCheckTag.Ipv6:
+                parts.push(emitPatternIssueAtTwoSegments(value, path, firstSegmentExpression, secondSegmentExpression, issues, IPV6_PATTERN, "ipv6", 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) {
@@ -60,14 +431,210 @@ export function emitNumberCheck(schema, value, path, issues) {
             case NumberCheckTag.Lte:
                 parts.push(`if(${value}>${String(check.value)}){${emitIssue(issues, path, "expected_lte", `<= ${String(check.value)}`, `String(${value})`)}}`);
                 break;
+            case NumberCheckTag.Gt:
+                parts.push(`if(${value}<=${String(check.value)}){${emitIssue(issues, path, "expected_gt", `> ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+            case NumberCheckTag.Lt:
+                parts.push(`if(${value}>=${String(check.value)}){${emitIssue(issues, path, "expected_lt", `< ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+            case NumberCheckTag.MultipleOf:
+                parts.push(`if(${value}%${String(check.value)}!==0){${emitIssue(issues, path, "expected_multiple_of", `multiple of ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+        }
+    }
+    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;
+            case NumberCheckTag.Gt:
+                parts.push(`if(${value}<=${String(check.value)}){${emitIssueAtSegment(issues, path, segmentExpression, "expected_gt", `> ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+            case NumberCheckTag.Lt:
+                parts.push(`if(${value}>=${String(check.value)}){${emitIssueAtSegment(issues, path, segmentExpression, "expected_lt", `< ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+            case NumberCheckTag.MultipleOf:
+                parts.push(`if(${value}%${String(check.value)}!==0){${emitIssueAtSegment(issues, path, segmentExpression, "expected_multiple_of", `multiple of ${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;
+            case NumberCheckTag.Gt:
+                parts.push(`if(${value}<=${String(check.value)}){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_gt", `> ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+            case NumberCheckTag.Lt:
+                parts.push(`if(${value}>=${String(check.value)}){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_lt", `< ${String(check.value)}`, `String(${value})`)}}`);
+                break;
+            case NumberCheckTag.MultipleOf:
+                parts.push(`if(${value}%${String(check.value)}!==0){${emitIssueAtTwoSegments(issues, path, firstSegmentExpression, secondSegmentExpression, "expected_multiple_of", `multiple of ${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;AAiBjD,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"}