typesea 0.1.0

package/dist/compile/graph-predicate.js

@@ -0,0 +1,460 @@
+/**
+ * @file graph-predicate.ts
+ * @brief Predicate source emitter backed by optimized Sea-of-Nodes graphs.
+ */
+import { NodeTag } from "../kind/index.js";
+import { makeValidationPlan } from "../plan/index.js";
+import { pushKeyset, pushLiteral, pushRegex, pushSchema, stringRef } from "./context.js";
+/**
+ * @brief emit graph function.
+ * @details Emits one predicate function from the optimized graph owned by a schema plan.
+ * @returns Generated function name.
+ */
+export function emitGraphFunction(schema, context) {
+    const cached = context.functionNames.get(schema);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const name = `p${String(context.functions.length)}`;
+    const source = {
+        name,
+        body: ""
+    };
+    context.functionNames.set(schema, name);
+    context.functions.push(source);
+    const plan = makeValidationPlan(schema);
+    source.body = emitGraphBody(plan.graph, plan.graph.result, "v", context);
+    return name;
+}
+/**
+ * @brief emit graph functions.
+ * @details Serializes every graph predicate function accumulated in the context.
+ * @returns JavaScript source for the predicate function table.
+ */
+export function emitGraphFunctions(context) {
+    const chunks = new Array(context.functions.length);
+    for (let index = 0; index < context.functions.length; index += 1) {
+        const source = context.functions[index];
+        if (source !== undefined) {
+            chunks[index] = `function ${source.name}(v){${source.body}}`;
+        }
+    }
+    return chunks.join("");
+}
+/**
+ * @brief emit graph body.
+ */
+function emitGraphBody(graph, id, value, context) {
+    const state = {
+        chunks: [],
+        dataSlots: new Map(),
+        dataGuards: new Set(),
+        temp: 0
+    };
+    emitGraphReturn(graph, id, value, context, state);
+    return state.chunks.join("");
+}
+/**
+ * @brief emit graph return.
+ */
+function emitGraphReturn(graph, id, value, context, state) {
+    const node = graph.nodes[id];
+    if (node === undefined) {
+        state.chunks.push("return false;");
+        return;
+    }
+    switch (node.tag) {
+        case NodeTag.Return:
+            emitGraphReturn(graph, node.value, value, context, state);
+            return;
+        case NodeTag.And:
+            emitAndReturn(graph, node.values, value, context, state);
+            return;
+        case NodeTag.Or:
+            emitOrReturn(graph, node.values, value, context, state);
+            return;
+        case NodeTag.DiscriminantDispatch:
+            emitDiscriminantDispatchReturn(graph, node.value, value, node.key, node.literals, node.schemas, context, state);
+            return;
+        default:
+            state.chunks.push(`return ${emitGraphExpression(graph, id, value, context, state)};`);
+    }
+}
+/**
+ * @brief emit and return.
+ */
+function emitAndReturn(graph, ids, value, context, state) {
+    for (let index = 0; index < ids.length; index += 1) {
+        const id = ids[index];
+        if (id !== undefined) {
+            emitFalseCheck(graph, id, value, context, state);
+        }
+    }
+    state.chunks.push("return true;");
+}
+/**
+ * @brief emit false check.
+ */
+function emitFalseCheck(graph, id, value, context, state) {
+    const node = graph.nodes[id];
+    if (node?.tag === NodeTag.And) {
+        for (let index = 0; index < node.values.length; index += 1) {
+            const child = node.values[index];
+            if (child !== undefined) {
+                emitFalseCheck(graph, child, value, context, state);
+            }
+        }
+        return;
+    }
+    if (node?.tag === NodeTag.ArrayEvery) {
+        emitArrayEveryCheck(graph, node.value, node.item, value, context, state);
+        return;
+    }
+    if (node?.tag === NodeTag.RecordEvery) {
+        emitRecordEveryCheck(graph, node.value, node.item, value, context, state);
+        return;
+    }
+    if (node?.tag === NodeTag.HasOwnData) {
+        emitHasDataCheck(graph, node.object, node.key, value, context, state);
+        return;
+    }
+    if (node?.tag === NodeTag.StrictKeys) {
+        emitStrictKeysCheck(graph, node.object, node.keys, value, context, state);
+        return;
+    }
+    state.chunks.push(`if(!${emitGraphExpression(graph, id, value, context, state)})return false;`);
+}
+/**
+ * @brief emit array every check.
+ */
+function emitArrayEveryCheck(graph, valueId, item, value, context, state) {
+    const arrayExpression = emitGraphExpression(graph, valueId, value, context, state);
+    const index = `i${String(state.temp)}`;
+    state.temp += 1;
+    const descriptor = `d${String(state.temp)}`;
+    state.temp += 1;
+    const itemValue = `v${String(state.temp)}`;
+    state.temp += 1;
+    state.chunks.push(`for(let ${index}=0;${index}<${arrayExpression}.length;${index}+=1){`, `const ${descriptor}=gp(${arrayExpression},${index});`, `if(${descriptor}!==undefined&&!h.call(${descriptor},"value"))return false;`, `const ${itemValue}=${descriptor}===undefined?undefined:${descriptor}.value;`, `if(!${emitInlineSchemaExpression(item, itemValue, context)})return false;`, "}");
+}
+/**
+ * @brief emit record every check.
+ */
+function emitRecordEveryCheck(graph, valueId, item, value, context, state) {
+    const recordExpression = emitGraphExpression(graph, valueId, value, context, state);
+    const keys = `ks${String(state.temp)}`;
+    state.temp += 1;
+    const index = `i${String(state.temp)}`;
+    state.temp += 1;
+    const key = `key${String(state.temp)}`;
+    state.temp += 1;
+    const descriptor = `d${String(state.temp)}`;
+    state.temp += 1;
+    const itemValue = `v${String(state.temp)}`;
+    state.temp += 1;
+    state.chunks.push(`const ${keys}=Object.keys(${recordExpression});`, `for(let ${index}=0;${index}<${keys}.length;${index}+=1){`, `const ${key}=${keys}[${index}];`, `if(${key}===undefined)return false;`, `const ${descriptor}=gp(${recordExpression},${key});`, `if(${descriptor}===undefined||!h.call(${descriptor},"value"))return false;`, `const ${itemValue}=${descriptor}.value;`, `if(!${emitInlineSchemaExpression(item, itemValue, context)})return false;`, "}");
+}
+/**
+ * @brief emit strict keys check.
+ */
+function emitStrictKeysCheck(graph, object, keys, value, context, state) {
+    const objectExpression = emitGraphExpression(graph, object, value, context, state);
+    if (hasAllRequiredKeys(object, keys, state)) {
+        state.chunks.push(`if(Object.getOwnPropertyNames(${objectExpression}).length!==${String(keys.length)}||Object.getOwnPropertySymbols(${objectExpression}).length!==0)return false;`);
+        return;
+    }
+    const present = `xs${String(state.temp)}`;
+    state.temp += 1;
+    const index = `i${String(state.temp)}`;
+    state.temp += 1;
+    const key = `key${String(state.temp)}`;
+    state.temp += 1;
+    state.chunks.push(`const ${present}=Reflect.ownKeys(${objectExpression});`, `for(let ${index}=0;${index}<${present}.length;${index}+=1){`, `const ${key}=${present}[${index}];`, `if(typeof ${key}!=="string"||!${keyMembershipExpression(key, keys, context)})return false;`, "}");
+}
+/**
+ * @brief emit or return.
+ */
+function emitOrReturn(graph, ids, value, context, state) {
+    for (let index = 0; index < ids.length; index += 1) {
+        const id = ids[index];
+        if (id !== undefined) {
+            state.chunks.push(`if(${emitGraphExpression(graph, id, value, context, state)})return true;`);
+        }
+    }
+    state.chunks.push("return false;");
+}
+/**
+ * @brief emit discriminant dispatch return.
+ */
+function emitDiscriminantDispatchReturn(graph, object, value, key, literals, schemas, context, state) {
+    const objectExpression = emitGraphExpression(graph, object, value, context, state);
+    const descriptor = `d${String(state.temp)}`;
+    state.temp += 1;
+    state.chunks.push(`if(!o(${objectExpression}))return false;`, `const ${descriptor}=g(${objectExpression},${stringRef(context, key)});`, `if(${descriptor}===undefined||typeof ${descriptor}.value!=="string")return false;`, `switch(${descriptor}.value){`);
+    for (let index = 0; index < schemas.length; index += 1) {
+        const schema = schemas[index];
+        const literal = literals[index];
+        if (schema !== undefined && literal !== undefined) {
+            state.chunks.push(`case ${stringRef(context, literal)}:return ${emitGraphFunction(schema, context)}(${objectExpression});`);
+        }
+    }
+    state.chunks.push("default:return false;}");
+}
+/**
+ * @brief emit graph expression.
+ */
+function emitGraphExpression(graph, id, value, context, state) {
+    const node = graph.nodes[id];
+    if (node === undefined) {
+        return "undefined";
+    }
+    switch (node.tag) {
+        case NodeTag.Start:
+            return "true";
+        case NodeTag.Param:
+            return value;
+        case NodeTag.Const:
+            return literalExpression(node.value, context);
+        case NodeTag.GetProp:
+            return state === undefined
+                ? `gv(${emitGraphExpression(graph, node.object, value, context, state)},${stringRef(context, node.key)})`
+                : emitDataValueSlot(graph, node.object, node.key, value, context, state);
+        case NodeTag.IsString:
+            return `(typeof ${emitGraphExpression(graph, node.value, value, context, state)}==="string")`;
+        case NodeTag.IsNumber:
+            return finiteNumberExpression(emitGraphExpression(graph, node.value, value, context, state));
+        case NodeTag.IsBoolean:
+            return `(typeof ${emitGraphExpression(graph, node.value, value, context, state)}==="boolean")`;
+        case NodeTag.IsBigInt:
+            return `(typeof ${emitGraphExpression(graph, node.value, value, context, state)}==="bigint")`;
+        case NodeTag.IsSymbol:
+            return `(typeof ${emitGraphExpression(graph, node.value, value, context, state)}==="symbol")`;
+        case NodeTag.IsObject:
+            return `o(${emitGraphExpression(graph, node.value, value, context, state)})`;
+        case NodeTag.IsArray:
+            return `Array.isArray(${emitGraphExpression(graph, node.value, value, context, state)})`;
+        case NodeTag.IsUndefined:
+            return `(${emitGraphExpression(graph, node.value, value, context, state)}===undefined)`;
+        case NodeTag.IsNull:
+            return `(${emitGraphExpression(graph, node.value, value, context, state)}===null)`;
+        case NodeTag.IsInteger:
+            return `Number.isInteger(${emitGraphExpression(graph, node.value, value, context, state)})`;
+        case NodeTag.Not:
+            return `(${emitGraphExpression(graph, node.value, value, context, state)}!==true)`;
+        case NodeTag.Equals:
+            return `Object.is(${emitGraphExpression(graph, node.left, value, context, state)},${emitGraphExpression(graph, node.right, value, context, state)})`;
+        case NodeTag.Gte:
+            return `(${emitGraphExpression(graph, node.left, value, context, state)}>=${emitGraphExpression(graph, node.right, value, context, state)})`;
+        case NodeTag.Lte:
+            return `(${emitGraphExpression(graph, node.left, value, context, state)}<=${emitGraphExpression(graph, node.right, value, context, state)})`;
+        case NodeTag.StringMin:
+            return `(${emitGraphExpression(graph, node.value, value, context, state)}.length>=${String(node.bound)})`;
+        case NodeTag.StringMax:
+            return `(${emitGraphExpression(graph, node.value, value, context, state)}.length<=${String(node.bound)})`;
+        case NodeTag.Regex:
+            return regexExpression(emitGraphExpression(graph, node.value, value, context, state), node.regex, context);
+        case NodeTag.HasOwn:
+            return `ho(${emitGraphExpression(graph, node.object, value, context, state)},${stringRef(context, node.key)})`;
+        case NodeTag.HasOwnData:
+            return state === undefined
+                ? `hd(${emitGraphExpression(graph, node.object, value, context, state)},${stringRef(context, node.key)})`
+                : hasDataExpression(graph, node.object, node.key, value, context, state);
+        case NodeTag.StrictKeys:
+            return `sk(${emitGraphExpression(graph, node.object, value, context, state)},k[${String(pushKeyset(context, node.keys))}])`;
+        case NodeTag.ArrayEvery:
+            return `ea(${emitGraphExpression(graph, node.value, value, context, state)},${emitGraphFunction(node.item, context)})`;
+        case NodeTag.TupleItems:
+            return emitTupleItemsExpression(emitGraphExpression(graph, node.value, value, context, state), node.items, context);
+        case NodeTag.RecordEvery:
+            return `er(${emitGraphExpression(graph, node.value, value, context, state)},${emitGraphFunction(node.item, context)})`;
+        case NodeTag.DiscriminantDispatch:
+            return emitDiscriminantDispatchExpression(emitGraphExpression(graph, node.value, value, context, state), node.key, node.literals, node.schemas, context);
+        case NodeTag.SchemaCheck:
+            return `d(${String(pushSchema(context, node.schema))},${emitGraphExpression(graph, node.value, value, context, state)})`;
+        case NodeTag.And:
+            return emitBooleanFoldExpression(graph, node.values, value, context, state, true);
+        case NodeTag.Or:
+            return emitBooleanFoldExpression(graph, node.values, value, context, state, false);
+        case NodeTag.Return:
+            return emitGraphExpression(graph, node.value, value, context, state);
+    }
+}
+/**
+ * @brief emit boolean fold expression.
+ */
+function emitBooleanFoldExpression(graph, ids, value, context, state, and) {
+    const fallback = and ? "true" : "false";
+    const operator = and ? "&&" : "||";
+    const parts = [];
+    for (let index = 0; index < ids.length; index += 1) {
+        const id = ids[index];
+        if (id !== undefined) {
+            parts.push(emitGraphExpression(graph, id, value, context, undefined));
+        }
+    }
+    if (parts.length === 0) {
+        return fallback;
+    }
+    return `(${parts.join(operator)})`;
+}
+/**
+ * @brief emit data slot.
+ */
+function emitDataSlot(graph, object, key, value, context, state) {
+    const cacheKey = dataSlotKey(object, key);
+    const cached = state.dataSlots.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const objectExpression = emitGraphExpression(graph, object, value, context, state);
+    const descriptor = `d${String(state.temp)}`;
+    state.temp += 1;
+    const keyRef = stringRef(context, key);
+    state.chunks.push(`const ${descriptor}=gp(${objectExpression},${keyRef});`);
+    const slot = {
+        descriptor,
+        value: undefined
+    };
+    state.dataSlots.set(cacheKey, slot);
+    return slot;
+}
+/**
+ * @brief emit data value slot.
+ */
+function emitDataValueSlot(graph, object, key, value, context, state) {
+    const cacheKey = dataSlotKey(object, key);
+    const slot = emitDataSlot(graph, object, key, value, context, state);
+    if (slot.value !== undefined) {
+        return slot.value;
+    }
+    const localValue = `v${String(state.temp)}`;
+    state.temp += 1;
+    const source = state.dataGuards.has(cacheKey)
+        ? `${slot.descriptor}.value`
+        : `${slot.descriptor}===undefined?undefined:${slot.descriptor}.value`;
+    state.chunks.push(`const ${localValue}=${source};`);
+    slot.value = localValue;
+    return localValue;
+}
+/**
+ * @brief emit has data check.
+ */
+function emitHasDataCheck(graph, object, key, value, context, state) {
+    const cacheKey = dataSlotKey(object, key);
+    const slot = emitDataSlot(graph, object, key, value, context, state);
+    state.chunks.push(`if(${slot.descriptor}===undefined||!h.call(${slot.descriptor},"value"))return false;`);
+    state.dataGuards.add(cacheKey);
+}
+/**
+ * @brief has data expression.
+ */
+function hasDataExpression(graph, object, key, value, context, state) {
+    const slot = emitDataSlot(graph, object, key, value, context, state);
+    return `(${slot.descriptor}!==undefined&&h.call(${slot.descriptor},"value"))`;
+}
+/**
+ * @brief data slot key.
+ */
+function dataSlotKey(object, key) {
+    return `${String(object)}:${key}`;
+}
+/**
+ * @brief has all required keys.
+ */
+function hasAllRequiredKeys(object, keys, state) {
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (key === undefined || !state.dataGuards.has(dataSlotKey(object, key))) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief key membership expression.
+ */
+function keyMembershipExpression(key, keys, context) {
+    if (keys.length === 0) {
+        return "false";
+    }
+    const parts = new Array(keys.length);
+    for (let index = 0; index < keys.length; index += 1) {
+        const value = keys[index];
+        parts[index] = value === undefined
+            ? "false"
+            : `${key}===${stringRef(context, value)}`;
+    }
+    return `(${parts.join("||")})`;
+}
+/**
+ * @brief emit inline schema expression.
+ */
+function emitInlineSchemaExpression(schema, value, context) {
+    const plan = makeValidationPlan(schema);
+    return emitGraphExpression(plan.graph, plan.graph.result, value, context, undefined);
+}
+/**
+ * @brief finite number expression.
+ */
+function finiteNumberExpression(value) {
+    return `(typeof ${value}==="number"&&Number.isFinite(${value}))`;
+}
+/**
+ * @brief regex expression.
+ */
+function regexExpression(value, regex, context) {
+    const index = pushRegex(context, regex);
+    const ref = `r[${String(index)}]`;
+    return `((${ref}.lastIndex=0),${ref}.test(${value}))`;
+}
+/**
+ * @brief emit tuple items expression.
+ */
+function emitTupleItemsExpression(value, items, context) {
+    const parts = [
+        `Array.isArray(${value})`,
+        `${value}.length===${String(items.length)}`
+    ];
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        if (item !== undefined) {
+            parts.push(`ev(${value},${String(index)},${emitGraphFunction(item, context)})`);
+        }
+    }
+    return `(${parts.join("&&")})`;
+}
+/**
+ * @brief emit discriminant dispatch expression.
+ */
+function emitDiscriminantDispatchExpression(value, key, literals, schemas, context) {
+    const functions = [];
+    for (let index = 0; index < schemas.length; index += 1) {
+        const schema = schemas[index];
+        if (schema !== undefined) {
+            functions.push(emitGraphFunction(schema, context));
+        }
+    }
+    const keyset = `k[${String(pushKeyset(context, literals))}]`;
+    if (functions.length === 0) {
+        return `dj(${value},${stringRef(context, key)},${keyset})`;
+    }
+    return `dj(${value},${stringRef(context, key)},${keyset},${functions.join(",")})`;
+}
+/**
+ * @brief literal expression.
+ */
+function literalExpression(value, context) {
+    if (value === true) {
+        return "true";
+    }
+    if (value === false) {
+        return "false";
+    }
+    if (value === null) {
+        return "null";
+    }
+    if (value === undefined) {
+        return "undefined";
+    }
+    return `l[${String(pushLiteral(context, value))}]`;
+}

package/dist/compile/guard.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @file compile/guard.ts
+ * @brief Compiled guard construction and receiver validation.
+ */
+import { BaseGuard, type Guard, type Presence, type RuntimeValue } from "../guard/index.js";
+import type { CheckResult } from "../issue/index.js";
+import { type Schema } from "../schema/index.js";
+import { type BooleanPredicate, type IssueCollectorRoot } from "./runtime.js";
+import type { CompileOptions, CompiledGuard } from "./types.js";
+/**
+ * @brief compiled base guard.
+ * @details Owns its state directly; methods expose receiver checks and explicit result flow.
+ * @invariant Construction leaves the instance in a fully usable state before it escapes.
+ */
+export declare class CompiledBaseGuard<TValue, TPresence extends Presence = "required"> extends BaseGuard<TValue, TPresence> implements CompiledGuard<TValue, TPresence> {
+    readonly source: string;
+    private readonly test;
+    private readonly collect;
+    /**
+     * @brief constructor.
+               * @post The receiver is initialized according to the class invariant before it can be observed.
+     */
+    constructor(schema: Schema, test: BooleanPredicate, collect: IssueCollectorRoot, source: string);
+    /**
+     * @brief is.
+             */
+    is(this: unknown, value: unknown): value is RuntimeValue<TValue, TPresence>;
+    /**
+     * @brief check.
+             */
+    check(this: unknown, value: unknown): CheckResult<RuntimeValue<TValue, TPresence>>;
+    /**
+     * @brief assert.
+             */
+    assert(this: unknown, value: unknown): asserts value is RuntimeValue<TValue, TPresence>;
+}
+/**
+ * @brief compile.
+ */
+export declare function compile<TValue, TPresence extends Presence>(guard: Guard<TValue, TPresence>, options?: Partial<CompileOptions>): CompiledBaseGuard<TValue, TPresence>;
+//# sourceMappingURL=guard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guard.d.ts","sourceRoot":"","sources":["../../src/compile/guard.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,SAAS,EAET,KAAK,KAAK,EACV,KAAK,QAAQ,EACb,KAAK,YAAY,EAClB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD,OAAO,EAGL,KAAK,MAAM,EACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAIL,KAAK,gBAAgB,EAErB,KAAK,kBAAkB,EACxB,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACd,MAAM,YAAY,CAAC;AAOpB;;;;GAIG;AACH,qBAAa,iBAAiB,CAC5B,MAAM,EACN,SAAS,SAAS,QAAQ,GAAG,UAAU,CACvC,SAAQ,SAAS,CAAC,MAAM,EAAE,SAAS,CAAE,YAAW,aAAa,CAAC,MAAM,EAAE,SAAS,CAAC;IAChF,SAAwB,MAAM,EAAE,MAAM,CAAC;IACvC,iBAAyB,IAAI,CAAmB;IAChD,iBAAyB,OAAO,CAAqB;IAErD;;;OAGG;gBAED,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,MAAM;IAmBhB;;eAEW;IACK,EAAE,CAChB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC;IAI3C;;eAEW;IACK,KAAK,CACnB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,OAAO,GACb,WAAW,CAAC,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAI/C;;eAEW;IACK,MAAM,CACpB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC,MAAM,EAAE,SAAS,CAAC;CAMpD;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,SAAS,QAAQ,EACxD,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,SAAS,CAAC,EAC/B,OAAO,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,GAChC,iBAAiB,CAAC,MAAM,EAAE,SAAS,CAAC,CAgCtC"}

package/dist/compile/guard.js

@@ -0,0 +1,180 @@
+/**
+ * @file compile/guard.ts
+ * @brief Compiled guard construction and receiver validation.
+ */
+import { BaseGuard, TypeSeaAssertionError } from "../guard/index.js";
+import { finalizeIssueArray } from "../issue/index.js";
+import { err, ok } from "../result/index.js";
+import { freezeSchema, isSchemaValue } from "../schema/index.js";
+import { makeDynamicCheck, makeDynamicIssueCheck, strictKeys } from "./runtime.js";
+import { emitCompiledSourceBundle } from "./source.js";
+/**
+ * @brief constructed compiled guards.
+ */
+const constructedCompiledGuards = new WeakSet();
+/**
+ * @brief compiled base guard.
+ * @details Owns its state directly; methods expose receiver checks and explicit result flow.
+ * @invariant Construction leaves the instance in a fully usable state before it escapes.
+ */
+export class CompiledBaseGuard extends BaseGuard {
+    /**
+     * @brief constructor.
+               * @post The receiver is initialized according to the class invariant before it can be observed.
+     */
+    constructor(schema, test, collect, source) {
+        if (typeof test !== "function") {
+            throw new TypeError("compiled guard test must be a function");
+        }
+        if (typeof collect !== "function") {
+            throw new TypeError("compiled guard collector must be a function");
+        }
+        if (typeof source !== "string") {
+            throw new TypeError("compiled guard source must be a string");
+        }
+        super(schema);
+        defineReadonlyProperty(this, "test", test, false);
+        defineReadonlyProperty(this, "collect", collect, false);
+        defineReadonlyProperty(this, "source", source, true);
+        constructedCompiledGuards.add(this);
+        Object.freeze(this);
+    }
+    /**
+     * @brief is.
+             */
+    is(value) {
+        return isStrictTrue(readCompiledTest(this)(value));
+    }
+    /**
+     * @brief check.
+             */
+    check(value) {
+        return runCompiledCheck(this, value);
+    }
+    /**
+     * @brief assert.
+             */
+    assert(value) {
+        const result = runCompiledCheck(this, value);
+        if (!result.ok) {
+            throw new TypeSeaAssertionError(result.error);
+        }
+    }
+}
+/**
+ * @brief compile.
+ */
+export function compile(guard, options) {
+    const schema = readCompileSchema(guard);
+    const name = readCompileName(options);
+    const bundle = emitCompiledSourceBundle(schema, name);
+    // compile() intentionally emits source so V8 can optimize the validator body.
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval
+    const factory = new Function("l", "r", "k", "u", "d", "m", "sk", bundle.source);
+    const dynamicCheck = makeDynamicCheck(bundle.dynamicSchemas);
+    const runtime = factory(bundle.literals, bundle.regexps, bundle.keysets, bundle.strings, dynamicCheck, makeDynamicIssueCheck(bundle.dynamicSchemas), strictKeys);
+    return new CompiledBaseGuard(schema, runtime.is, runtime.check, bundle.source);
+}
+/**
+ * @brief read compile schema.
+ */
+function readCompileSchema(guard) {
+    if (!isRecord(guard)) {
+        throw new TypeError("compile guard must be a TypeSea guard");
+    }
+    const schema = guard["schema"];
+    if (!isSchemaValue(schema)) {
+        throw new TypeError("compile guard must contain a valid TypeSea schema");
+    }
+    return freezeSchema(schema);
+}
+/**
+ * @brief is strict true.
+ */
+function isStrictTrue(value) {
+    return value === true;
+}
+/**
+ * @brief run compiled check.
+ */
+function runCompiledCheck(guard, value) {
+    const issues = finalizeIssueArray(readCompiledCollect(guard)(value));
+    if (issues.length === 0) {
+        return ok(value);
+    }
+    return err(issues);
+}
+/**
+ * @brief read compiled test.
+ */
+function readCompiledTest(guard) {
+    if (isConstructedCompiledGuard(guard)) {
+        return guard["test"];
+    }
+    if (!isRecord(guard)) {
+        throw new TypeError("compiled guard receiver must be a TypeSea guard");
+    }
+    const test = guard["test"];
+    if (typeof test !== "function") {
+        throw new TypeError("compiled guard receiver must contain a test function");
+    }
+    return test;
+}
+/**
+ * @brief read compiled collect.
+ */
+function readCompiledCollect(guard) {
+    if (isConstructedCompiledGuard(guard)) {
+        return guard["collect"];
+    }
+    if (!isRecord(guard)) {
+        throw new TypeError("compiled guard receiver must be a TypeSea guard");
+    }
+    const collect = guard["collect"];
+    if (typeof collect !== "function") {
+        throw new TypeError("compiled guard receiver must contain a collector function");
+    }
+    return collect;
+}
+/**
+ * @brief define readonly property.
+ */
+function defineReadonlyProperty(target, key, value, enumerable) {
+    Object.defineProperty(target, key, {
+        configurable: false,
+        enumerable,
+        value,
+        writable: false
+    });
+}
+/**
+ * @brief read compile name.
+ */
+function readCompileName(options) {
+    if (options === undefined) {
+        return "typesea_is";
+    }
+    if (!isRecord(options)) {
+        throw new TypeError("compile options must be an object");
+    }
+    const name = options["name"];
+    if (name === undefined) {
+        return "typesea_is";
+    }
+    if (typeof name !== "string") {
+        throw new TypeError("compile name must be a string");
+    }
+    return name;
+}
+/**
+ * @brief is record.
+ */
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * @brief is constructed compiled guard.
+ */
+function isConstructedCompiledGuard(value) {
+    return isRecord(value) && constructedCompiledGuards.has(value);
+}

package/dist/compile/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file compile/index.ts
+ * @brief Public compile module barrel.
+ */
+export { CompiledBaseGuard, compile } from "./guard.js";
+export { emitCompiledSourceBundle } from "./source.js";
+export type { CompileOptions, CompiledGuard, CompiledSourceBundle } from "./types.js";
+//# sourceMappingURL=index.d.ts.map