@astrale-os/kernel-dsl 0.2.0-beta.37 → 0.2.0-beta.38

package/dist/v1/compiled/loader/load.js

@@ -2,6 +2,7 @@ import { Key, MethodKey, PropertyKey as PropertyKeyValue } from '../../addressin
 import { compareUnicode } from '../../addressing/ordering.js';
 import { createDomain } from '../../domain/create.js';
 import { combineDomainValidation, createDomainValidation, unknownInputField, } from '../../domain/validation/create.js';
+import { bindValueProgram } from '../../language/value/compile/load.js';
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
 import { acceptCompiledSchema } from '../admission/accept.js';
 export function load(input) {
@@ -68,7 +69,9 @@ function loadEntry(entry) {
             ...entry.definitions.views,
             ...entry.definitions.core,
         ]),
-        validation: programValidation(entry.values, propertyPrograms, propertyOrdering, callablePrograms),
+        validation: programValidation('patterns' in entry
+            ? entry.values.map((value) => bindValueProgram(value, entry.patterns))
+            : entry.values, propertyPrograms, propertyOrdering, callablePrograms),
     };
 }
 function loadMethod(entry, value) {

package/dist/v1/compiled/model/schema.d.ts

@@ -6,10 +6,10 @@ import type { ClassDefinition } from '../../language/class/model/class.js';
 import type { PropertyDefinition } from '../../language/class/model/property.js';
 import type { CoreDefinition, CoreEdge } from '../../language/core/model/core.js';
 import type { PolicyDefinition } from '../../language/policy/model/policy.js';
-import type { ValueProgram } from '../../language/value/compile/model.js';
+import type { IndexedValueProgram, Pattern, RunPattern } from '../../language/value/compile/model.js';
 import type { OrderingKind } from '../../language/value/ordering.js';
 import type { ViewDefinition } from '../../language/view/model/view.js';
-export type { Pattern, PatternState, PatternTransition, ScalarRange, ValueNode, ValueProgram, } from '../../language/value/compile/model.js';
+export type { Pattern, PatternState, PatternTransition, RunPattern, ScalarRun, ScalarRange, IndexedValueProgram, ValueNode, ValueProgram, } from '../../language/value/compile/model.js';
 export interface CompiledProperty extends Omit<PropertyDefinition, 'schema'> {
     readonly name: string;
     readonly value: number;
@@ -60,12 +60,13 @@ export interface CompiledSchemaEntry {
     readonly facts: {
         readonly core: readonly CoreEdge[];
     };
-    readonly values: readonly ValueProgram[];
+    readonly values: readonly IndexedValueProgram[];
+    readonly patterns: readonly (Pattern | RunPattern)[];
 }
 declare const COMPILED_DOMAIN: unique symbol;
 export interface CompiledSchema<Resolved = Domain> {
     readonly format: 'astrale.dsl.compiled-schema';
-    readonly version: 1;
+    readonly version: 2;
     readonly root: DomainDependency;
     readonly closure: readonly CompiledSchemaEntry[];
     readonly [COMPILED_DOMAIN]: Resolved;

package/dist/v1/domain/create.js

@@ -1,4 +1,4 @@
-import { Key } from '../addressing/index.js';
+import { Key, MethodKey } from '../addressing/index.js';
 import { frozenRecord } from './namespace/member-collection.js';
 import { createClasses } from './projection/classes.js';
 const admittedDomains = new WeakSet();
@@ -58,14 +58,13 @@ export function createDomain(input) {
             if (classValue?.kind !== 'edge') {
                 throw new TypeError(`Core Edge has no Edge Class ${Key.of(edge.class)}.`);
             }
+            const endpoint = (ref) => ref.kind === 'domain'
+                ? domainEndpoint
+                : requiredCoreEndpoint(definitionsByKey, callables, ref);
             return Object.freeze({
                 class: classValue,
-                source: edge.source.kind === 'domain'
-                    ? domainEndpoint
-                    : requiredCore(definitionsByKey, edge.source),
-                target: edge.target.kind === 'domain'
-                    ? domainEndpoint
-                    : requiredCore(definitionsByKey, edge.target),
+                source: endpoint(edge.source),
+                target: endpoint(edge.target),
                 properties: edge.properties,
             });
         }));
@@ -241,9 +240,18 @@ function namespace(definitions, kind) {
         .filter((value) => value.ref.kind === kind)
         .map((value) => [value.ref.name, value]));
 }
-function requiredCore(definitions, ref) {
+/** Every non-Domain Core endpoint addresses one already-resolved local Definition or Method. */
+function requiredCoreEndpoint(definitions, callables, ref) {
+    if (ref.kind === 'method') {
+        const key = MethodKey.of(ref.owner, ref.name);
+        const method = callables.get(key);
+        if (method === undefined || !('owner' in method)) {
+            throw new TypeError(`Core endpoint ${key} is absent.`);
+        }
+        return method;
+    }
     const value = definitions.get(Key.of(ref));
-    if (value?.ref.kind !== 'core')
+    if (value === undefined)
         throw new TypeError(`Core endpoint ${Key.of(ref)} is absent.`);
     return value;
 }

package/dist/v1/index.d.ts

@@ -4,7 +4,7 @@ export { stateMachine } from './language/state/index.js';
 export type { EventOf, StateMachine, StateOf } from './language/state/index.js';
 export { PropertyValues } from './language/index.js';
 export * as metadata from './language/definition/metadata.js';
-export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, MethodDefinition, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
+export type { AnyResolvedClass, BoundMethodOf, BoundMethodShortcutsOf, CallableResultOf, CallableInputOf, CallableOutputOf, ClassSatisfactionKeysOf, ClassDefinition, CoreDefinition, CoreEdge, FunctionAuth, FunctionDefinition, MethodDefinition, MethodOwnerKeyOf, PolicyCheckExpression, PolicyDefinition, PropertyInputOf, PropertyAccessOf, PropertyOutputOf, PropertyShortcutsOf, PropertyValuesOf, ResolvedClass, ResolvedCoreDefinition, ResolvedCoreEndpoint, ResolvedData, ResolvedFunction, ExecutableMethod, ResolvedMethod, ResolvedMethodCollection, ResolvedPolicy, ResolvedProperty, ResolvedView, MethodAccessOf, SelfMethodsOf, SelfPropertiesOf, SelfStaticMethodsOf, StaticMethodsOf, ViewDefinition, } from './language/index.js';
 export { acceptDefinitionRef, callableAddress, ClassKey, equalDefinitionRefs, isDefinitionRef, Key, MethodKey, PropertyKey, } from './addressing/index.js';
 export type { ClassRef, CoreRef, DefinitionBase, DefinitionKey, DefinitionRef, FunctionRef, MethodAddress, PolicyRef, Revision, ViewRef, } from './addressing/index.js';
 export type { Definition } from './language/index.js';

package/dist/v1/language/core/model/core.d.ts

@@ -1,9 +1,15 @@
 import type { ClassRef, CoreRef, DefinitionBase } from '../../../addressing/index.js';
 import type { PropertyValues } from '../../class/property-values.js';
+import type { PolicyObjectRef } from '../../policy/model/policy.js';
 export interface DomainEndpointRef {
     readonly kind: 'domain';
 }
-export type CoreEndpointRef = CoreRef | DomainEndpointRef;
+/**
+ * One Core Edge endpoint: the owning Domain itself, or any local Definition whose installed
+ * projection resolves through an exact member Path. That is the same projected-member vocabulary
+ * a Policy object names, so both languages address one identity the same way.
+ */
+export type CoreEndpointRef = PolicyObjectRef | DomainEndpointRef;
 export interface CoreDefinition extends DefinitionBase<CoreRef> {
     readonly class: ClassRef;
     readonly properties: PropertyValues;

package/dist/v1/language/core/resolved.d.ts

@@ -1,6 +1,8 @@
 import type { DefinitionKey } from '../../addressing/index.js';
+import type { ResolvedMethod } from '../callable/resolved.js';
 import type { PropertyValues } from '../class/property-values.js';
 import type { ResolvedClass } from '../class/resolved.js';
+import type { ResolvedDefinition } from '../resolved.js';
 import type { CoreDefinition } from './model/core.js';
 export interface ResolvedCoreDefinition {
     readonly ref: CoreDefinition['ref'];
@@ -13,9 +15,11 @@ export interface ResolvedDomainEndpoint {
     readonly kind: 'domain';
     readonly origin: string;
 }
+/** The owning Domain, one local Definition, or one local Class-owned Method. */
+export type ResolvedCoreEndpoint = ResolvedDefinition | ResolvedMethod | ResolvedDomainEndpoint;
 export interface ResolvedCoreEdge {
     readonly class: ResolvedClass<'edge'>;
-    readonly source: ResolvedCoreDefinition | ResolvedDomainEndpoint;
-    readonly target: ResolvedCoreDefinition | ResolvedDomainEndpoint;
+    readonly source: ResolvedCoreEndpoint;
+    readonly target: ResolvedCoreEndpoint;
     readonly properties: PropertyValues;
 }

package/dist/v1/language/index.d.ts

@@ -21,7 +21,7 @@ export type { Definition } from './definition.js';
 export type { ResolvedDefinition, ResolvedDefinitionOf } from './resolved.js';
 export type { Diagnostic, DiagnosticCode } from './validation/diagnostic.js';
 export type * from './policy/model/policy.js';
-export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './policy/model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';
 export type * from './policy/resolved.js';
 export type * from './view/model/view.js';
 export type * from './view/resolved.js';

package/dist/v1/language/index.js

@@ -1,4 +1,4 @@
 export { isMethodExecutable } from './callable/executable.js';
 export { stateMachine } from './state/index.js';
 export { PropertyValues } from './class/property-values.js';
-export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './policy/model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './policy/model/policy.js';

package/dist/v1/language/policy/index.d.ts

@@ -1,4 +1,4 @@
 export type * from './model/policy.js';
-export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './model/policy.js';
 export type * from './resolved.js';
 export * from './normalization/normalize.js';

package/dist/v1/language/policy/index.js

@@ -1,2 +1,2 @@
-export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, } from './model/policy.js';
+export { policyVariableClass, policyVariableSelector, policyObjectKey, policyObjectOrigin, projectedMemberClass, } from './model/policy.js';
 export * from './normalization/normalize.js';

package/dist/v1/language/policy/model/policy.d.ts

@@ -89,6 +89,7 @@ export type PolicyObjectRef = ClassRef | FunctionRef | PolicyRef | ViewRef | Cor
 /** Exact projected identity, including Class-owned Method declarations. */
 export declare function policyObjectKey(ref: PolicyObjectRef): string;
 export declare function policyObjectOrigin(ref: PolicyObjectRef): string;
+export declare function projectedMemberClass(ref: Exclude<PolicyObjectRef, CoreRef>): ClassRef;
 export type PolicyCheckObject = {
     readonly kind: 'self';
 } | {

package/dist/v1/language/policy/model/policy.js

@@ -16,3 +16,20 @@ export function policyObjectKey(ref) {
 export function policyObjectOrigin(ref) {
     return ref.kind === 'method' ? ref.owner.origin : ref.origin;
 }
+/**
+ * The Kernel declaration Class each projected member materializes as. A Core Node is absent: it
+ * keeps the concrete Class its own Domain authored, which only that Domain's schema can resolve.
+ */
+const PROJECTED_MEMBER_CLASSES = Object.freeze({
+    class: kernelClassRef('Class'),
+    function: kernelClassRef('Function'),
+    method: kernelClassRef('Function'),
+    policy: kernelClassRef('Policy'),
+    view: kernelClassRef('View'),
+});
+export function projectedMemberClass(ref) {
+    return PROJECTED_MEMBER_CLASSES[ref.kind];
+}
+function kernelClassRef(name) {
+    return Object.freeze({ origin: 'kernel.astrale.ai', kind: 'class', name });
+}

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,7 +1,7 @@
 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) {
@@ -154,12 +154,17 @@ 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)) {
             failures.push(invalid(instancePointer, 'pattern', 'String does not match pattern.'));

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[];

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

@@ -1,31 +1,41 @@
 import { diagnostic } from '../../validation/diagnostic.js';
 import { validateCanonicalJsonDomain } from '../profile/json.validate.js';
 import { evaluateInstance } from './evaluator.js';
-import { prepareValueSchema } from './preparation.js';
+import { prepareValueSchema, } from './preparation.js';
 const validatorCache = new WeakMap();
 /**
  * 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 function validateJsonInstance(schema, value, registry, pointer = '') {
+export function validateJsonInstance(schema, value, registry, pointer = '', patterns) {
     const diagnostics = [...validateCanonicalJsonDomain(value, pointer)];
     if (diagnostics.length > 0)
         return diagnostics;
-    const prepared = preparedInstanceValidator(schema, registry, pointer);
-    if (prepared.kind === 'error') {
+    const prepared = preparedInstanceValidator(schema, registry, pointer, patterns);
+    if (!prepared.compiled) {
         return [
             diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Value validation failed closed while preparing exact schema resources: ${prepared.message}.`),
         ];
     }
-    const result = evaluateInstance(prepared.compiled, value);
+    return instanceDiagnostics(prepared.value, value, pointer);
+}
+/** Validate with the exact preparation already retained by a source-resolved Property or Callable. */
+export function validatePreparedInstance(compiled, value) {
+    const diagnostics = [...validateCanonicalJsonDomain(value, '')];
+    return diagnostics.length > 0
+        ? diagnostics
+        : instanceDiagnostics(compiled, value, '');
+}
+function instanceDiagnostics(compiled, value, pointer) {
+    const result = evaluateInstance(compiled, value);
     if (result.valid)
         return [];
     return result.failures.map((failure) => diagnostic('VALUE_SCHEMA_INSTANCE_INVALID', `${pointer}${failure.instancePointer}`, `Value does not satisfy its complete V1 schema at ${failure.keyword}: ${failure.message}`));
 }
-function preparedInstanceValidator(schema, registry, pointer) {
+function preparedInstanceValidator(schema, registry, pointer, patterns) {
     let bySchema = validatorCache.get(registry);
     if (bySchema === undefined) {
         bySchema = new Map();
@@ -34,10 +44,7 @@ function preparedInstanceValidator(schema, registry, pointer) {
     const cached = bySchema.get(schema);
     if (cached !== undefined)
         return cached;
-    const compilation = prepareValueSchema(schema, registry, pointer);
-    const prepared = compilation.compiled
-        ? { kind: 'validator', compiled: compilation.value }
-        : { kind: 'error', message: compilation.message };
+    const prepared = prepareValueSchema(schema, registry, pointer, patterns);
     bySchema.set(schema, prepared);
     return prepared;
 }

package/dist/v1/language/value/ordering.d.ts

@@ -1,4 +1,5 @@
 import type { ValueProgram } from './compile/model.js';
+import type { CompiledInstanceSchema } from './evaluate/types.js';
 import type { JsonSchema } from './model/schema.js';
 import type { ValueSchemaRegistry } from './reference/registry.js';
 export type OrderingKind = 'boolean' | 'number' | 'string' | 'instant';
@@ -11,3 +12,4 @@ export type OrderingKind = 'boolean' | 'number' | 'string' | 'instant';
 export declare function classifyOrdering(contract: JsonSchema, registry: ValueSchemaRegistry): OrderingKind | undefined;
 /** Recompute the scalar ordering classification from one admitted portable value program. */
 export declare function classifyValueProgramOrdering(program: ValueProgram): OrderingKind | undefined;
+export declare function classifyPreparedOrdering(compiled: CompiledInstanceSchema): OrderingKind | undefined;

package/dist/v1/language/value/ordering.js

@@ -18,17 +18,13 @@ export function classifyOrdering(contract, registry) {
     const prepared = prepareValueSchema(contract, registry, '');
     if (!prepared.compiled)
         return undefined;
-    const candidates = new OrderingClassifier(prepared.value).classify(prepared.value.root);
-    if (candidates.size !== 1)
-        return undefined;
-    const [kind] = candidates;
-    return kind === 'boolean' || kind === 'number' || kind === 'string' || kind === 'instant'
-        ? kind
-        : undefined;
+    return classifyPreparedOrdering(prepared.value);
 }
 /** Recompute the scalar ordering classification from one admitted portable value program. */
 export function classifyValueProgramOrdering(program) {
-    const compiled = loadValueProgram(program);
+    return classifyPreparedOrdering(loadValueProgram(program));
+}
+export function classifyPreparedOrdering(compiled) {
     const candidates = new OrderingClassifier(compiled).classify(compiled.root);
     if (candidates.size !== 1)
         return undefined;

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

@@ -1,3 +1,3 @@
-import type { Pattern } from '../compile/model.js';
-/** Compile one admitted I-Regexp AST to portable Thompson-NFA data. */
-export declare function compilePattern(source: string): Pattern;
+import type { Pattern, RunPattern } from '../compile/model.js';
+/** Compile scalar sequences as counted runs; preserve the NFA for branching expressions. */
+export declare function compilePattern(source: string): Pattern | RunPattern;