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

package/dist/v1/builder/core/authoring.d.ts

@@ -1,6 +1,6 @@
 import type { Object as JsonObject } from '@astrale-os/kernel-dsl/value';
-import type { CoreRef } from '../../addressing/index.js';
 import type { DomainEndpointRef } from '../../language/core/model/core.js';
+import type { PolicyObjectInput } from '../callable/authoring.js';
 import type { EdgeClass, NodeClass } from '../class/authoring.js';
 import type { AUTHORING } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
@@ -18,7 +18,12 @@ interface CoreEdgeConfiguration {
 export interface CoreNode {
     readonly [AUTHORING]: 'core-node';
 }
-export type CoreEndpoint = CoreNode | CoreRef | DomainEndpointRef;
+/**
+ * The owning Domain, or any local Definition of it: a Class, Function, Method, Policy, View, or
+ * Core Node, authored as a handle, a lazy handle, or its canonical ref. A lazy handle lets a Core
+ * Edge name a declaration that only exists later in a module cycle.
+ */
+export type CoreEndpoint = PolicyObjectInput | DomainEndpointRef;
 export interface CoreEdge {
     readonly [AUTHORING]: 'core-edge';
 }

package/dist/v1/builder/lowering/schema/context.d.ts

@@ -1,4 +1,4 @@
-import type { CoreRef, ClassRef, DefinitionRef, FunctionRef, PolicyRef, ViewRef } from '../../../addressing/index.js';
+import type { ClassRef, DefinitionRef, FunctionRef, PolicyRef, ViewRef } from '../../../addressing/index.js';
 import type { DomainDependency } from '../../../addressing/index.js';
 import type { ClassKind } from '../../../language/class/model/class.js';
 import type { CoreEndpointRef } from '../../../language/core/model/core.js';
@@ -7,7 +7,7 @@ import type { ValueSchemaRegistry } from '../../../language/value/reference/regi
 import type { DomainSchema, DomainSchemaIR } from '../../../schema/model/schema.js';
 import type { Function, PolicyObjectInput } from '../../callable/authoring.js';
 import type { Class, ClassReferenceInput } from '../../class/authoring.js';
-import type { CoreNode } from '../../core/authoring.js';
+import type { CoreEndpoint, CoreNode } from '../../core/authoring.js';
 import type { Policy } from '../../policy/authoring.js';
 import type { View } from '../../view/authoring.js';
 import { type Lazy } from '../../schema/lazy.js';
@@ -19,7 +19,6 @@ export declare class BuilderContext {
     readonly localDefinitions: Map<string, DefinitionRef<import("../../../addressing/definition-ref.js").Definition.Kind, string>>;
     readonly localClassKinds: Map<string, ClassKind>;
     readonly policies: Map<object, PolicyRef>;
-    readonly coreNodes: Map<CoreNode, CoreRef>;
     readonly policyObjects: Map<object, PolicyObjectRef>;
     readonly policyObjectRefs: Set<string>;
     readonly usedForeignOrigins: Set<string>;
@@ -34,7 +33,13 @@ export declare class BuilderContext {
     resolveEdgeClass(input: ClassReferenceInput, pointer: string): ClassRef;
     resolvePolicy(input: Lazy<unknown>, pointer: string): PolicyRef;
     resolvePolicyObject(input: PolicyObjectInput | PolicyObjectRef, pointer: string): PolicyObjectRef;
-    resolveCoreEndpoint(value: CoreNode | CoreEndpointRef, pointer: string): CoreEndpointRef;
+    /** A Core fact belongs to the Domain that declares it, so a dependency endpoint never resolves. */
+    resolveCoreEndpoint(input: CoreEndpoint, pointer: string): CoreEndpointRef;
+    /**
+     * The shared lookup from one already-resolved authoring value to its ref; each caller owns its
+     * own admission rule and diagnostic.
+     */
+    private policyObjectRef;
     dependencies(): Readonly<Record<string, DomainDependency>>;
     valueRegistry(): ValueSchemaRegistry;
     noteDomainEndpointReferences(schema: DomainSchemaIR): void;

package/dist/v1/builder/lowering/schema/context.js

@@ -15,7 +15,6 @@ export class BuilderContext {
     localDefinitions = new Map();
     localClassKinds = new Map();
     policies = new Map();
-    coreNodes = new Map();
     policyObjects = new Map();
     policyObjectRefs = new Set();
     usedForeignOrigins = new Set();
@@ -59,7 +58,6 @@ export class BuilderContext {
     captureCoreNode(value, slug, pointer) {
         const ref = { origin: this.origin, kind: 'core', name: slug };
         this.ownership.captureDefinition(value, ref, pointer);
-        this.coreNodes.set(value, ref);
         this.capturePolicyObject(value, ref);
     }
     captureFunction(value, ref, pointer) {
@@ -110,12 +108,7 @@ export class BuilderContext {
         return { ...ref };
     }
     resolvePolicyObject(input, pointer) {
-        const value = resolveLazy(input, pointer);
-        const ref = isPolicyObjectRef(value)
-            ? value
-            : typeof value === 'object' && value !== null
-                ? (this.policyObjects.get(value) ?? this.ownership.definition(value))
-                : undefined;
+        const ref = this.policyObjectRef(resolveLazy(input, pointer));
         const origin = ref === undefined ? undefined : policyObjectOrigin(ref);
         const dependency = origin === undefined ? undefined : this.#dependencies.get(origin)?.schema;
         const admitted = ref !== undefined &&
@@ -130,15 +123,30 @@ export class BuilderContext {
             this.usedForeignOrigins.add(admittedOrigin);
         return { ...ref };
     }
-    resolveCoreEndpoint(value, pointer) {
+    /** A Core fact belongs to the Domain that declares it, so a dependency endpoint never resolves. */
+    resolveCoreEndpoint(input, pointer) {
+        const value = resolveLazy(input, pointer);
         if (isDomainEndpointRef(value))
             return { kind: 'domain' };
-        const ref = isCoreRef(value) ? value : this.coreNodes.get(value);
-        if (ref === undefined || ref.origin !== this.origin) {
-            fail('BUILDER_CORE_REF', pointer, 'A Core reference must name a registered local Core Node.');
+        const ref = this.policyObjectRef(value);
+        if (ref === undefined ||
+            policyObjectOrigin(ref) !== this.origin ||
+            !this.policyObjectRefs.has(policyObjectKey(ref))) {
+            fail('BUILDER_CORE_REF', pointer, 'A Core Edge endpoint must name one registered local Definition, Function, Method, Policy, View, or Core Node.');
         }
         return { ...ref };
     }
+    /**
+     * The shared lookup from one already-resolved authoring value to its ref; each caller owns its
+     * own admission rule and diagnostic.
+     */
+    policyObjectRef(value) {
+        if (isPolicyObjectRef(value))
+            return value;
+        return typeof value === 'object' && value !== null
+            ? (this.policyObjects.get(value) ?? this.ownership.definition(value))
+            : undefined;
+    }
     dependencies() {
         return Object.fromEntries([...this.#dependencies.values()]
             .sort((left, right) => compareUnicode(left.alias, right.alias))
@@ -226,14 +234,6 @@ function isDefinitionRef(value) {
         typeof candidate.name === 'string' &&
         candidate.kind === 'class');
 }
-function isCoreRef(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const candidate = value;
-    return (typeof candidate.origin === 'string' &&
-        candidate.kind === 'core' &&
-        typeof candidate.name === 'string');
-}
 function isPolicyObjectRef(value) {
     if (typeof value !== 'object' || value === null)
         return false;

package/dist/v1/builder/policy/authoring.d.ts

@@ -1,12 +1,12 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { PolicyCheckExpression, PolicyPatternExpression, PolicyPatternTerm as CanonicalPolicyPatternTerm, PolicyObjectRef } from '../../language/policy/model/policy.js';
 import type { PolicyObjectInput } from '../callable/authoring.js';
-import type { EdgeClass, NodeClass } from '../class/authoring.js';
+import type { EdgeClassReferenceInput, NodeClassReferenceInput } from '../class/authoring.js';
 import type { AuthoringValue } from '../schema/handle.js';
 import type { Lazy } from '../schema/lazy.js';
 export interface PolicyEdgeInput {
     readonly source: CanonicalPolicyPatternTerm;
-    readonly class: Lazy<EdgeClass>;
+    readonly class: EdgeClassReferenceInput;
     readonly target: CanonicalPolicyPatternTerm;
     readonly repeat?: {
         readonly min: number;
@@ -15,8 +15,8 @@ export interface PolicyEdgeInput {
 }
 export interface PolicyNodeBinder {
     (): CanonicalPolicyPatternTerm;
-    (definition: Lazy<NodeClass>): CanonicalPolicyPatternTerm;
-    readonly exact: (definition: Lazy<NodeClass>) => CanonicalPolicyPatternTerm;
+    (definition: NodeClassReferenceInput): CanonicalPolicyPatternTerm;
+    readonly exact: (definition: NodeClassReferenceInput) => CanonicalPolicyPatternTerm;
 }
 export interface PolicyExistsContext {
     readonly node: PolicyNodeBinder;
@@ -54,8 +54,8 @@ export declare function policyDeclaration(value: Policy): PolicyDeclaration;
 export declare const policy: PolicyBuilder;
 export declare function createPatternContext(options: {
     readonly resolveObject: (value: PolicyObjectInput, pointer: string) => PolicyObjectRef;
-    readonly resolveEdgeClass: (value: Lazy<EdgeClass>, pointer: string) => ClassRef;
-    readonly resolveNodeClass: (value: Lazy<NodeClass>, pointer: string) => ClassRef;
+    readonly resolveEdgeClass: (value: EdgeClassReferenceInput, pointer: string) => ClassRef;
+    readonly resolveNodeClass: (value: NodeClassReferenceInput, pointer: string) => ClassRef;
     readonly pointer: string;
 }): PolicyPatternContext;
 export type { PolicyCheckExpression };

package/dist/v1/builder/policy/authoring.js

@@ -71,7 +71,9 @@ export function createPatternContext(options) {
                 if (args.length > 1 || (args.length === 1 && args[0] === undefined)) {
                     fail('BUILDER_POLICY', `${options.pointer}/match/exists/nodes`, 'node(...) accepts either no arguments or one Node Class.');
                 }
-                return args.length === 0 ? bind('any') : bind('satisfies', args[0]);
+                return args.length === 0
+                    ? bind('any')
+                    : bind('satisfies', args[0]);
             };
             Object.defineProperty(node, 'exact', {
                 enumerable: true,

package/dist/v1/compiled/admission/accept.js

@@ -5,6 +5,8 @@ import { DEPENDENCY_ALIAS_PATTERN, DOMAIN_ORIGIN_PATTERN, DOMAIN_REVISION_PATTER
 import { MEDIA_TYPE_PATTERN } from '../../language/class/model/data.js';
 import { PropertyValues } from '../../language/class/property-values.js';
 import { admitStateTopology } from '../../language/state/topology.js';
+import { bindValueProgram } from '../../language/value/compile/load.js';
+import { isValueObject } from '../../language/value/model/object.js';
 import { classifyValueProgramOrdering } from '../../language/value/ordering.js';
 import { invalidCompiled } from '../diagnostic.js';
 import { revisionOfCompiledEntry } from './revision.js';
@@ -19,10 +21,11 @@ export function acceptCompiledSchema(input) {
     exact(root, ['format', 'version', 'root', 'closure'], 'CompiledSchema', '');
     if (root.format !== 'astrale.dsl.compiled-schema')
         invalid('format', undefined, '/format');
-    if (root.version !== 1)
+    if (root.version !== 1 && root.version !== 2)
         invalid('version', undefined, '/version');
+    const version = root.version;
     const rootPin = dependency(root.root, 'root', '/root');
-    const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`));
+    const closure = array(root.closure, 'closure', '/closure').map((value, index) => entry(value, index, `/closure/${index}`, version));
     if (closure.length > dependencyLimits.closure) {
         invalid('dependency closure limit', 'COMPILED_DEPENDENCY_LIMITS', '/closure');
     }
@@ -64,7 +67,7 @@ export function acceptCompiledSchema(input) {
     }
     const candidate = {
         format: 'astrale.dsl.compiled-schema',
-        version: 1,
+        version: 2,
         root: rootPin,
         closure,
     };
@@ -72,9 +75,17 @@ export function acceptCompiledSchema(input) {
     validateCompiledSemantics(candidate);
     return deepFreeze(candidate);
 }
-function entry(input, entryIndex, path) {
+function entry(input, entryIndex, path, version) {
     const value = object(input, `closure[${entryIndex}]`, path);
-    exact(value, ['origin', 'revision', 'dependencies', 'definitions', 'facts', 'values'], 'entry', path);
+    exact(value, [
+        'origin',
+        'revision',
+        'dependencies',
+        'definitions',
+        'facts',
+        'values',
+        ...(version === 2 ? ['patterns'] : []),
+    ], 'entry', path);
     const origin = originValue(value.origin, 'entry origin', `${path}/origin`);
     const revision = revisionValue(value.revision, 'entry revision', `${path}/revision`);
     const dependenciesPath = `${path}/dependencies`;
@@ -86,14 +97,19 @@ function entry(input, entryIndex, path) {
         dependencyOrigins.add(dependency.origin);
     }
     const valuesPath = `${path}/values`;
-    const values = array(value.values, 'values', valuesPath).map((item, index) => program(item, index, `${valuesPath}/${index}`));
+    const patternsPath = `${path}/patterns`;
+    const patterns = version === 2
+        ? array(value.patterns, 'entry patterns', patternsPath).map((item, index) => pattern(item, index, `${patternsPath}/${index}`, true))
+        : [];
+    const values = array(value.values, 'values', valuesPath).map((item, index) => program(item, index, `${valuesPath}/${index}`, patterns, version));
+    const bound = values.map((value) => bindValueProgram(value, patterns));
     const definitionsPath = `${path}/definitions`;
     const definitions = object(value.definitions, 'definitions', definitionsPath);
     exact(definitions, ['classes', 'functions', 'policies', 'views', 'core'], 'definitions', definitionsPath);
     const classesPath = `${definitionsPath}/classes`;
-    const classes = array(definitions.classes, 'classes', classesPath).map((item, index) => compiledClass(item, values, `${classesPath}/${index}`));
+    const classes = array(definitions.classes, 'classes', classesPath).map((item, index) => compiledClass(item, bound, `${classesPath}/${index}`));
     const functionsPath = `${definitionsPath}/functions`;
-    const functions = array(definitions.functions, 'functions', functionsPath).map((item, index) => compiledFunction(item, values, `${functionsPath}/${index}`));
+    const functions = array(definitions.functions, 'functions', functionsPath).map((item, index) => compiledFunction(item, bound, `${functionsPath}/${index}`));
     const factsPath = `${path}/facts`;
     const facts = object(value.facts, 'facts', factsPath);
     exact(facts, ['core'], 'facts', factsPath);
@@ -116,6 +132,7 @@ function entry(input, entryIndex, path) {
             core: array(facts.core, 'core facts', coreFactsPath).map((item, index) => compiledCoreEdge(item, `${coreFactsPath}/${index}`)),
         },
         values,
+        patterns,
     };
     const collections = [
         ['classes', accepted.definitions.classes],
@@ -554,18 +571,20 @@ function coreEndpoint(input, label, path) {
     if (value.kind === 'domain')
         exact(value, ['kind'], label, path);
     else
-        definitionRef(value, 'core', label, path);
+        projectedMemberRef(value, label, path);
 }
 function policyObjectRef(input, path) {
-    const ref = object(input, 'Policy object ref', path);
+    projectedMemberRef(object(input, 'Policy object ref', path), 'Policy object ref', path);
+}
+function projectedMemberRef(ref, label, path) {
     if (ref.kind !== 'method') {
-        definitionRef(input, undefined, 'Policy object ref', path);
+        definitionRef(ref, undefined, label, path);
         return;
     }
-    exact(ref, ['kind', 'owner', 'name'], 'Policy Method ref', path);
-    definitionRef(ref.owner, 'class', 'Policy Method owner', `${path}/owner`);
+    exact(ref, ['kind', 'owner', 'name'], `${label} Method`, path);
+    definitionRef(ref.owner, 'class', `${label} Method owner`, `${path}/owner`);
     if (typeof ref.name !== 'string' || !MEMBER_NAME_PATTERN.test(ref.name))
-        invalid('Policy Method name', undefined, `${path}/name`);
+        invalid(`${label} Method name`, undefined, `${path}/name`);
 }
 function definitionRef(input, kind, label, path) {
     if (!isDefinitionRef(input) || (kind !== undefined && input.kind !== kind))
@@ -752,16 +771,35 @@ function walk(input, path, visit) {
     for (const [key, value] of Object.entries(input))
         walk(value, pointer(path, key), visit);
 }
-function program(input, programIndex, path) {
+function program(input, programIndex, path, table, version) {
     const value = object(input, `values[${programIndex}]`, path);
     exact(value, ['root', 'nodes', 'patterns'], 'ValueProgram', path);
     const nodesPath = `${path}/nodes`;
     const nodes = array(value.nodes, 'ValueProgram nodes', nodesPath).map((node, index) => valueNode(node, index, `${nodesPath}/${index}`));
     const root = index(value.root, nodes.length, 'ValueProgram root', `${path}/root`);
     const patternsPath = `${path}/patterns`;
-    const patterns = array(value.patterns, 'ValueProgram patterns', patternsPath).map((item, index) => pattern(item, index, `${patternsPath}/${index}`));
-    unique(patterns.map(({ source }) => source), 'patterns', patternsPath);
+    const patterns = array(value.patterns, 'ValueProgram patterns', patternsPath).map((item, position) => {
+        const patternPath = `${patternsPath}/${position}`;
+        if (version === 2)
+            return index(item, table.length, 'ValueProgram pattern', patternPath);
+        // Legacy programs can carry different machines with the same source label. Preserve each.
+        return table.push(pattern(item, position, patternPath, false)) - 1;
+    });
+    const sources = patterns.map((index) => table[index].source);
+    unique(sources, 'patterns', patternsPath);
+    const available = new Set(sources);
     for (const [nodeIndex, node] of nodes.entries()) {
+        if (isValueObject(node.schema)) {
+            const required = [node.schema.pattern, node.schema.fullMatch];
+            if (isValueObject(node.schema.patternProperties)) {
+                required.push(...Object.keys(node.schema.patternProperties));
+            }
+            for (const source of required) {
+                if (typeof source === 'string' && !available.has(source)) {
+                    invalid('ValueProgram pattern binding', undefined, patternsPath);
+                }
+            }
+        }
         for (const [name, child] of Object.entries(node.children))
             index(child, nodes.length, 'ValueNode child', pointer(`${nodesPath}/${nodeIndex}/children`, name));
         if (node.reference !== undefined)
@@ -785,8 +823,10 @@ function valueNode(input, nodeIndex, path) {
             : { reference: integer(value.reference, 'reference', `${path}/reference`) }),
     };
 }
-function pattern(input, patternIndex, path) {
+function pattern(input, patternIndex, path, counted) {
     const value = object(input, `patterns[${patternIndex}]`, path);
+    if (counted && Object.hasOwn(value, 'runs'))
+        return runPattern(value, path);
     exact(value, ['source', 'start', 'states'], 'Pattern', path);
     if (typeof value.source !== 'string')
         invalid('Pattern source', undefined, `${path}/source`);
@@ -831,6 +871,45 @@ function pattern(input, patternIndex, path) {
     }
     return { source: value.source, start, states };
 }
+function runPattern(value, path) {
+    exact(value, ['source', 'runs'], 'RunPattern', path);
+    if (typeof value.source !== 'string')
+        invalid('Pattern source', undefined, `${path}/source`);
+    const entries = array(value.runs, 'scalar runs', `${path}/runs`);
+    if (entries.length === 0 || entries.length > 4096) {
+        invalid('scalar run count', undefined, `${path}/runs`);
+    }
+    const runs = entries.map((entry, position) => {
+        const runPath = `${path}/runs/${position}`;
+        const run = object(entry, 'scalar run', runPath);
+        exact(run, ['ranges', 'minimum'], 'scalar run', runPath, ['maximum']);
+        const minimum = boundedInteger(run.minimum, 0, 1000, 'run minimum', `${runPath}/minimum`);
+        const maximum = run.maximum === undefined
+            ? undefined
+            : boundedInteger(run.maximum, minimum, 1000, 'run maximum', `${runPath}/maximum`);
+        if (position !== entries.length - 1 && minimum !== maximum) {
+            invalid('exact scalar prefix', undefined, `${runPath}/maximum`);
+        }
+        let previous = -1;
+        const ranges = array(run.ranges, 'scalar ranges', `${runPath}/ranges`).map((entry, index) => {
+            const rangePath = `${runPath}/ranges/${index}`;
+            const range = array(entry, 'scalar range', rangePath);
+            if (range.length !== 2)
+                invalid('scalar range', undefined, rangePath);
+            const minimum = scalar(range[0], 'range minimum', `${rangePath}/0`);
+            const maximum = scalar(range[1], 'range maximum', `${rangePath}/1`);
+            if (minimum > maximum ||
+                minimum <= previous ||
+                (minimum >= 0xd800 && minimum <= 0xdfff) ||
+                (maximum >= 0xd800 && maximum <= 0xdfff))
+                invalid('ordered scalar range', undefined, rangePath);
+            previous = maximum;
+            return [minimum, maximum];
+        });
+        return { ranges, minimum, ...(maximum === undefined ? {} : { maximum }) };
+    });
+    return { source: value.source, runs };
+}
 function dependency(input, label, path) {
     const value = object(input, label, path);
     exact(value, ['origin', 'revision'], label, path);

package/dist/v1/compiled/admission/semantics.js

@@ -3,10 +3,11 @@ import { Key, PropertyKey as PropertyKeyValue } from '../../addressing/index.js'
 import { compareUnicode } from '../../addressing/ordering.js';
 import { composeMethods } from '../../language/callable/composition.js';
 import { isMethodExecutable } from '../../language/callable/executable.js';
-import { policyObjectOrigin, policyVariableClass } from '../../language/index.js';
+import { policyObjectKey, policyObjectOrigin, policyVariableClass, projectedMemberClass, } from '../../language/index.js';
 import { branchesOf, branchProduct, capBranches, isConnected, targetMode, termKey, } from '../../language/policy/analysis/branches.js';
 import { BRANCH_OVERFLOW, MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, MAX_DOMAINS, MAX_EDGES, MAX_PATTERN_DEPTH, MAX_REPEAT, MAX_VARIABLES, measureChecks, } from '../../language/policy/analysis/budgets.js';
 import { normalizePolicyExpression } from '../../language/policy/normalization/normalize.js';
+import { bindValueProgram } from '../../language/value/compile/load.js';
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../language/value/syntax/node-path/schema.js';
 import { invalidCompiled } from '../diagnostic.js';
@@ -140,7 +141,7 @@ function outputKey(entry, output) {
     return output.mode === 'binary' ? 'binary' : `${output.mode}:${programKey(entry, output.value)}`;
 }
 function programKey(entry, value) {
-    return json.serialize(entry.values[value]);
+    return json.serialize(bindValueProgram(entry.values[value], entry.patterns));
 }
 function validateClassFacets(context) {
     for (const located of context.classes.values()) {
@@ -984,8 +985,8 @@ function validateCore(candidate, context) {
             if (analysis === undefined)
                 fail(`${path}/class`, 'Core Edge Class analysis is absent.');
             validateCoreProperties(value.properties, analysis, `${path}/properties`);
-            const source = resolveCoreEndpoint(value.source, nodes, `${path}/source`);
-            const target = resolveCoreEndpoint(value.target, nodes, `${path}/target`);
+            const source = resolveCoreEndpoint(context, entry, value.source, nodes, `${path}/source`);
+            const target = resolveCoreEndpoint(context, entry, value.target, nodes, `${path}/target`);
             const declaration = classValue.value;
             const satisfies = declaration.orientation === 'directed'
                 ? endpointSatisfies(context, source, declaration.endpoints.source.accepts) &&
@@ -1019,21 +1020,44 @@ function validateCoreProperties(values, analysis, path) {
         }
         if (property.declaration.auto !== undefined)
             fail(`${path}/${escapePointer(property.key)}`, 'Core properties cannot author an automatic Property.');
-        if (validateValueProgram(property.entry.values[property.declaration.value], values[property.key])
-            .length > 0)
+        if (validateValueProgram(bindValueProgram(property.entry.values[property.declaration.value], property.entry.patterns), values[property.key]).length > 0)
             fail(`${path}/${escapePointer(property.key)}`, 'Core Property value does not satisfy its exact contract.');
     }
 }
-function resolveCoreEndpoint(ref, nodes, path) {
+function resolveCoreEndpoint(context, entry, ref, nodes, path) {
     if (ref.kind === 'domain')
         return { key: 'domain' };
-    const node = nodes.get(Key.of(ref));
-    if (node === undefined)
-        fail(path, 'Core endpoint does not name a declared local Core Node.');
-    return node;
+    const undeclared = () => fail(path, 'Core endpoint does not name a declared local Definition.');
+    if (policyObjectOrigin(ref) !== entry.origin)
+        return undeclared();
+    if (ref.kind === 'core')
+        return nodes.get(Key.of(ref)) ?? undeclared();
+    if (!declaresProjectedMember(context, entry, ref))
+        return undeclared();
+    return { key: policyObjectKey(ref), class: projectedMemberClass(ref), pointer: path };
+}
+/** Only a projected declaration can carry a Core fact; an abstract Method is never projected. */
+function declaresProjectedMember(context, entry, ref) {
+    if (ref.kind === 'method') {
+        const owner = context.classes.get(Key.of(ref.owner))?.value;
+        const method = owner?.kind === 'node' ? owner.methods.find((value) => value.name === ref.name) : undefined;
+        return method !== undefined && isMethodExecutable(owner, method);
+    }
+    const declarations = ref.kind === 'class'
+        ? entry.definitions.classes
+        : ref.kind === 'function'
+            ? entry.definitions.functions
+            : ref.kind === 'policy'
+                ? entry.definitions.policies
+                : entry.definitions.views;
+    return declarations.some((declaration) => declaration.ref.name === ref.name);
 }
 function endpointSatisfies(context, endpoint, accepts) {
-    return !('value' in endpoint) || classSatisfiesAny(context, endpoint.value.class, accepts);
+    if ('value' in endpoint)
+        return classSatisfiesAny(context, endpoint.value.class, accepts);
+    if ('class' in endpoint)
+        return classSatisfiesAny(context, endpoint.class, accepts);
+    return true;
 }
 function validateCoreEdgeSet(context, entry, entryIndex, nodes, edges) {
     const seen = new Set();
@@ -1064,27 +1088,56 @@ function validateCoreEdgeSet(context, entry, entryIndex, nodes, edges) {
     }
 }
 function validateCardinality(context, declaration, edges, nodes) {
-    for (const node of nodes.values()) {
+    for (const subject of cardinalitySubjects(edges, nodes)) {
         if (declaration.orientation === 'directed') {
-            if (classSatisfiesAny(context, node.value.class, declaration.endpoints.source.accepts))
-                checkCount(declaration.endpoints.source.outgoing, edges.filter(({ source }) => source.key === node.key).length, node.pointer);
-            if (classSatisfiesAny(context, node.value.class, declaration.endpoints.target.accepts))
-                checkCount(declaration.endpoints.target.incoming, edges.filter(({ target }) => target.key === node.key).length, node.pointer);
+            if (classSatisfiesAny(context, subject.class, declaration.endpoints.source.accepts))
+                checkCount(declaration.endpoints.source.outgoing, edges.filter(({ source }) => source.key === subject.key).length, subject.pointer, subject.minimum);
+            if (classSatisfiesAny(context, subject.class, declaration.endpoints.target.accepts))
+                checkCount(declaration.endpoints.target.incoming, edges.filter(({ target }) => target.key === subject.key).length, subject.pointer, subject.minimum);
         }
         else {
-            const degree = edges.filter(({ source, target }) => source.key === node.key || target.key === node.key).length;
+            const degree = edges.filter(({ source, target }) => source.key === subject.key || target.key === subject.key).length;
             const [first, second] = declaration.endpoints;
-            if (classSatisfiesAny(context, node.value.class, first.accepts))
-                checkCount(first.incident, degree, node.pointer);
+            if (classSatisfiesAny(context, subject.class, first.accepts))
+                checkCount(first.incident, degree, subject.pointer, subject.minimum);
             if (!sameIncidentEndpoint(first, second) &&
-                classSatisfiesAny(context, node.value.class, second.accepts))
-                checkCount(second.incident, degree, node.pointer);
+                classSatisfiesAny(context, subject.class, second.accepts))
+                checkCount(second.incident, degree, subject.pointer, subject.minimum);
+        }
+    }
+}
+/**
+ * Every declared Core Node proves its own complete degree, so both bounds hold. A Definition
+ * endpoint is only named by the Edges that reach it: the Domain may also create ordinary Edges of
+ * the same Class against it, so a minimum is unprovable here and only the maximum is enforced.
+ */
+function cardinalitySubjects(edges, nodes) {
+    const subjects = new Map();
+    for (const node of nodes.values()) {
+        subjects.set(node.key, {
+            key: node.key,
+            class: node.value.class,
+            pointer: node.pointer,
+            minimum: true,
+        });
+    }
+    for (const edge of edges) {
+        for (const endpoint of [edge.source, edge.target]) {
+            if ('value' in endpoint || !('class' in endpoint) || subjects.has(endpoint.key))
+                continue;
+            subjects.set(endpoint.key, {
+                key: endpoint.key,
+                class: endpoint.class,
+                pointer: endpoint.pointer,
+                minimum: false,
+            });
         }
     }
+    return Object.freeze([...subjects.values()]);
 }
-function checkCount(count, degree, path) {
+function checkCount(count, degree, path, enforceMinimum) {
     const [minimum, maximum] = countBounds(count);
-    if (degree < minimum || degree > maximum)
+    if (degree > maximum || (degree < minimum && enforceMinimum))
         fail(path, `Core degree ${degree} violates Edge count ${count}.`);
 }
 function countBounds(value) {

package/dist/v1/compiled/compiler/compile.js

@@ -1,6 +1,6 @@
 import { inputFieldNodes } from '../../language/value/compile/fields.js';
 import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
-import { classifyOrdering } from '../../language/value/ordering.js';
+import { classifyPreparedOrdering } from '../../language/value/ordering.js';
 import { revisionOfDomainSchema } from '../../schema/canonical/revision.js';
 import { lookupForDomainClosure, requireDomainClosure } from '../../schema/resolution/closure.js';
 import { createDomainValueSchemaRegistry } from '../../schema/resolution/value.registry.js';
@@ -16,7 +16,7 @@ export function compile(schema) {
     const closure = Object.freeze(sources.map((source) => compileEntry(source, lookup)));
     return Object.freeze({
         format: 'astrale.dsl.compiled-schema',
-        version: 1,
+        version: 2,
         root: Object.freeze({ origin: schema.origin, revision: revisionOfDomainSchema(schema) }),
         closure,
     });
@@ -24,16 +24,31 @@ export function compile(schema) {
 function compileEntry(schema, lookup) {
     const registry = createDomainValueSchemaRegistry(schema, lookup);
     const values = [];
-    const add = (contract, pointer) => {
-        const result = prepareValueSchema(contract, registry, pointer);
+    const pool = new Map();
+    const patternIndices = new Map();
+    const prepare = (contract, pointer) => {
+        const result = prepareValueSchema(contract, registry, pointer, pool);
         if (!result.compiled)
             throw new TypeError(`Cannot compile ValueSchema: ${result.message}`);
-        return values.push(result.value.program()) - 1;
+        return result.value;
     };
+    const addProgram = (program) => {
+        const patterns = program.patterns.map((pattern) => {
+            let index = patternIndices.get(pattern);
+            if (index === undefined) {
+                index = patternIndices.size;
+                patternIndices.set(pattern, index);
+            }
+            return index;
+        });
+        return values.push(Object.freeze({ ...program, patterns: Object.freeze(patterns) })) - 1;
+    };
+    const add = (contract, pointer) => addProgram(prepare(contract, pointer).program());
     const properties = (definition, pointer) => Object.entries(definition.properties)
         .sort(([left], [right]) => compare(left, right))
         .map(([name, property]) => {
-        const ordering = classifyOrdering(property.schema, registry);
+        const prepared = prepare(property.schema, `${pointer}/properties/${name}/schema`);
+        const ordering = classifyPreparedOrdering(prepared);
         return {
             name,
             required: property.required,
@@ -41,7 +56,7 @@ function compileEntry(schema, lookup) {
             ...(property.description === undefined ? {} : { description: property.description }),
             ...(property.state === undefined ? {} : { state: property.state }),
             ...(ordering === undefined ? {} : { ordering }),
-            value: add(property.schema, `${pointer}/properties/${name}/schema`),
+            value: addProgram(prepared.program()),
         };
     });
     const output = (value, pointer) => value.mode === 'binary'
@@ -106,6 +121,7 @@ function compileEntry(schema, lookup) {
         }),
         facts: Object.freeze({ core: schema.core.edges }),
         values: Object.freeze(values),
+        patterns: Object.freeze([...patternIndices.keys()]),
     });
 }
 function compare(left, right) {

package/dist/v1/compiled/loader/load.d.ts

@@ -1,4 +1,12 @@
-import type { CompiledSchema, DomainOfCompiled } from '../model/schema.js';
+import type { ValueProgram } from '../../language/value/compile/model.js';
+import type { CompiledSchema, CompiledSchemaEntry, DomainOfCompiled } from '../model/schema.js';
+type LegacyEntry = Omit<CompiledSchemaEntry, 'values' | 'patterns'> & {
+    readonly values: readonly ValueProgram[];
+};
+type LegacyCompiledSchema = Omit<CompiledSchema, 'version' | 'closure'> & {
+    readonly version: 1;
+    readonly closure: readonly LegacyEntry[];
+};
 /** Load admitted compiled data through the one resolved Domain constructor. */
 export declare function load<const Input extends CompiledSchema>(input: Input): DomainOfCompiled<Input>;
 export declare function load(input: unknown): import('../../domain/model/domain.js').Domain;
@@ -6,4 +14,5 @@ export declare function load(input: unknown): import('../../domain/model/domain.
  * Realize compiled material whose exact embedded bytes were already proven by generated build code.
  * External bytes and caller-provided values must continue through {@link load}.
  */
-export declare function realize(compiled: CompiledSchema): import('../../domain/model/domain.js').Domain;
+export declare function realize(compiled: CompiledSchema | LegacyCompiledSchema): import('../../domain/model/domain.js').Domain;
+export {};