typesea 0.1.0

package/dist/optimize/rewrite.js

@@ -0,0 +1,34 @@
+/**
+ * @file rewrite.ts
+ * @brief Node dependency rewrite utilities.
+ */
+import { mapNodeIds } from "./map-node.js";
+/**
+ * @brief rewrite node deps.
+ * @details Resolves dependency aliases while preserving the node's own id.
+ * @param node Borrowed graph node to rewrite.
+ * @param aliases Borrowed alias table produced by the folding pass.
+ * @returns Graph node with dependency ids rewritten through the alias table.
+ */
+export function rewriteNodeDeps(node, aliases) {
+    return mapNodeIds(node, (value) => resolveAlias(value, aliases), node.id);
+}
+/**
+ * @brief resolve alias.
+ * @details Follows an alias chain until it reaches a stable node id.
+ * @param value Borrowed node id to resolve.
+ * @param aliases Borrowed alias table.
+ * @returns Canonical node id for the current folding pass.
+ */
+export function resolveAlias(value, aliases) {
+    let current = value;
+    let next = aliases[current];
+    while (next !== undefined && next !== current) {
+        current = next;
+        next = aliases[current];
+    }
+    if (next === undefined) {
+        throw new Error("Graph alias points outside graph");
+    }
+    return current;
+}

package/dist/plan/cache.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @file cache.ts
+ * @brief Validation plan cache.
+ */
+import type { Schema } from "../schema/index.js";
+import type { ValidationPlan } from "./types.js";
+/**
+ * @brief make validation plan.
+ * @details Lowers a schema into Sea-of-Nodes IR, runs the optimizer, and caches
+ * the resulting graph for all runtime users of the schema.
+ * @returns Cached or freshly built validation plan for the schema identity.
+ */
+export declare function makeValidationPlan(schema: Schema): ValidationPlan;
+/**
+ * @brief schema requires tracking.
+ * @details Returns true only for schemas that can recurse through `lazy`.
+ * @returns True when active schema/value pair tracking is required.
+ */
+export declare function schemaRequiresTracking(schema: Schema): boolean;
+//# sourceMappingURL=cache.d.ts.map

package/dist/plan/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/plan/cache.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAgBjD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAYjE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAQ9D"}

package/dist/plan/cache.js

@@ -0,0 +1,122 @@
+/**
+ * @file cache.ts
+ * @brief Validation plan cache.
+ */
+import { lowerSchema } from "../lower/index.js";
+import { SchemaTag } from "../kind/index.js";
+import { optimizeGraph } from "../optimize/index.js";
+/**
+ * @brief plan cache.
+ * @details Weakly keys plans by immutable schema identity without extending schema lifetime.
+ * @invariant A cached plan always belongs to the exact schema object used as the key.
+ */
+const planCache = new WeakMap();
+/**
+ * @brief tracking cache.
+ * @details Stores whether a schema can re-enter itself through lazy recursion.
+ * @invariant `true` means validation must use active schema/value pair tracking.
+ */
+const trackingCache = new WeakMap();
+/**
+ * @brief make validation plan.
+ * @details Lowers a schema into Sea-of-Nodes IR, runs the optimizer, and caches
+ * the resulting graph for all runtime users of the schema.
+ * @returns Cached or freshly built validation plan for the schema identity.
+ */
+export function makeValidationPlan(schema) {
+    const cached = planCache.get(schema);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const plan = Object.freeze({
+        schema,
+        graph: optimizeGraph(lowerSchema(schema)),
+        tracksRecursion: schemaRequiresTracking(schema)
+    });
+    planCache.set(schema, plan);
+    return plan;
+}
+/**
+ * @brief schema requires tracking.
+ * @details Returns true only for schemas that can recurse through `lazy`.
+ * @returns True when active schema/value pair tracking is required.
+ */
+export function schemaRequiresTracking(schema) {
+    const cached = trackingCache.get(schema);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = schemaRequiresTrackingInner(schema, new WeakSet());
+    trackingCache.set(schema, result);
+    return result;
+}
+/**
+ * @brief schema requires tracking inner.
+ */
+function schemaRequiresTrackingInner(schema, seen) {
+    if (seen.has(schema)) {
+        return false;
+    }
+    seen.add(schema);
+    switch (schema.tag) {
+        case SchemaTag.Lazy:
+            return true;
+        case SchemaTag.Array:
+            return schemaRequiresTrackingInner(schema.item, seen);
+        case SchemaTag.Tuple:
+            return schemaArrayRequiresTracking(schema.items, seen);
+        case SchemaTag.Record:
+            return schemaRequiresTrackingInner(schema.value, seen);
+        case SchemaTag.Object:
+            for (let index = 0; index < schema.entries.length; index += 1) {
+                const entry = schema.entries[index];
+                if (entry !== undefined &&
+                    schemaRequiresTrackingInner(entry.schema, seen)) {
+                    return true;
+                }
+            }
+            return false;
+        case SchemaTag.Union:
+            return schemaArrayRequiresTracking(schema.options, seen);
+        case SchemaTag.Intersection:
+            return schemaRequiresTrackingInner(schema.left, seen) ||
+                schemaRequiresTrackingInner(schema.right, seen);
+        case SchemaTag.Optional:
+        case SchemaTag.Undefinedable:
+        case SchemaTag.Nullable:
+        case SchemaTag.Brand:
+            return schemaRequiresTrackingInner(schema.inner, seen);
+        case SchemaTag.DiscriminatedUnion:
+            for (let index = 0; index < schema.cases.length; index += 1) {
+                const unionCase = schema.cases[index];
+                if (unionCase !== undefined &&
+                    schemaRequiresTrackingInner(unionCase.schema, seen)) {
+                    return true;
+                }
+            }
+            return false;
+        case SchemaTag.Refine:
+            return schemaRequiresTrackingInner(schema.inner, seen);
+        case SchemaTag.Unknown:
+        case SchemaTag.Never:
+        case SchemaTag.String:
+        case SchemaTag.Number:
+        case SchemaTag.BigInt:
+        case SchemaTag.Symbol:
+        case SchemaTag.Boolean:
+        case SchemaTag.Literal:
+            return false;
+    }
+}
+/**
+ * @brief schema array requires tracking.
+ */
+function schemaArrayRequiresTracking(schemas, seen) {
+    for (let index = 0; index < schemas.length; index += 1) {
+        const schema = schemas[index];
+        if (schema !== undefined && schemaRequiresTrackingInner(schema, seen)) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/plan/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file index.ts
+ * @brief Validation plan module aggregation.
+ */
+export { makeValidationPlan, schemaRequiresTracking } from "./cache.js";
+export { executeGraphPredicate, executeSchemaPredicate, executeSchemaPredicateWithState } from "./predicate.js";
+export type { ValidationPlan } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plan/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AACxE,OAAO,EACL,qBAAqB,EACrB,sBAAsB,EACtB,+BAA+B,EAChC,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/plan/index.js

@@ -0,0 +1,6 @@
+/**
+ * @file index.ts
+ * @brief Validation plan module aggregation.
+ */
+export { makeValidationPlan, schemaRequiresTracking } from "./cache.js";
+export { executeGraphPredicate, executeSchemaPredicate, executeSchemaPredicateWithState } from "./predicate.js";

package/dist/plan/predicate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @file predicate.ts
+ * @brief Sea-of-Nodes predicate executor.
+ */
+import type { Graph } from "../ir/index.js";
+import { type Schema } from "../schema/index.js";
+import { type ValidationState } from "../evaluate/state.js";
+/**
+ * @brief execute schema predicate.
+ * @details Runs one schema through its optimized Sea-of-Nodes validation plan.
+ * Dynamic schemas are resolved only at explicit lazy/refinement boundaries.
+ * @returns True when the value satisfies the schema.
+ */
+export declare function executeSchemaPredicate(schema: Schema, value: unknown): boolean;
+/**
+ * @brief execute schema predicate with state.
+ * @details Shares recursion accounting and cycle detection across nested IR nodes.
+ * @returns True when the value satisfies the schema under the borrowed state.
+ */
+export declare function executeSchemaPredicateWithState(schema: Schema, value: unknown, state: ValidationState): boolean;
+/**
+ * @brief execute graph predicate.
+ * @details Executes a frozen graph with one input value.
+ * @returns Boolean value held by the graph return node.
+ */
+export declare function executeGraphPredicate(graph: Graph, value: unknown, state: ValidationState): boolean;
+//# sourceMappingURL=predicate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate.d.ts","sourceRoot":"","sources":["../../src/plan/predicate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,KAAK,EAGN,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAEL,KAAK,MAAM,EACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAKL,KAAK,eAAe,EACrB,MAAM,sBAAsB,CAAC;AAI9B;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GACb,OAAO,CAET;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,GACrB,OAAO,CAcT;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,GACrB,OAAO,CAaT"}

package/dist/plan/predicate.js

@@ -0,0 +1,415 @@
+/**
+ * @file predicate.ts
+ * @brief Sea-of-Nodes predicate executor.
+ */
+import { NodeTag, SchemaTag } from "../kind/index.js";
+import { resolveLazySchema } from "../schema/index.js";
+import { enterValidation, leaveValidation, makeValidationState } from "../evaluate/state.js";
+import { makeValidationPlan, schemaRequiresTracking } from "./cache.js";
+import { executeSchemaKernel } from "./schema-predicate.js";
+/**
+ * @brief execute schema predicate.
+ * @details Runs one schema through its optimized Sea-of-Nodes validation plan.
+ * Dynamic schemas are resolved only at explicit lazy/refinement boundaries.
+ * @returns True when the value satisfies the schema.
+ */
+export function executeSchemaPredicate(schema, value) {
+    return executeSchemaPredicateWithState(schema, value, makeValidationState());
+}
+/**
+ * @brief execute schema predicate with state.
+ * @details Shares recursion accounting and cycle detection across nested IR nodes.
+ * @returns True when the value satisfies the schema under the borrowed state.
+ */
+export function executeSchemaPredicateWithState(schema, value, state) {
+    if (!schemaRequiresTracking(schema)) {
+        return executeSchemaPredicateInner(schema, value, state);
+    }
+    const entered = enterValidation(schema, value, state);
+    if (entered === "cycle") {
+        return true;
+    }
+    if (entered === "budget") {
+        return false;
+    }
+    const result = executeSchemaPredicateInner(schema, value, state);
+    leaveValidation(schema, value, state);
+    return result;
+}
+/**
+ * @brief execute graph predicate.
+ * @details Executes a frozen graph with one input value.
+ * @returns Boolean value held by the graph return node.
+ */
+export function executeGraphPredicate(graph, value, state) {
+    const frame = acquireGraphFrame(state, graph.nodes.length);
+    const result = evaluateNode(graph, graph.result, value, frame.values, frame.seen, frame.epoch, state);
+    releaseGraphFrame(state);
+    return result === true;
+}
+/**
+ * @brief execute schema predicate inner.
+ */
+function executeSchemaPredicateInner(schema, value, state) {
+    switch (schema.tag) {
+        case SchemaTag.Lazy:
+            return executeSchemaPredicateWithState(resolveLazySchema(schema, state.resolving), value, state);
+        case SchemaTag.Refine:
+            return executeSchemaPredicateWithState(schema.inner, value, state) &&
+                isStrictTrue(schema.predicate(value));
+        default: {
+            makeValidationPlan(schema);
+            return executeSchemaKernel(schema, value, state, executeSchemaPredicateWithState);
+        }
+    }
+}
+/**
+ * @brief evaluate node.
+ */
+function evaluateNode(graph, id, input, values, seen, epoch, state) {
+    if (seen[id] === epoch) {
+        return values[id];
+    }
+    const node = graph.nodes[id];
+    const result = node === undefined
+        ? undefined
+        : evaluateGraphNode(graph, node, input, values, seen, epoch, state);
+    values[id] = result;
+    seen[id] = epoch;
+    return result;
+}
+/**
+ * @brief evaluate graph node.
+ */
+function evaluateGraphNode(graph, node, input, values, seen, epoch, state) {
+    switch (node.tag) {
+        case NodeTag.Start:
+            return true;
+        case NodeTag.Param:
+            return input;
+        case NodeTag.Const:
+            return node.value;
+        case NodeTag.GetProp:
+            return readOwnDataValue(evaluateNode(graph, node.object, input, values, seen, epoch, state), node.key);
+        case NodeTag.IsString:
+            return typeof evaluateNode(graph, node.value, input, values, seen, epoch, state) === "string";
+        case NodeTag.IsNumber:
+            return isFiniteNumber(evaluateNode(graph, node.value, input, values, seen, epoch, state));
+        case NodeTag.IsBoolean:
+            return typeof evaluateNode(graph, node.value, input, values, seen, epoch, state) === "boolean";
+        case NodeTag.IsBigInt:
+            return typeof evaluateNode(graph, node.value, input, values, seen, epoch, state) === "bigint";
+        case NodeTag.IsSymbol:
+            return typeof evaluateNode(graph, node.value, input, values, seen, epoch, state) === "symbol";
+        case NodeTag.IsObject:
+            return isPlainRecord(evaluateNode(graph, node.value, input, values, seen, epoch, state));
+        case NodeTag.IsArray:
+            return Array.isArray(evaluateNode(graph, node.value, input, values, seen, epoch, state));
+        case NodeTag.IsUndefined:
+            return evaluateNode(graph, node.value, input, values, seen, epoch, state) === undefined;
+        case NodeTag.IsNull:
+            return evaluateNode(graph, node.value, input, values, seen, epoch, state) === null;
+        case NodeTag.IsInteger:
+            return Number.isInteger(evaluateNode(graph, node.value, input, values, seen, epoch, state));
+        case NodeTag.Not:
+            return evaluateNode(graph, node.value, input, values, seen, epoch, state) !== true;
+        case NodeTag.Equals:
+            return Object.is(evaluateNode(graph, node.left, input, values, seen, epoch, state), evaluateNode(graph, node.right, input, values, seen, epoch, state));
+        case NodeTag.Gte:
+            return compareNumber(evaluateNode(graph, node.left, input, values, seen, epoch, state), evaluateNode(graph, node.right, input, values, seen, epoch, state), true);
+        case NodeTag.Lte:
+            return compareNumber(evaluateNode(graph, node.left, input, values, seen, epoch, state), evaluateNode(graph, node.right, input, values, seen, epoch, state), false);
+        case NodeTag.StringMin:
+            return testStringBound(evaluateNode(graph, node.value, input, values, seen, epoch, state), node.bound, true);
+        case NodeTag.StringMax:
+            return testStringBound(evaluateNode(graph, node.value, input, values, seen, epoch, state), node.bound, false);
+        case NodeTag.Regex:
+            return testRegex(evaluateNode(graph, node.value, input, values, seen, epoch, state), node.regex);
+        case NodeTag.HasOwn:
+            return hasOwnProperty(evaluateNode(graph, node.object, input, values, seen, epoch, state), node.key);
+        case NodeTag.HasOwnData:
+            return hasOwnDataProperty(evaluateNode(graph, node.object, input, values, seen, epoch, state), node.key);
+        case NodeTag.StrictKeys:
+            return testStrictKeys(evaluateNode(graph, node.object, input, values, seen, epoch, state), node.keys);
+        case NodeTag.ArrayEvery:
+            return testArrayEvery(evaluateNode(graph, node.value, input, values, seen, epoch, state), node.item, state);
+        case NodeTag.TupleItems:
+            return testTupleItems(evaluateNode(graph, node.value, input, values, seen, epoch, state), node.items, state);
+        case NodeTag.RecordEvery:
+            return testRecordEvery(evaluateNode(graph, node.value, input, values, seen, epoch, state), node.item, state);
+        case NodeTag.DiscriminantDispatch:
+            return testDiscriminantDispatch(evaluateNode(graph, node.value, input, values, seen, epoch, state), node.key, node.schemas, node.lookup, state);
+        case NodeTag.SchemaCheck:
+            return executeSchemaPredicateWithState(node.schema, evaluateNode(graph, node.value, input, values, seen, epoch, state), state);
+        case NodeTag.And:
+            return evaluateAnd(graph, node.values, input, values, seen, epoch, state);
+        case NodeTag.Or:
+            return evaluateOr(graph, node.values, input, values, seen, epoch, state);
+        case NodeTag.Return:
+            return evaluateNode(graph, node.value, input, values, seen, epoch, state);
+    }
+}
+/**
+ * @brief evaluate and.
+ */
+function evaluateAnd(graph, ids, input, values, seen, epoch, state) {
+    for (let index = 0; index < ids.length; index += 1) {
+        const id = ids[index];
+        if (id === undefined ||
+            evaluateNode(graph, id, input, values, seen, epoch, state) !== true) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief evaluate or.
+ */
+function evaluateOr(graph, ids, input, values, seen, epoch, state) {
+    for (let index = 0; index < ids.length; index += 1) {
+        const id = ids[index];
+        if (id !== undefined &&
+            evaluateNode(graph, id, input, values, seen, epoch, state) === true) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @brief test array every.
+ */
+function testArrayEvery(value, item, state) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const slot = readArrayIndexValue(value, index);
+        if (slot.accessor ||
+            !executeSchemaPredicateWithState(item, slot.value, state)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief test tuple items.
+ */
+function testTupleItems(value, items, state) {
+    if (!Array.isArray(value) || value.length !== items.length) {
+        return false;
+    }
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (item === undefined) {
+            return false;
+        }
+        const slot = readArrayIndexValue(value, index);
+        if (slot.accessor ||
+            !executeSchemaPredicateWithState(item, slot.value, state)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief test record every.
+ */
+function testRecordEvery(value, item, state) {
+    if (!isPlainRecord(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (key === undefined) {
+            return false;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (descriptor === undefined ||
+            !Object.prototype.hasOwnProperty.call(descriptor, "value") ||
+            !executeSchemaPredicateWithState(item, descriptor.value, state)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief test discriminant dispatch.
+ */
+function testDiscriminantDispatch(value, key, schemas, lookup, state) {
+    if (!isPlainRecord(value)) {
+        return false;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined ||
+        !Object.prototype.hasOwnProperty.call(descriptor, "value") ||
+        typeof descriptor.value !== "string") {
+        return false;
+    }
+    const index = Object.prototype.hasOwnProperty.call(lookup, descriptor.value)
+        ? lookup[descriptor.value]
+        : undefined;
+    if (index === undefined) {
+        return false;
+    }
+    const schema = schemas[index];
+    return schema !== undefined &&
+        executeSchemaPredicateWithState(schema, value, state);
+}
+/**
+ * @brief read array index value.
+ */
+function readArrayIndexValue(value, index) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (descriptor === undefined) {
+        return {
+            accessor: false,
+            value: undefined
+        };
+    }
+    if (!Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+        return {
+            accessor: true,
+            value: undefined
+        };
+    }
+    return {
+        accessor: false,
+        value: descriptor.value
+    };
+}
+/**
+ * @brief read own data value.
+ */
+function readOwnDataValue(value, key) {
+    if (!isPropertyHost(value)) {
+        return undefined;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === undefined ||
+        !Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+        return undefined;
+    }
+    return descriptor.value;
+}
+/**
+ * @brief has own property.
+ */
+function hasOwnProperty(value, key) {
+    return isPropertyHost(value) &&
+        Object.prototype.hasOwnProperty.call(value, key);
+}
+/**
+ * @brief has own data property.
+ */
+function hasOwnDataProperty(value, key) {
+    if (!isPropertyHost(value)) {
+        return false;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== undefined &&
+        Object.prototype.hasOwnProperty.call(descriptor, "value");
+}
+/**
+ * @brief test strict keys.
+ */
+function testStrictKeys(value, keys) {
+    if (!isPlainRecord(value)) {
+        return false;
+    }
+    const present = Reflect.ownKeys(value);
+    for (let index = 0; index < present.length; index += 1) {
+        const key = present[index];
+        if (typeof key !== "string" || !keys.includes(key)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief compare number.
+ */
+function compareNumber(left, right, gte) {
+    if (typeof left !== "number" || typeof right !== "number") {
+        return false;
+    }
+    return gte ? left >= right : left <= right;
+}
+/**
+ * @brief test string bound.
+ */
+function testStringBound(value, bound, min) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    return min ? value.length >= bound : value.length <= bound;
+}
+/**
+ * @brief test regex.
+ */
+function testRegex(value, regex) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    regex.lastIndex = 0;
+    const result = regex.test(value);
+    regex.lastIndex = 0;
+    return result;
+}
+/**
+ * @brief is finite number.
+ */
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+/**
+ * @brief is plain record.
+ */
+function isPlainRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * @brief is property host.
+ */
+function isPropertyHost(value) {
+    return (typeof value === "object" && value !== null) || typeof value === "function";
+}
+/**
+ * @brief acquire graph frame.
+ */
+function acquireGraphFrame(state, nodeCount) {
+    const index = state.graphDepth;
+    state.graphDepth = index + 1;
+    let frame = state.graphFrames[index];
+    if (frame === undefined) {
+        frame = {
+            values: new Array(nodeCount),
+            seen: new Uint32Array(nodeCount),
+            epoch: 0
+        };
+        state.graphFrames[index] = frame;
+    }
+    else if (frame.seen.length < nodeCount) {
+        frame.values = new Array(nodeCount);
+        frame.seen = new Uint32Array(nodeCount);
+        frame.epoch = 0;
+    }
+    frame.epoch += 1;
+    if (frame.epoch === 0) {
+        frame.seen.fill(0);
+        frame.epoch = 1;
+    }
+    return frame;
+}
+/**
+ * @brief release graph frame.
+ */
+function releaseGraphFrame(state) {
+    state.graphDepth -= 1;
+}
+/**
+ * @brief is strict true.
+ */
+function isStrictTrue(value) {
+    return value === true;
+}

package/dist/plan/schema-predicate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file schema-predicate.ts
+ * @brief Schema-specialized predicate kernels for validation plans.
+ */
+import { type Schema } from "../schema/index.js";
+import type { ValidationState } from "../evaluate/state.js";
+/**
+ * @brief child predicate runner.
+ */
+export type ChildPredicateRunner = (schema: Schema, value: unknown, state: ValidationState) => boolean;
+/**
+ * @brief execute schema kernel.
+ */
+export declare function executeSchemaKernel(schema: Schema, value: unknown, state: ValidationState, runChild: ChildPredicateRunner): boolean;
+//# sourceMappingURL=schema-predicate.d.ts.map

package/dist/plan/schema-predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-predicate.d.ts","sourceRoot":"","sources":["../../src/plan/schema-predicate.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,EAIL,KAAK,MAAM,EACZ,MAAM,oBAAoB,CAAC;AAS5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,KACnB,OAAO,CAAC;AAEb;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,eAAe,EACtB,QAAQ,EAAE,oBAAoB,GAC7B,OAAO,CAoDT"}