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

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/callable/composition.d.ts

@@ -10,6 +10,18 @@ export interface MethodComposition<Method> {
     readonly frontier: ReadonlyMap<string, Method>;
     readonly methods: ReadonlyMap<string, Method>;
 }
+/** Structured failure facts; human diagnostic wording is not compatibility evidence. */
+export type MethodCompositionIssue = {
+    readonly kind: 'signature';
+    readonly local: string;
+    readonly required: string;
+} | {
+    readonly kind: 'ambiguous';
+    readonly methods: readonly [string, string];
+} | {
+    readonly kind: 'missing';
+    readonly required: string;
+};
 /** Concrete implementations never discharge a descendant's abstract obligations. */
-export declare function composeMethods<Method extends MethodMember>(parents: readonly MethodComposition<Method>[], own: ReadonlyMap<string, Method>, abstract: boolean, sameSignature: (left: Method, right: Method) => boolean, report: (message: string) => void): MethodComposition<Method>;
+export declare function composeMethods<Method extends MethodMember>(parents: readonly MethodComposition<Method>[], own: ReadonlyMap<string, Method>, abstract: boolean, sameSignature: (left: Method, right: Method) => boolean, report: (message: string, issue: MethodCompositionIssue) => void): MethodComposition<Method>;
 export {};

package/dist/v1/language/callable/composition.js

@@ -5,7 +5,11 @@ export function composeMethods(parents, own, abstract, sameSignature, report) {
     for (const required of requirements.values()) {
         const local = own.get(required.name);
         if (local !== undefined && !sameSignature(local, required)) {
-            report(`Method ${local.key} does not exactly preserve abstract signature ${required.key}.`);
+            report(`Method ${local.key} does not exactly preserve abstract signature ${required.key}.`, {
+                kind: 'signature',
+                local: local.key,
+                required: required.key,
+            });
         }
     }
     for (const local of own.values()) {
@@ -22,7 +26,10 @@ export function composeMethods(parents, own, abstract, sameSignature, report) {
     for (const inherited of frontier.values()) {
         const prior = methods.get(inherited.name);
         if (prior !== undefined && !own.has(inherited.name)) {
-            report(`Inherited Method ${inherited.name} is ambiguous: ${prior.key}, ${inherited.key}.`);
+            report(`Inherited Method ${inherited.name} is ambiguous: ${prior.key}, ${inherited.key}.`, {
+                kind: 'ambiguous',
+                methods: [prior.key, inherited.key],
+            });
         }
         methods.set(inherited.name, inherited);
     }
@@ -34,7 +41,10 @@ export function composeMethods(parents, own, abstract, sameSignature, report) {
             const local = own.get(required.name);
             if (local === undefined && !missing.has(required.name)) {
                 missing.add(required.name);
-                report(`Concrete Class requires a local Method declaration of ${required.key}.`);
+                report(`Concrete Class requires a local Method declaration of ${required.key}.`, {
+                    kind: 'missing',
+                    required: required.key,
+                });
             }
         }
     }

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,15 +1,21 @@
 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();
+    searchResults = new Map();
+    fullMatchResults = new Map();
+    patternResultCount = 0;
     constructor(compiled) {
         this.compiled = compiled;
     }
@@ -79,14 +85,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) {
@@ -154,18 +166,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 +301,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 +365,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 {};