typesea 0.1.0

package/dist/evaluate/check-composite.js

@@ -0,0 +1,184 @@
+/**
+ * @file check-composite.ts
+ * @brief Composite diagnostic schema interpreters.
+ */
+import { ObjectModeTag, PresenceTag, SchemaTag } from "../kind/index.js";
+import { pushIssue } from "./issue.js";
+import { actualType, findDiscriminatedUnionCase, hasObjectKey, isDataPropertyDescriptor, isPlainRecord, isStrictTrue, literalToExpected, readOwnDataProperty } from "./shared.js";
+/**
+ * @brief collect array issues.
+ */
+export function collectArrayIssues(item, value, path, issues, state, collectChild) {
+    if (!Array.isArray(value)) {
+        pushIssue(path, issues, "expected_array", "array", actualType(value));
+        return;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const itemProperty = readArrayIndexDataProperty(value, index);
+        path.push(index);
+        if (itemProperty === null) {
+            pushIssue(path, issues, "expected_array", "data property", "accessor");
+        }
+        else {
+            collectChild(item, itemProperty === undefined ? undefined : itemProperty.value, path, issues, state);
+        }
+        path.pop();
+    }
+}
+/**
+ * @brief collect tuple issues.
+ */
+export function collectTupleIssues(items, value, path, issues, state, collectChild) {
+    if (!Array.isArray(value)) {
+        pushIssue(path, issues, "expected_tuple", "tuple", actualType(value));
+        return;
+    }
+    if (value.length !== items.length) {
+        pushIssue(path, issues, "expected_tuple_length", `length ${String(items.length)}`, `length ${String(value.length)}`);
+    }
+    const count = value.length < items.length ? value.length : items.length;
+    for (let index = 0; index < count; index += 1) {
+        const item = items[index];
+        if (item === undefined) {
+            continue;
+        }
+        const itemValue = readArrayIndexDataProperty(value, index);
+        path.push(index);
+        if (itemValue === null) {
+            pushIssue(path, issues, "expected_tuple", "data property", "accessor");
+        }
+        else {
+            collectChild(item, itemValue === undefined ? undefined : itemValue.value, path, issues, state);
+        }
+        path.pop();
+    }
+}
+/**
+ * @brief read array index data property.
+ * @details Reads an array element through its descriptor so validation does not execute getters.
+ * @returns Data descriptor for elements, undefined for holes, and null for accessors.
+ */
+function readArrayIndexDataProperty(value, index) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (descriptor === undefined) {
+        return undefined;
+    }
+    if (!isDataPropertyDescriptor(descriptor)) {
+        return null;
+    }
+    return descriptor;
+}
+/**
+ * @brief collect record issues.
+ */
+export function collectRecordIssues(item, value, path, issues, state, collectChild) {
+    if (!isPlainRecord(value)) {
+        pushIssue(path, issues, "expected_record", "record", actualType(value));
+        return;
+    }
+    const keys = Object.keys(value);
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (key === undefined) {
+            continue;
+        }
+        const property = readOwnDataProperty(value, key);
+        path.push(key);
+        if (property === undefined) {
+            pushIssue(path, issues, "expected_record", "data property", "accessor or missing");
+        }
+        else {
+            collectChild(item, property.value, path, issues, state);
+        }
+        path.pop();
+    }
+}
+/**
+ * @brief collect object issues.
+ */
+export function collectObjectIssues(schema, value, path, issues, state, collectChild) {
+    if (!isPlainRecord(value)) {
+        pushIssue(path, issues, "expected_object", "object", actualType(value));
+        return;
+    }
+    const record = value;
+    const entries = schema.entries;
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry === undefined) {
+            continue;
+        }
+        const property = readOwnDataProperty(record, entry.key);
+        path.push(entry.key);
+        if (property === undefined) {
+            if (entry.presence === PresenceTag.Optional &&
+                !Object.prototype.hasOwnProperty.call(record, entry.key)) {
+                path.pop();
+                continue;
+            }
+            if (entry.presence === PresenceTag.Required) {
+                pushIssue(path, issues, "expected_required_key", "present key", "missing");
+            }
+            else {
+                pushIssue(path, issues, "expected_object", "data property", "accessor");
+            }
+            path.pop();
+            continue;
+        }
+        collectChild(entry.schema, property.value, path, issues, state);
+        path.pop();
+    }
+    if (schema.mode === ObjectModeTag.Strict) {
+        const keys = Reflect.ownKeys(record);
+        for (let index = 0; index < keys.length; index += 1) {
+            const key = keys[index];
+            if (key !== undefined &&
+                (typeof key !== "string" || !hasObjectKey(schema.keyLookup, key))) {
+                path.push(typeof key === "string" ? key : String(key));
+                pushIssue(path, issues, "unrecognized_key", "known key", "extra key");
+                path.pop();
+            }
+        }
+    }
+}
+/**
+ * @brief collect discriminated union issues.
+ */
+export function collectDiscriminatedUnionIssues(key, cases, value, path, issues, state, collectChild) {
+    if (!isPlainRecord(value)) {
+        pushIssue(path, issues, "expected_object", "object", actualType(value));
+        return;
+    }
+    const discriminantProperty = readOwnDataProperty(value, key);
+    if (discriminantProperty === undefined) {
+        path.push(key);
+        pushIssue(path, issues, "expected_discriminant", "data property", "missing or accessor");
+        path.pop();
+        return;
+    }
+    const discriminant = discriminantProperty.value;
+    if (typeof discriminant !== "string") {
+        path.push(key);
+        pushIssue(path, issues, "expected_discriminant", "string discriminant", actualType(discriminant));
+        path.pop();
+        return;
+    }
+    const selected = findDiscriminatedUnionCase(cases, discriminant);
+    if (selected === undefined) {
+        path.push(key);
+        pushIssue(path, issues, "expected_discriminant", "known discriminant", literalToExpected(discriminant));
+        path.pop();
+        return;
+    }
+    collectChild(selected, value, path, issues, state);
+}
+/**
+ * @brief collect refine issues.
+ */
+export function collectRefineIssues(inner, predicate, name, value, path, issues, state, collectChild) {
+    const before = issues.length;
+    collectChild(inner, value, path, issues, state);
+    if (issues.length === before && !isStrictTrue(predicate(value))) {
+        pushIssue(path, issues, "expected_refinement", name, actualType(value));
+    }
+}

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

@@ -0,0 +1,20 @@
+/**
+ * @file check-scalar.ts
+ * @brief Scalar diagnostic schema interpreters.
+ */
+import { SchemaTag } from "../kind/index.js";
+import type { Issue, PathSegment } from "../issue/index.js";
+import { type Schema } from "../schema/index.js";
+/**
+ * @brief collect string issues.
+ */
+export declare function collectStringIssues(schema: Extract<Schema, {
+    readonly tag: typeof SchemaTag.String;
+}>, value: unknown, path: PathSegment[], issues: Issue[]): void;
+/**
+ * @brief collect number issues.
+ */
+export declare function collectNumberIssues(schema: Extract<Schema, {
+    readonly tag: typeof SchemaTag.Number;
+}>, value: unknown, path: PathSegment[], issues: Issue[]): void;
+//# sourceMappingURL=check-scalar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-scalar.d.ts","sourceRoot":"","sources":["../../src/evaluate/check-scalar.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAEL,SAAS,EAEV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAEL,KAAK,MAAM,EACZ,MAAM,oBAAoB,CAAC;AAI5B;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,SAAS,CAAC,MAAM,CAAA;CAAE,CAAC,EAClE,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,WAAW,EAAE,EACnB,MAAM,EAAE,KAAK,EAAE,GACd,IAAI,CAgDN;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,OAAO,SAAS,CAAC,MAAM,CAAA;CAAE,CAAC,EAClE,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,WAAW,EAAE,EACnB,MAAM,EAAE,KAAK,EAAE,GACd,IAAI,CAyCN"}

package/dist/evaluate/check-scalar.js

@@ -0,0 +1,81 @@
+/**
+ * @file check-scalar.ts
+ * @brief Scalar diagnostic schema interpreters.
+ */
+import { NumberCheckTag, SchemaTag, StringCheckTag } from "../kind/index.js";
+import { UUID_PATTERN } from "../schema/index.js";
+import { pushIssue } from "./issue.js";
+import { actualType } from "./shared.js";
+/**
+ * @brief collect string issues.
+ */
+export function collectStringIssues(schema, value, path, issues) {
+    if (typeof value !== "string") {
+        pushIssue(path, issues, "expected_string", "string", actualType(value));
+        return;
+    }
+    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:
+                if (value.length < check.value) {
+                    pushIssue(path, issues, "expected_min_length", `length >= ${String(check.value)}`, `length ${String(value.length)}`);
+                }
+                break;
+            case StringCheckTag.Max:
+                if (value.length > check.value) {
+                    pushIssue(path, issues, "expected_max_length", `length <= ${String(check.value)}`, `length ${String(value.length)}`);
+                }
+                break;
+            case StringCheckTag.Regex:
+                check.regex.lastIndex = 0;
+                if (!check.regex.test(value)) {
+                    pushIssue(path, issues, "expected_pattern", check.name, "string");
+                }
+                break;
+            case StringCheckTag.Uuid:
+                UUID_PATTERN.lastIndex = 0;
+                if (!UUID_PATTERN.test(value)) {
+                    pushIssue(path, issues, "expected_pattern", "uuid", "string");
+                }
+                break;
+        }
+    }
+}
+/**
+ * @brief collect number issues.
+ */
+export function collectNumberIssues(schema, value, path, issues) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        pushIssue(path, issues, "expected_number", "number", actualType(value));
+        return;
+    }
+    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:
+                if (!Number.isInteger(value)) {
+                    pushIssue(path, issues, "expected_integer", "integer", "number");
+                }
+                break;
+            case NumberCheckTag.Gte:
+                if (value < check.value) {
+                    pushIssue(path, issues, "expected_gte", `>= ${String(check.value)}`, String(value));
+                }
+                break;
+            case NumberCheckTag.Lte:
+                if (value > check.value) {
+                    pushIssue(path, issues, "expected_lte", `<= ${String(check.value)}`, String(value));
+                }
+                break;
+        }
+    }
+}

package/dist/evaluate/check.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file check.ts
+ * @brief Diagnostic schema interpreter dispatcher.
+ */
+import type { CheckResult } from "../issue/index.js";
+import { type Schema } from "../schema/index.js";
+/**
+ * @brief check schema.
+ */
+export declare function checkSchema<TValue>(schema: Schema, value: unknown): CheckResult<TValue>;
+//# sourceMappingURL=check.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../../src/evaluate/check.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAsB,MAAM,mBAAmB,CAAC;AAGzE,OAAO,EAEL,KAAK,MAAM,EACZ,MAAM,oBAAoB,CAAC;AA0B5B;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAChC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GACb,WAAW,CAAC,MAAM,CAAC,CAWrB"}

package/dist/evaluate/check.js

@@ -0,0 +1,126 @@
+/**
+ * @file check.ts
+ * @brief Diagnostic schema interpreter dispatcher.
+ */
+import { SchemaTag } from "../kind/index.js";
+import { freezeIssueArray } from "../issue/index.js";
+import { err, ok } from "../result/index.js";
+import { resolveLazySchema } from "../schema/index.js";
+import { collectArrayIssues, collectDiscriminatedUnionIssues, collectObjectIssues, collectRecordIssues, collectRefineIssues, collectTupleIssues } from "./check-composite.js";
+import { collectNumberIssues, collectStringIssues } from "./check-scalar.js";
+import { pushIssue } from "./issue.js";
+import { isSchemaWithState, isUnionSchema } from "./predicate.js";
+import { actualType, literalToExpected } from "./shared.js";
+import { enterValidation, leaveValidation, makeValidationState } from "./state.js";
+/**
+ * @brief check schema.
+ */
+export function checkSchema(schema, value) {
+    if (isSchemaWithState(schema, value, makeValidationState())) {
+        return ok(value);
+    }
+    const issues = [];
+    const path = [];
+    collectIssues(schema, value, path, issues, makeValidationState());
+    if (issues.length === 0) {
+        pushIssue(path, issues, "expected_refinement", "matching schema", actualType(value));
+    }
+    return err(freezeIssueArray(issues));
+}
+/**
+ * @brief collect issues.
+ */
+function collectIssues(schema, value, path, issues, state) {
+    const entered = enterValidation(schema, value, state);
+    if (entered === "cycle") {
+        return;
+    }
+    if (entered === "budget") {
+        pushIssue(path, issues, "expected_depth_limit", `depth <= ${String(state.maxDepth)}`, "depth or work limit exceeded");
+        return;
+    }
+    collectIssuesInner(schema, value, path, issues, state);
+    leaveValidation(schema, value, state);
+}
+/**
+ * @brief collect issues inner.
+ */
+function collectIssuesInner(schema, value, path, issues, state) {
+    switch (schema.tag) {
+        case SchemaTag.Unknown:
+            return;
+        case SchemaTag.Never:
+            pushIssue(path, issues, "expected_never", "never", actualType(value));
+            return;
+        case SchemaTag.String:
+            collectStringIssues(schema, value, path, issues);
+            return;
+        case SchemaTag.Number:
+            collectNumberIssues(schema, value, path, issues);
+            return;
+        case SchemaTag.BigInt:
+            if (typeof value !== "bigint") {
+                pushIssue(path, issues, "expected_bigint", "bigint", actualType(value));
+            }
+            return;
+        case SchemaTag.Symbol:
+            if (typeof value !== "symbol") {
+                pushIssue(path, issues, "expected_symbol", "symbol", actualType(value));
+            }
+            return;
+        case SchemaTag.Boolean:
+            if (typeof value !== "boolean") {
+                pushIssue(path, issues, "expected_boolean", "boolean", actualType(value));
+            }
+            return;
+        case SchemaTag.Literal:
+            if (!Object.is(value, schema.value)) {
+                pushIssue(path, issues, "expected_literal", literalToExpected(schema.value), actualType(value));
+            }
+            return;
+        case SchemaTag.Array:
+            collectArrayIssues(schema.item, value, path, issues, state, collectIssues);
+            return;
+        case SchemaTag.Tuple:
+            collectTupleIssues(schema.items, value, path, issues, state, collectIssues);
+            return;
+        case SchemaTag.Record:
+            collectRecordIssues(schema.value, value, path, issues, state, collectIssues);
+            return;
+        case SchemaTag.Object:
+            collectObjectIssues(schema, value, path, issues, state, collectIssues);
+            return;
+        case SchemaTag.Union:
+            if (!isUnionSchema(schema.options, value, state)) {
+                pushIssue(path, issues, "expected_union", "union", actualType(value));
+            }
+            return;
+        case SchemaTag.Intersection:
+            collectIssues(schema.left, value, path, issues, state);
+            collectIssues(schema.right, value, path, issues, state);
+            return;
+        case SchemaTag.Optional:
+        case SchemaTag.Undefinedable:
+            if (value !== undefined) {
+                collectIssues(schema.inner, value, path, issues, state);
+            }
+            return;
+        case SchemaTag.Nullable:
+            if (value !== null) {
+                collectIssues(schema.inner, value, path, issues, state);
+            }
+            return;
+        case SchemaTag.DiscriminatedUnion:
+            collectDiscriminatedUnionIssues(schema.key, schema.cases, value, path, issues, state, collectIssues);
+            return;
+        case SchemaTag.Brand:
+            collectIssues(schema.inner, value, path, issues, state);
+            return;
+        case SchemaTag.Lazy:
+            collectIssues(resolveLazySchema(schema, state.resolving), value, path, issues, state);
+            return;
+        case SchemaTag.Refine:
+            collectRefineIssues(schema.inner, schema.predicate, schema.name, value, path, issues, state, collectIssues);
+            return;
+    }
+}

package/dist/evaluate/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file index.ts
+ * @brief Public evaluation module aggregation.
+ */
+export { checkSchema } from "./check.js";
+export { isSchema } from "./predicate.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/evaluate/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/evaluate/index.js

@@ -0,0 +1,6 @@
+/**
+ * @file index.ts
+ * @brief Public evaluation module aggregation.
+ */
+export { checkSchema } from "./check.js";
+export { isSchema } from "./predicate.js";

package/dist/evaluate/issue.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file issue.ts
+ * @brief Runtime validation issue construction.
+ */
+import type { Issue, PathSegment } from "../issue/index.js";
+/**
+ * @brief push issue.
+ */
+export declare function pushIssue(path: PathSegment[], issues: Issue[], code: Issue["code"], expected: string | undefined, actual: string | undefined): void;
+//# sourceMappingURL=issue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"issue.d.ts","sourceRoot":"","sources":["../../src/evaluate/issue.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAG5D;;GAEG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,WAAW,EAAE,EACnB,MAAM,EAAE,KAAK,EAAE,EACf,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,EACnB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,IAAI,CAEN"}

package/dist/evaluate/issue.js

@@ -0,0 +1,11 @@
+/**
+ * @file issue.ts
+ * @brief Runtime validation issue construction.
+ */
+import { makeIssue } from "../issue/index.js";
+/**
+ * @brief push issue.
+ */
+export function pushIssue(path, issues, code, expected, actual) {
+    issues.push(makeIssue(path.slice(), code, expected, actual, undefined));
+}

package/dist/evaluate/predicate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @file predicate.ts
+ * @brief Compatibility entry points for IR-backed predicate execution.
+ */
+import type { Schema } from "../schema/index.js";
+import type { ValidationState } from "./state.js";
+/**
+ * @brief is schema.
+ * @details Executes the schema through its optimized Sea-of-Nodes validation plan.
+ * @returns True when the input satisfies the schema.
+ */
+export declare function isSchema(schema: Schema, value: unknown): boolean;
+/**
+ * @brief is schema with state.
+ * @details Shares recursion and cycle tracking with nested IR nodes.
+ * @returns True when the input satisfies the schema under the borrowed state.
+ */
+export declare function isSchemaWithState(schema: Schema, value: unknown, state: ValidationState): boolean;
+/**
+ * @brief is union schema.
+ * @details Preserves the historical helper used by diagnostic generation while
+ * routing each union option through IR-backed validation.
+ * @returns True when at least one option accepts the value.
+ */
+export declare function isUnionSchema(options: readonly Schema[], value: unknown, state: ValidationState): boolean;
+//# sourceMappingURL=predicate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../../src/evaluate/predicate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,GACrB,OAAO,CAET;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,GACrB,OAAO,CAST"}

package/dist/evaluate/predicate.js

@@ -0,0 +1,37 @@
+/**
+ * @file predicate.ts
+ * @brief Compatibility entry points for IR-backed predicate execution.
+ */
+import { executeSchemaPredicate, executeSchemaPredicateWithState } from "../plan/index.js";
+/**
+ * @brief is schema.
+ * @details Executes the schema through its optimized Sea-of-Nodes validation plan.
+ * @returns True when the input satisfies the schema.
+ */
+export function isSchema(schema, value) {
+    return executeSchemaPredicate(schema, value);
+}
+/**
+ * @brief is schema with state.
+ * @details Shares recursion and cycle tracking with nested IR nodes.
+ * @returns True when the input satisfies the schema under the borrowed state.
+ */
+export function isSchemaWithState(schema, value, state) {
+    return executeSchemaPredicateWithState(schema, value, state);
+}
+/**
+ * @brief is union schema.
+ * @details Preserves the historical helper used by diagnostic generation while
+ * routing each union option through IR-backed validation.
+ * @returns True when at least one option accepts the value.
+ */
+export function isUnionSchema(options, value, state) {
+    for (let index = 0; index < options.length; index += 1) {
+        const option = options[index];
+        if (option !== undefined &&
+            executeSchemaPredicateWithState(option, value, state)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/evaluate/shared.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @file shared.ts
+ * @brief Shared scalar helpers for schema evaluation.
+ */
+import type { DiscriminatedUnionCase, LiteralValue, ObjectKeyLookup, Schema } from "../schema/index.js";
+/**
+ * @brief unknown record.
+ */
+export type UnknownRecord = Readonly<Record<string, unknown>>;
+/**
+ * @brief data property descriptor.
+ * @details Defines the subset of descriptors whose value is stable for one validation read.
+ * @invariant Accessor descriptors never match this contract.
+ */
+export interface DataPropertyDescriptor {
+    /**
+     * @brief value.
+     * @details The captured data slot is unknown until the schema-specific validator consumes it.
+     * @invariant Accessing this field does not execute user getter code.
+     */
+    readonly value: unknown;
+}
+/**
+ * @brief has object key.
+ */
+export declare function hasObjectKey(keyLookup: ObjectKeyLookup, key: string): boolean;
+/**
+ * @brief read own data property.
+ * @details Reads one own property through its descriptor so getters are not executed.
+ * @returns Own data descriptor, or undefined for missing/accessor properties.
+ */
+export declare function readOwnDataProperty(record: UnknownRecord, key: string): DataPropertyDescriptor | undefined;
+/**
+ * @brief find discriminated union case.
+ */
+export declare function findDiscriminatedUnionCase(cases: readonly DiscriminatedUnionCase[], value: string): Schema | undefined;
+/**
+ * @brief is strict true.
+ */
+export declare function isStrictTrue(value: unknown): boolean;
+/**
+ * @brief is plain record.
+ */
+export declare function isPlainRecord(value: unknown): value is UnknownRecord;
+/**
+ * @brief is data property descriptor.
+ * @details Checks that a descriptor contains a data value instead of getter/setter code.
+ * @returns True when the descriptor has a stable value slot.
+ */
+export declare function isDataPropertyDescriptor(descriptor: PropertyDescriptor): descriptor is DataPropertyDescriptor;
+/**
+ * @brief actual type.
+ */
+export declare function actualType(value: unknown): string;
+/**
+ * @brief literal to expected.
+ */
+export declare function literalToExpected(value: LiteralValue): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/evaluate/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/evaluate/shared.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,YAAY,EACZ,eAAe,EACf,MAAM,EACP,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAE9D;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IAErC;;;;OAIG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAE7E;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,MAAM,GACV,sBAAsB,GAAG,SAAS,CAMpC;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,sBAAsB,EAAE,EACxC,KAAK,EAAE,MAAM,GACZ,MAAM,GAAG,SAAS,CAQpB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEpD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAEpE;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,kBAAkB,GAC7B,UAAU,IAAI,sBAAsB,CAEtC;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAiBjD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAiB7D"}