@astrale-os/kernel-dsl 0.2.0-beta.8 → 0.2.0

package/dist/v1/language/state/machine.d.ts

@@ -0,0 +1,28 @@
+import { type ZodType } from 'zod';
+import type { EventName, StateName, StateTopology, TransitionRelation, ValidTransitionRelation } from './topology.js';
+export interface StateMachine<Transitions extends TransitionRelation = any, Initial extends StateName<Transitions> = StateName<Transitions>> extends StateTopology<Transitions, Initial> {
+    readonly stateSchema: ZodType<StateName<Transitions>, StateName<Transitions>>;
+    readonly eventSchema: ZodType<EventName<Transitions>, EventName<Transitions>>;
+    eventsFrom<State extends StateName<Transitions>>(state: State): readonly EventName<Transitions, State>[];
+    decide<State extends StateName<Transitions>, Event extends EventName<Transitions>>(state: State, event: Event): TransitionDecision<Transitions, State, Event>;
+}
+export type StateOf<Machine extends StateMachine> = StateName<Machine['transitions']>;
+export type EventOf<Machine extends StateMachine, State extends StateOf<Machine> = StateOf<Machine>> = EventName<Machine['transitions'], State>;
+type TransitionDecision<Transitions extends TransitionRelation, State extends StateName<Transitions>, Event extends EventName<Transitions>> = State extends StateName<Transitions> ? Event extends EventName<Transitions> ? Event extends keyof Transitions[State] ? Readonly<{
+    kind: 'allowed';
+    transition: Readonly<{
+        from: State;
+        event: Event;
+        to: Transitions[State][Event];
+    }>;
+}> : Readonly<{
+    kind: 'rejected';
+    code: 'STATE_TRANSITION_ILLEGAL';
+    from: State;
+    event: Event;
+}> : never : never;
+export declare function stateMachine<const Transitions extends TransitionRelation, const Initial extends StateName<Transitions>>(input: Readonly<{
+    initial: Initial;
+    transitions: Transitions & ValidTransitionRelation<Transitions>;
+}>): StateMachine<Transitions, Initial>;
+export {};

package/dist/v1/language/state/machine.js

@@ -0,0 +1,40 @@
+import { enum as enumeration } from 'zod';
+import { compareUnicode } from '../../addressing/ordering.js';
+import { admitStateTopology } from './topology.js';
+export function stateMachine(input) {
+    const topology = admitStateTopology(input);
+    const states = Object.keys(topology.transitions);
+    const events = [
+        ...new Set(states.flatMap((state) => Object.keys(topology.transitions[state]))),
+    ].sort(compareUnicode);
+    const stateSet = new Set(states);
+    const eventSet = new Set(events);
+    return Object.freeze({
+        ...topology,
+        stateSchema: enumeration(states),
+        eventSchema: enumeration(events),
+        eventsFrom(state) {
+            admitState(state, stateSet);
+            return Object.freeze(Object.keys(topology.transitions[state]));
+        },
+        decide(state, event) {
+            admitState(state, stateSet);
+            admitEvent(event, eventSet);
+            const target = topology.transitions[state][event];
+            return target === undefined
+                ? Object.freeze({ kind: 'rejected', code: 'STATE_TRANSITION_ILLEGAL', from: state, event })
+                : Object.freeze({
+                    kind: 'allowed',
+                    transition: Object.freeze({ from: state, event, to: target }),
+                });
+        },
+    });
+}
+function admitState(state, states) {
+    if (!states.has(state))
+        throw new TypeError(`State machine does not declare state "${state}".`);
+}
+function admitEvent(event, events) {
+    if (!events.has(event))
+        throw new TypeError(`State machine does not declare event "${event}".`);
+}

package/dist/v1/language/state/topology.d.ts

@@ -0,0 +1,14 @@
+export type TransitionRelation = Readonly<Record<string, Readonly<Record<string, string>>>>;
+export type StateName<Transitions extends TransitionRelation> = Extract<keyof Transitions, string>;
+export type EventName<Transitions extends TransitionRelation, State extends StateName<Transitions> = StateName<Transitions>> = State extends StateName<Transitions> ? Extract<keyof Transitions[State], string> : never;
+export type ValidTransitionRelation<Transitions extends TransitionRelation> = Readonly<{
+    [State in StateName<Transitions>]: Readonly<{
+        [Event in keyof Transitions[State]]: string extends StateName<Transitions> ? string : Exclude<StateName<Transitions>, State>;
+    }>;
+}>;
+export interface StateTopology<Transitions extends TransitionRelation = TransitionRelation, Initial extends StateName<Transitions> = StateName<Transitions>> {
+    readonly initial: Initial;
+    readonly transitions: Transitions;
+}
+export type StateTopologyOf<Value> = Value extends StateTopology<infer Transitions, infer Initial> ? StateTopology<Transitions, Initial> : undefined;
+export declare function admitStateTopology(input: unknown): StateTopology;

package/dist/v1/language/state/topology.js

@@ -0,0 +1,69 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+export function admitStateTopology(input) {
+    if (!isRecord(input) || !exactKeys(input, ['initial', 'transitions']))
+        invalidInput();
+    const initial = input.initial;
+    const authored = input.transitions;
+    if (typeof initial !== 'string' || initial.length === 0 || !isRecord(authored))
+        invalidInput();
+    const states = Object.keys(authored);
+    if (states.length === 0)
+        throw new TypeError('State topology requires at least one state.');
+    if (states.includes(''))
+        throw new TypeError('State topology has an empty state name.');
+    if (!states.includes(initial)) {
+        throw new TypeError(`State topology initial state "${initial}" is not declared.`);
+    }
+    const declared = new Set(states);
+    const transitions = Object.create(null);
+    let transitionCount = 0;
+    for (const state of states.sort(compareUnicode)) {
+        const outgoing = authored[state];
+        if (!isRecord(outgoing))
+            throw new TypeError(`State "${state}" transitions must be an object.`);
+        const accepted = Object.create(null);
+        for (const event of Object.keys(outgoing).sort(compareUnicode)) {
+            const target = outgoing[event];
+            if (event.length === 0)
+                throw new TypeError(`State "${state}" has an empty event name.`);
+            if (typeof target !== 'string' || !declared.has(target)) {
+                throw new TypeError(`State "${state}" event "${event}" targets undeclared state "${String(target)}".`);
+            }
+            if (target === state) {
+                throw new TypeError(`State "${state}" event "${event}" is a self-transition.`);
+            }
+            accepted[event] = target;
+            transitionCount += 1;
+        }
+        transitions[state] = Object.freeze(accepted);
+    }
+    if (transitionCount === 0)
+        throw new TypeError('State topology requires at least one transition.');
+    const reachable = new Set([initial]);
+    const pending = [initial];
+    while (pending.length > 0) {
+        const state = pending.shift();
+        for (const target of Object.values(transitions[state])) {
+            if (reachable.has(target))
+                continue;
+            reachable.add(target);
+            pending.push(target);
+        }
+    }
+    for (const state of states) {
+        if (!reachable.has(state)) {
+            throw new TypeError(`State "${state}" is unreachable from initial "${initial}".`);
+        }
+    }
+    return Object.freeze({ initial, transitions: Object.freeze(transitions) });
+}
+function invalidInput() {
+    throw new TypeError('State topology must contain exactly initial and transitions.');
+}
+function isRecord(input) {
+    return input !== null && typeof input === 'object' && !Array.isArray(input);
+}
+function exactKeys(input, expected) {
+    const keys = Reflect.ownKeys(input);
+    return keys.length === expected.length && keys.every((key) => expected.includes(String(key)));
+}

package/dist/v1/language/value/compile/fields.d.ts

@@ -1,3 +1,3 @@
 import type { ValueProgram } from './model.js';
 /** Exact field constraints available for independent scalar route validation. */
-export declare function inputFieldNodes(program: ValueProgram): Readonly<Record<string, readonly number[]>> | undefined;
+export declare function inputFieldNodes(program: Pick<ValueProgram, 'root' | 'nodes'>): Readonly<Record<string, readonly number[]>> | undefined;

package/dist/v1/language/value/compile/load.d.ts

@@ -1,4 +1,6 @@
 import type { CompiledInstanceSchema } from '../evaluate/types.js';
-import type { ValueProgram } from './model.js';
+import type { IndexedValueProgram, ValueProgram } from './model.js';
+/** Bind already-admitted entry-local indices without copying any pattern machine. */
+export declare function bindValueProgram(program: IndexedValueProgram, patterns: ValueProgram['patterns']): ValueProgram;
 /** Bind admitted portable indices to the canonical instance evaluator. */
-export declare function loadValueProgram(program: ValueProgram): CompiledInstanceSchema;
+export declare function loadValueProgram(program: ValueProgram, rootIndex?: number): CompiledInstanceSchema;

package/dist/v1/language/value/compile/load.js

@@ -1,7 +1,28 @@
 import { loadPattern } from '../regexp/matcher.js';
 import { appendPointer } from '../syntax/pointer.js';
+const loadedPrograms = new WeakMap();
+/** Bind already-admitted entry-local indices without copying any pattern machine. */
+export function bindValueProgram(program, patterns) {
+    return Object.freeze({
+        ...program,
+        patterns: Object.freeze(program.patterns.map((index) => patterns[index])),
+    });
+}
 /** Bind admitted portable indices to the canonical instance evaluator. */
-export function loadValueProgram(program) {
+export function loadValueProgram(program, rootIndex = program.root) {
+    let compiled = loadedPrograms.get(program);
+    if (compiled === undefined) {
+        compiled = createValueProgram(program);
+        loadedPrograms.set(program, compiled);
+    }
+    if (rootIndex === program.root)
+        return compiled;
+    const root = compiled.locations.get(String(rootIndex));
+    if (root === undefined)
+        throw new TypeError('Compiled value program root is absent.');
+    return { ...compiled, root };
+}
+function createValueProgram(program) {
     const resource = { key: 'compiled', schema: true, ownerOrigin: 'compiled' };
     const locations = program.nodes.map((node, index) => ({
         key: String(index),

package/dist/v1/language/value/compile/model.d.ts

@@ -14,6 +14,17 @@ export interface Pattern {
     readonly start: number;
     readonly states: readonly PatternState[];
 }
+/** A scalar run counts Unicode scalars, never UTF-16 code units. */
+export interface ScalarRun {
+    readonly ranges: readonly ScalarRange[];
+    readonly minimum: number;
+    readonly maximum?: number;
+}
+/** All runs except the last have an exact finite length. */
+export interface RunPattern {
+    readonly source: string;
+    readonly runs: readonly ScalarRun[];
+}
 export interface ValueNode {
     readonly schema: JsonValue;
     readonly children: Readonly<Record<string, number>>;
@@ -23,5 +34,9 @@ export interface ValueNode {
 export interface ValueProgram {
     readonly root: number;
     readonly nodes: readonly ValueNode[];
-    readonly patterns: readonly Pattern[];
+    readonly patterns: readonly (Pattern | RunPattern)[];
+}
+/** Pattern indices belong to the enclosing compiled entry's table. */
+export interface IndexedValueProgram extends Omit<ValueProgram, 'patterns'> {
+    readonly patterns: readonly number[];
 }

package/dist/v1/language/value/evaluate/assertions.d.ts

@@ -1,6 +1,8 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 export declare function matchesType(input: string, value: JsonValue): boolean;
 export declare function jsonEqual(left: JsonValue, right: JsonValue): boolean;
+/** Count Unicode code points with string-iterator semantics, without a character array. */
+export declare function codePointLength(input: string): number;
 export declare function unique(values: readonly JsonValue[]): boolean;
 /** Compare finite JSON numbers as their exact ECMAScript decimal spellings. */
 export declare function isMultipleOf(value: number, divisor: number): boolean;

package/dist/v1/language/value/evaluate/assertions.js

@@ -21,6 +21,19 @@ export function matchesType(input, value) {
 export function jsonEqual(left, right) {
     return equal(left, right);
 }
+/** Count Unicode code points with string-iterator semantics, without a character array. */
+export function codePointLength(input) {
+    let length = 0;
+    for (let index = 0; index < input.length; index++, length++) {
+        const first = input.charCodeAt(index);
+        if (first >= 0xd800 && first <= 0xdbff && index + 1 < input.length) {
+            const second = input.charCodeAt(index + 1);
+            if (second >= 0xdc00 && second <= 0xdfff)
+                index++;
+        }
+    }
+    return length;
+}
 export function unique(values) {
     const seen = new Set();
     for (const value of values) {

package/dist/v1/language/value/evaluate/evaluator.js

@@ -1,36 +1,61 @@
+import { isCanonicalBlobRef } from '../model/blob.js';
 import { isInstantValue } from '../model/instant.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 import { appendPointer } from '../syntax/pointer.js';
-import { isMultipleOf, jsonEqual, matchesType, unique } from './assertions.js';
+import { codePointLength, isMultipleOf, jsonEqual, matchesType, unique } from './assertions.js';
 import { evaluation, mergeAnnotations } from './types.js';
 /** Evaluate complete Draft 2020-12 acceptance without dynamic source generation. */
 export function evaluateInstance(compiled, input) {
     return new InstanceEvaluator(compiled).evaluate(compiled.root, input, '');
 }
+/** Bound per-call retention independently of the size or diversity of an input value. */
+const MAX_CACHED_PATTERN_RESULTS = 256;
+const MAX_CACHED_PATTERN_INPUT_LENGTH = 128;
 class InstanceEvaluator {
     compiled;
-    active = new Set();
+    resultCache = new Map();
+    searchResults = new Map();
+    fullMatchResults = new Map();
+    patternResultCount = 0;
     constructor(compiled) {
         this.compiled = compiled;
     }
     evaluate(location, input, instancePointer) {
-        const activeKey = `${location.key}\u0000${instancePointer}`;
-        if (this.active.has(activeKey)) {
+        const key = `${location.key}\u0000${instancePointer}`;
+        // propertyNames evaluates the name at the property's value pointer. Cache by the actual
+        // input too, retaining one result per repeated sub-problem within this call. A null entry
+        // marks an active evaluation; completed results and their annotations are only read.
+        let byLocation = this.resultCache.get(input);
+        const memoized = byLocation?.get(key);
+        if (memoized === null) {
             throw new TypeError('Admitted value schema entered a non-productive evaluation cycle.');
         }
-        this.active.add(activeKey);
+        if (memoized !== undefined)
+            return memoized;
+        if (byLocation === undefined) {
+            byLocation = new Map();
+            this.resultCache.set(input, byLocation);
+        }
+        byLocation.set(key, null);
         try {
-            if (location.schema === true)
-                return evaluation();
-            if (location.schema === false) {
-                return evaluation([
+            let result;
+            if (location.schema === true) {
+                result = evaluation();
+            }
+            else if (location.schema === false) {
+                result = evaluation([
                     invalid(instancePointer, 'false', 'The false schema rejects every value.'),
                 ]);
             }
-            return this.evaluateObjectSchema(location, location.schema, input, instancePointer);
+            else {
+                result = this.evaluateObjectSchema(location, location.schema, input, instancePointer);
+            }
+            byLocation.set(key, result);
+            return result;
         }
-        finally {
-            this.active.delete(activeKey);
+        catch (error) {
+            byLocation.delete(key);
+            throw error;
         }
     }
     evaluateObjectSchema(location, schema, input, instancePointer) {
@@ -79,14 +104,20 @@ class InstanceEvaluator {
         });
         const anyOf = schemaList(schema.anyOf);
         if (anyOf !== undefined) {
-            const results = anyOf.map((_, index) => this.evaluate(this.child(location, 'anyOf', index), input, instancePointer));
-            const admitted = results.filter(({ valid }) => valid);
-            if (admitted.length === 0) {
+            let admitted = 0;
+            anyOf.forEach((_, index) => {
+                const branch = this.child(location, 'anyOf', index);
+                if (contradictsRequiredConst(branch.schema, input))
+                    return;
+                const result = this.evaluate(branch, input, instancePointer);
+                if (!result.valid)
+                    return;
+                admitted += 1;
+                mergeAnnotations(properties, items, result);
+            });
+            if (admitted === 0) {
                 failures.push(invalid(instancePointer, 'anyOf', 'Value satisfies no anyOf branch.'));
             }
-            else {
-                admitted.forEach((result) => mergeAnnotations(properties, items, result));
-            }
         }
         const oneOf = schemaList(schema.oneOf);
         if (oneOf !== undefined) {
@@ -119,6 +150,9 @@ class InstanceEvaluator {
         if (schema['x-astrale-value-kind'] === 'instant' && !isInstantValue(input)) {
             failures.push(invalid(instancePointer, 'x-astrale-value-kind', 'Value is not an exact UTC millisecond Instant.'));
         }
+        if (schema['x-astrale-value-kind'] === 'blob' && !isCanonicalBlobRef(input)) {
+            failures.push(invalid(instancePointer, 'x-astrale-value-kind', 'Value is not a canonical blob Ref.'));
+        }
         if (typeof schema.type === 'string') {
             if (!matchesType(schema.type, input)) {
                 failures.push(invalid(instancePointer, 'type', `Value is not of type ${schema.type}.`));
@@ -154,18 +188,23 @@ class InstanceEvaluator {
         }
     }
     evaluateStringAssertions(schema, input, instancePointer, failures) {
-        const length = Array.from(input).length;
-        if (typeof schema.maxLength === 'number' && length > schema.maxLength) {
-            failures.push(invalid(instancePointer, 'maxLength', 'String exceeds maxLength.'));
-        }
-        if (typeof schema.minLength === 'number' && length < schema.minLength) {
-            failures.push(invalid(instancePointer, 'minLength', 'String is below minLength.'));
+        // For n UTF-16 units, ceil(n / 2) <= code points <= n. Count only if those
+        // bounds cannot already prove both length assertions; other assertions still run.
+        if ((typeof schema.maxLength === 'number' && input.length > schema.maxLength) ||
+            (typeof schema.minLength === 'number' && Math.ceil(input.length / 2) < schema.minLength)) {
+            const length = codePointLength(input);
+            if (typeof schema.maxLength === 'number' && length > schema.maxLength) {
+                failures.push(invalid(instancePointer, 'maxLength', 'String exceeds maxLength.'));
+            }
+            if (typeof schema.minLength === 'number' && length < schema.minLength) {
+                failures.push(invalid(instancePointer, 'minLength', 'String is below minLength.'));
+            }
         }
-        if (typeof schema.pattern === 'string' && !this.compiled.matcher(schema.pattern).test(input)) {
+        if (typeof schema.pattern === 'string' && !this.matchesPattern(schema.pattern, input, false)) {
             failures.push(invalid(instancePointer, 'pattern', 'String does not match pattern.'));
         }
         if (typeof schema.fullMatch === 'string' &&
-            !this.compiled.matcher(schema.fullMatch).matches(input)) {
+            !this.matchesPattern(schema.fullMatch, input, true)) {
             failures.push(invalid(instancePointer, 'fullMatch', 'String does not match fullMatch.'));
         }
     }
@@ -284,9 +323,8 @@ class InstanceEvaluator {
         const patternMatched = new Set();
         let patternsValid = true;
         for (const pattern of Object.keys(patterns)) {
-            const matcher = this.compiled.matcher(pattern);
             for (const name of names) {
-                if (!matcher.test(name))
+                if (!this.matchesPattern(pattern, name, false))
                     continue;
                 patternMatched.add(name);
                 const result = this.evaluate(this.child(location, 'patternProperties', pattern), input[name], appendPointer(instancePointer, name));
@@ -349,6 +387,51 @@ class InstanceEvaluator {
     child(parent, keyword, member) {
         return this.compiled.child(parent, keyword, member);
     }
+    matchesPattern(source, input, whole) {
+        const cacheable = input.length <= MAX_CACHED_PATTERN_INPUT_LENGTH;
+        const cache = whole ? this.fullMatchResults : this.searchResults;
+        if (cacheable) {
+            const found = cache.get(source)?.get(input);
+            if (found !== undefined)
+                return found;
+        }
+        const matcher = this.compiled.matcher(source);
+        const result = whole ? matcher.matches(input) : matcher.test(input);
+        if (cacheable && this.patternResultCount < MAX_CACHED_PATTERN_RESULTS) {
+            let values = cache.get(source);
+            if (values === undefined) {
+                values = new Map();
+                cache.set(source, values);
+            }
+            values.set(input, result);
+            this.patternResultCount++;
+        }
+        return result;
+    }
+}
+/** A required property with a different primitive const makes the entire branch impossible. */
+function contradictsRequiredConst(schema, input) {
+    if (!isJsonObject(schema) || !isJsonObject(input) || !Array.isArray(schema.required)) {
+        return false;
+    }
+    if (!isJsonObject(schema.properties))
+        return false;
+    for (const key of schema.required) {
+        if (typeof key !== 'string' || !Object.hasOwn(input, key))
+            continue;
+        const property = schema.properties[key];
+        if (!isJsonObject(property) || !Object.hasOwn(property, 'const'))
+            continue;
+        const expected = property.const;
+        if ((expected === null ||
+            typeof expected === 'string' ||
+            typeof expected === 'number' ||
+            typeof expected === 'boolean') &&
+            input[key] !== expected) {
+            return true;
+        }
+    }
+    return false;
 }
 function schemaList(input) {
     return Array.isArray(input) ? input : undefined;

package/dist/v1/language/value/evaluate/preparation.d.ts

@@ -1,6 +1,8 @@
 import type { JsonSchema } from '../model/schema.js';
 import type { ValueSchemaRegistry } from '../reference/registry.js';
+import type { IRegexpMatcher } from '../regexp/matcher.js';
 import type { CompiledInstanceSchema } from './types.js';
+import { compilePattern } from '../regexp/compile.js';
 export type InstanceSchemaCompilation = {
     readonly compiled: true;
     readonly value: CompiledInstanceSchema;
@@ -8,6 +10,13 @@ export type InstanceSchemaCompilation = {
     readonly compiled: false;
     readonly message: string;
 };
+/** Owned by one compilation or source-resolution closure, not retained process-globally. */
+interface PreparedPattern {
+    readonly pattern: ReturnType<typeof compilePattern>;
+    readonly matcher: IRegexpMatcher;
+}
+export type PatternPool = Map<string, PreparedPattern>;
 /** Prepare reference and linear-regexp state without generating executable source. */
-export declare function prepareValueSchema(schema: JsonSchema, registry: ValueSchemaRegistry, pointer: string): InstanceSchemaCompilation;
+export declare function prepareValueSchema(schema: JsonSchema, registry: ValueSchemaRegistry, pointer: string, pool?: PatternPool): InstanceSchemaCompilation;
 export declare function childKey(pointer: string): string;
+export {};

package/dist/v1/language/value/evaluate/preparation.js

@@ -6,7 +6,7 @@ import { loadPattern } from '../regexp/matcher.js';
 import { appendPointer } from '../syntax/pointer.js';
 import { walkSchema } from '../syntax/walk.js';
 /** Prepare reference and linear-regexp state without generating executable source. */
-export function prepareValueSchema(schema, registry, pointer) {
+export function prepareValueSchema(schema, registry, pointer, pool = new Map()) {
     const indexed = indexRegistry(registry, pointer);
     if (indexed.diagnostics.length > 0)
         return failed(indexed.diagnostics);
@@ -26,11 +26,11 @@ export function prepareValueSchema(schema, registry, pointer) {
             });
             if (!isJsonObject(location.schema))
                 return;
-            rememberMatcher(matchers, location.schema.pattern);
-            rememberMatcher(matchers, location.schema.fullMatch);
+            rememberMatcher(matchers, pool, location.schema.pattern);
+            rememberMatcher(matchers, pool, location.schema.fullMatch);
             if (isJsonObject(location.schema.patternProperties)) {
                 for (const pattern of Object.keys(location.schema.patternProperties)) {
-                    rememberMatcher(matchers, pattern);
+                    rememberMatcher(matchers, pool, pattern);
                 }
             }
         });
@@ -40,13 +40,14 @@ export function prepareValueSchema(schema, registry, pointer) {
     if (root === undefined) {
         return { compiled: false, message: 'The root value schema is absent from its closure.' };
     }
+    let program;
     return {
         compiled: true,
         value: {
             root,
             locations,
             resolutions: closure.resolutions,
-            program: () => portableProgram(root, locations, closure.resolutions),
+            program: () => (program ??= portableProgram(root, locations, closure.resolutions, matchers)),
             child(location, keyword, member) {
                 const keywordPointer = appendPointer(location.pointer, keyword);
                 const pointer = member === undefined ? keywordPointer : appendPointer(keywordPointer, member);
@@ -67,15 +68,14 @@ export function prepareValueSchema(schema, registry, pointer) {
                 if (matcher === undefined) {
                     throw new TypeError('Value schema uses an unprepared I-Regexp source.');
                 }
-                return matcher;
+                return matcher.matcher;
             },
         },
     };
 }
-function portableProgram(root, locations, resolutions) {
+function portableProgram(root, locations, resolutions, patterns) {
     const ordered = [...locations.values()];
     const indices = new Map(ordered.map((location, index) => [location.key, index]));
-    const patterns = new Map();
     const nodes = ordered.map((location) => {
         const children = {};
         walkSchema(location.schema, (child) => {
@@ -85,7 +85,6 @@ function portableProgram(root, locations, resolutions) {
             if (target !== undefined)
                 children[childKey(child.pointer)] = target;
         });
-        rememberPattern(patterns, location.schema);
         const resolved = resolutions.get(location.key);
         const reference = resolved === undefined
             ? undefined
@@ -102,29 +101,21 @@ function portableProgram(root, locations, resolutions) {
     return Object.freeze({
         root: indices.get(root.key),
         nodes: Object.freeze(nodes),
-        patterns: Object.freeze([...patterns.values()]),
+        patterns: Object.freeze([...patterns.values()].map(({ pattern }) => pattern)),
     });
 }
-function rememberPattern(patterns, schema) {
-    if (!isJsonObject(schema))
-        return;
-    for (const source of [schema.pattern, schema.fullMatch]) {
-        if (typeof source === 'string' && !patterns.has(source))
-            patterns.set(source, compilePattern(source));
-    }
-    if (isJsonObject(schema.patternProperties)) {
-        for (const source of Object.keys(schema.patternProperties)) {
-            if (!patterns.has(source))
-                patterns.set(source, compilePattern(source));
-        }
-    }
-}
 export function childKey(pointer) {
     return pointer.slice(1);
 }
-function rememberMatcher(matchers, input) {
+function rememberMatcher(matchers, pool, input) {
     if (typeof input === 'string' && !matchers.has(input)) {
-        matchers.set(input, loadPattern(compilePattern(input)));
+        let prepared = pool.get(input);
+        if (prepared === undefined) {
+            const pattern = compilePattern(input);
+            prepared = { pattern, matcher: loadPattern(pattern) };
+            pool.set(input, prepared);
+        }
+        matchers.set(input, prepared);
     }
 }
 function failed(diagnostics) {

package/dist/v1/language/value/evaluate/program.js

@@ -6,7 +6,7 @@ export function validateValueProgram(program, input, roots = [program.root]) {
     if (canonical.length > 0)
         return canonical;
     return roots.flatMap((root) => {
-        const result = evaluateInstance(loadValueProgram({ ...program, root }), input);
+        const result = evaluateInstance(loadValueProgram(program, root), input);
         return result.failures.map((failure) => ({
             code: 'VALUE_SCHEMA_INSTANCE_INVALID',
             pointer: failure.instancePointer,

package/dist/v1/language/value/evaluate/validate.d.ts

@@ -2,11 +2,15 @@ import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import type { Diagnostic } from '../../validation/diagnostic.js';
 import type { JsonSchema } from '../model/schema.js';
 import type { ValueSchemaRegistry } from '../reference/registry.js';
+import type { CompiledInstanceSchema } from './types.js';
+import { type PatternPool } from './preparation.js';
 /**
  * Validate one complete portable value with the admitted V1 Draft 2020-12 profile.
  *
  * Evaluation is an interpreter over the exact local resource closure. It never performs network
- * resolution or dynamic source generation, and every admitted I-Regexp executes through RE2JS.
+ * resolution or dynamic source generation; patterns use the portable executor.
  * `format` remains annotation-only; the graph NodePath codec performs its separate locator check.
  */
-export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string): Diagnostic[];
+export declare function validateJsonInstance(schema: JsonSchema, value: JsonValue, registry: ValueSchemaRegistry, pointer?: string, patterns?: PatternPool): Diagnostic[];
+/** Validate with the exact preparation already retained by a source-resolved Property or Callable. */
+export declare function validatePreparedInstance(compiled: CompiledInstanceSchema, value: unknown): Diagnostic[];