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

package/dist/v1/language/value/profile/json.validate.js

@@ -1,4 +1,4 @@
-import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
+import { acceptForRead as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
 import { diagnostic } from '../../validation/diagnostic.js';
 export function validateCanonicalJsonDomain(value, pointer) {
     try {

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;

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

@@ -1,9 +1,12 @@
 import { parseIRegexp } from './ast.js';
-/** Compile one admitted I-Regexp AST to portable Thompson-NFA data. */
+/** Compile scalar sequences as counted runs; preserve the NFA for branching expressions. */
 export function compilePattern(source) {
     const expression = parseIRegexp(source);
     if (expression === undefined)
         throw new TypeError('Cannot compile an invalid I-Regexp source.');
+    const runs = scalarRuns(expression);
+    if (runs !== undefined)
+        return Object.freeze({ source, runs });
     const builder = new Builder();
     const fragment = builder.expression(expression);
     builder.states[fragment.end].accepting = true;
@@ -13,9 +16,45 @@ export function compilePattern(source) {
         states: Object.freeze(builder.states.map(freezeState)),
     });
 }
+function scalarRuns(expression) {
+    if (expression.alternatives.length !== 1)
+        return undefined;
+    const pieces = expression.alternatives[0].pieces;
+    let counted = false;
+    for (let index = 0; index < pieces.length; index++) {
+        const piece = pieces[index];
+        if (piece.atom.kind !== 'ranges' ||
+            (index !== pieces.length - 1 && piece.minimum !== piece.maximum))
+            return undefined;
+        if (piece.maximum !== undefined && piece.maximum > 1)
+            counted = true;
+    }
+    if (!counted)
+        return undefined;
+    const runs = [];
+    for (const piece of pieces) {
+        if (piece.atom.kind !== 'ranges')
+            return undefined;
+        runs.push(Object.freeze({
+            ranges: freezeRanges(piece.atom.ranges),
+            minimum: piece.minimum,
+            ...(piece.maximum === undefined ? {} : { maximum: piece.maximum }),
+        }));
+    }
+    return Object.freeze(runs);
+}
+function freezeRanges(ranges) {
+    if (Object.isFrozen(ranges))
+        return ranges;
+    for (const range of ranges)
+        Object.freeze(range);
+    return Object.freeze(ranges);
+}
 class Builder {
     states = [];
     expression(expression) {
+        if (expression.alternatives.length === 1)
+            return this.sequence(expression.alternatives[0]);
         const start = this.state();
         const end = this.state();
         for (const alternative of expression.alternatives) {
@@ -26,20 +65,26 @@ class Builder {
         return { start, end };
     }
     sequence(sequence) {
-        let output = this.empty();
-        for (const piece of sequence.pieces)
-            output = this.concat(output, this.piece(piece));
-        return output;
+        let output;
+        for (const piece of sequence.pieces) {
+            const fragment = this.piece(piece);
+            output = output === undefined ? fragment : this.concat(output, fragment);
+        }
+        return output ?? this.empty();
     }
     piece(piece) {
-        let output = this.empty();
+        let output;
         for (let index = 0; index < piece.minimum; index++) {
-            output = this.concat(output, this.atom(piece.atom));
+            const fragment = this.atom(piece.atom);
+            output = output === undefined ? fragment : this.concat(output, fragment);
+        }
+        if (piece.maximum === undefined) {
+            const repeated = this.star(piece.atom);
+            return output === undefined ? repeated : this.concat(output, repeated);
         }
-        if (piece.maximum === undefined)
-            return this.concat(output, this.star(piece.atom));
         if (piece.maximum === piece.minimum)
-            return output;
+            return output ?? this.empty();
+        output ??= this.empty();
         const end = this.state();
         for (let index = piece.minimum; index < piece.maximum; index++) {
             // A shorter repetition exits the whole suffix, rather than skipping arbitrary copies.
@@ -87,7 +132,7 @@ class Builder {
 function freezeState(state) {
     return Object.freeze({
         epsilon: Object.freeze(state.epsilon),
-        transitions: Object.freeze(state.transitions.map((transition) => Object.freeze({ to: transition.to, ranges: Object.freeze(transition.ranges) }))),
+        transitions: Object.freeze(state.transitions.map((transition) => Object.freeze({ to: transition.to, ranges: freezeRanges(transition.ranges) }))),
         ...(state.accepting === true ? { accepting: true } : {}),
     });
 }

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

@@ -1,10 +1,10 @@
-import type { Pattern } from '../compile/model.js';
+import type { Pattern, RunPattern } from '../compile/model.js';
 export interface IRegexpMatcher {
     test(value: string): boolean;
     matches(value: string): boolean;
 }
 /**
- * Load the portable Thompson NFA executor shared by search and whole-string matching.
+ * Load the portable counted-run or Thompson NFA executor for search and whole-string matching.
  * Scratch belongs to one invocation: no match-result cache, shared mutable cursor or DFA expansion.
  */
-export declare function loadPattern(pattern: Pattern): IRegexpMatcher;
+export declare function loadPattern(pattern: Pattern | RunPattern): IRegexpMatcher;

package/dist/v1/language/value/regexp/matcher.js

@@ -1,8 +1,10 @@
 /**
- * Load the portable Thompson NFA executor shared by search and whole-string matching.
+ * Load the portable counted-run or Thompson NFA executor for search and whole-string matching.
  * Scratch belongs to one invocation: no match-result cache, shared mutable cursor or DFA expansion.
  */
 export function loadPattern(pattern) {
+    if ('runs' in pattern)
+        return loadRuns(pattern);
     const states = pattern.states;
     const start = initialFrontier(pattern);
     const run = (input, search) => {
@@ -52,8 +54,8 @@ export function loadPattern(pattern) {
             const scalar = character.codePointAt(0);
             for (let index = 0; index < activeCount; index++) {
                 for (const transition of active[index].state.transitions) {
-                    for (const [minimum, maximum] of transition.ranges) {
-                        if (scalar < minimum || scalar > maximum)
+                    for (const range of transition.ranges) {
+                        if (scalar < range[0] || scalar > range[1])
                             continue;
                         add(transition.to);
                         break;
@@ -83,6 +85,76 @@ export function loadPattern(pattern) {
         matches: (input) => run(input, false),
     });
 }
+function loadRuns(pattern) {
+    const runs = pattern.runs;
+    const run = (input, search) => {
+        if (search && runs.length === 1) {
+            const scalarRun = runs[0];
+            if (scalarRun.minimum === 0)
+                return true;
+            let count = 0;
+            for (const character of input) {
+                count = includesScalar(scalarRun.ranges, character.codePointAt(0)) ? count + 1 : 0;
+                if (count >= scalarRun.minimum)
+                    return true;
+            }
+            return false;
+        }
+        let start = 0;
+        do {
+            let offset = start;
+            let accepted = true;
+            for (let index = 0; index < runs.length; index++) {
+                const scalarRun = runs[index];
+                const maximum = search && index === runs.length - 1 ? scalarRun.minimum : (scalarRun.maximum ?? Infinity);
+                let count = 0;
+                while (count < maximum && offset < input.length) {
+                    const scalar = input.codePointAt(offset);
+                    if (!includesScalar(scalarRun.ranges, scalar))
+                        break;
+                    offset += scalar > 0xffff ? 2 : 1;
+                    count++;
+                }
+                if (count < scalarRun.minimum) {
+                    accepted = false;
+                    break;
+                }
+            }
+            if (accepted && (search || offset === input.length))
+                return true;
+            if (!search || start === input.length)
+                return false;
+            start += input.codePointAt(start) > 0xffff ? 2 : 1;
+        } while (start <= input.length);
+        return false;
+    };
+    return Object.freeze({
+        test: (input) => run(input, true),
+        matches: (input) => run(input, false),
+    });
+}
+function includesScalar(ranges, scalar) {
+    if (ranges.length < 8) {
+        for (const range of ranges) {
+            if (scalar >= range[0] && scalar <= range[1])
+                return true;
+        }
+        return false;
+    }
+    let low = 0;
+    let high = ranges.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >>> 1;
+        const range = ranges[middle];
+        if (scalar < range[0])
+            high = middle - 1;
+        else if (scalar > range[1])
+            low = middle + 1;
+        else
+            return true;
+    }
+    return false;
+}
 function initialFrontier(pattern) {
     const start = pattern.start;
     const seen = new Set([start]);

package/dist/v1/schema/compatibility/footprint.js

@@ -1,7 +1,7 @@
 import { Key } from '../../addressing/index.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
 import { SchemaError, diagnostic } from '../diagnostic.js';
-import { collectCallableContractRefs, collectCallableRefs, collectClassPolicyRefs, collectClassRefs, collectCoreRefs, collectEndpointRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, } from '../resolution/origins.js';
+import { collectCallableContractRefs, collectCallableRefs, collectClassPolicyRefs, collectClassRefs, collectCoreRefs, collectEndpointRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, coreEndpointDefinitionRef, } from '../resolution/origins.js';
 import { contextInvalid, effectiveDefinition, effectiveMethod, requireOwner } from './context.js';
 import { classCoordinate, keyReference, levelOf, memberCoordinate, methodCoordinate, propertyCoordinate, } from './coordinate.js';
 import { classMeaning, fingerprintMeaning, meaningForCoordinate, memberMeaning, methodMeaning, propertyMeaning, } from './meaning.js';
@@ -221,10 +221,11 @@ function collectMemberSemanticRefs(owner, ref, add) {
                 if (!incident)
                     continue;
                 add(edge.class);
-                if (edge.source.kind !== 'domain')
-                    add(edge.source);
-                if (edge.target.kind !== 'domain')
-                    add(edge.target);
+                for (const endpoint of [edge.source, edge.target]) {
+                    const endpointRef = coreEndpointDefinitionRef(endpoint);
+                    if (endpointRef !== undefined)
+                        add(endpointRef);
+                }
             }
         }
     }

package/dist/v1/schema/normalization/domain.js

@@ -175,7 +175,21 @@ function compareCoreEndpoints(left, right) {
         return right.kind === 'domain' ? 0 : -1;
     if (right.kind === 'domain')
         return 1;
-    return compareDefinitionRefs(left, right);
+    const [a, b] = [coreEndpointOrder(left), coreEndpointOrder(right)];
+    return (compareUnicode(a.origin, b.origin) ||
+        compareUnicode(a.kind, b.kind) ||
+        compareUnicode(a.name, b.name) ||
+        compareUnicode(a.member, b.member));
+}
+/**
+ * A Method orders under its owner Class through the synthetic kind `method`; every other endpoint
+ * keeps the exact `compareDefinitionRefs` tuple with an empty member, so the canonical order of
+ * already-authored Core Edges — and therefore their revisions — never moves.
+ */
+function coreEndpointOrder(ref) {
+    return ref.kind === 'method'
+        ? { origin: ref.owner.origin, kind: ref.kind, name: ref.owner.name, member: ref.name }
+        : { origin: ref.origin, kind: ref.kind, name: ref.name, member: '' };
 }
 function compareBytes(left, right) {
     const encoder = new TextEncoder();

package/dist/v1/schema/resolution/domain.js

@@ -5,8 +5,8 @@ import { createDomainValidation, unknownInputField } from '../../domain/validati
 import { inputFieldNodes } from '../../language/value/compile/fields.js';
 import { prepareValueSchema } from '../../language/value/evaluate/preparation.js';
 import { validateValueProgram } from '../../language/value/evaluate/program.js';
-import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
-import { classifyOrdering } from '../../language/value/ordering.js';
+import { validateJsonInstance, validatePreparedInstance, } from '../../language/value/evaluate/validate.js';
+import { classifyPreparedOrdering } from '../../language/value/ordering.js';
 import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { SchemaError } from '../diagnostic.js';
 import { validateDomainSchemaSemantics } from '../validation/domain.js';
@@ -51,15 +51,20 @@ function resolveWithLookup(schema, lookup) {
 function sourceValidation(closure, registries) {
     const properties = new Map();
     const callables = new Map();
+    const patterns = new Map();
     for (const owner of closure) {
         const registry = registries.get(owner.origin);
         if (registry === undefined)
             throw new TypeError(`No Value registry exists for ${owner.origin}.`);
         for (const definition of Object.values(owner.classes)) {
             for (const [name, property] of Object.entries(definition.properties)) {
+                const prepared = prepareValueSchema(property.schema, registry, '', patterns);
+                if (!prepared.compiled) {
+                    throw new TypeError(`Accepted Property cannot be prepared: ${prepared.message}`);
+                }
                 properties.set(PropertyKey.of(definition.ref, name), Object.freeze({
-                    ordering: classifyOrdering(property.schema, registry),
-                    validate: (input) => validateJsonInstance(property.schema, input, registry),
+                    ordering: classifyPreparedOrdering(prepared.value),
+                    validate: (input) => validatePreparedInstance(prepared.value, input),
                 }));
             }
             if (definition.kind !== 'node')
@@ -69,7 +74,7 @@ function sourceValidation(closure, registries) {
                     ? undefined
                     : method.output.mode === 'value'
                         ? method.output.schema
-                        : method.output.item, registry));
+                        : method.output.item, registry, patterns));
             }
         }
         for (const definition of Object.values(owner.functions)) {
@@ -77,13 +82,13 @@ function sourceValidation(closure, registries) {
                 ? undefined
                 : definition.output.mode === 'value'
                     ? definition.output.schema
-                    : definition.output.item, registry));
+                    : definition.output.item, registry, patterns));
         }
     }
     return createDomainValidation(properties, callables);
 }
-function callableValidation(input, output, registry) {
-    const prepared = prepareValueSchema(input, registry, '');
+function callableValidation(input, output, registry, patterns) {
+    const prepared = prepareValueSchema(input, registry, '', patterns);
     if (!prepared.compiled) {
         throw new TypeError(`Accepted callable input cannot be prepared: ${prepared.message}`);
     }
@@ -91,14 +96,16 @@ function callableValidation(input, output, registry) {
     const fields = inputFieldNodes(inputProgram);
     return Object.freeze({
         ...(fields === undefined ? {} : { fields: Object.freeze(Object.keys(fields)) }),
-        validateInput: (value) => validateJsonInstance(input, value, registry),
+        validateInput: (value) => validatePreparedInstance(prepared.value, value),
         validateInputField(field, value) {
             const nodes = fields?.[field];
             return nodes === undefined
                 ? unknownInputField(field)
                 : validateValueProgram(inputProgram, value, nodes);
         },
-        validateOutput: (value) => output === undefined ? [] : validateJsonInstance(output, value, registry),
+        validateOutput: (value) => output === undefined
+            ? []
+            : validateJsonInstance(output, value, registry, '', patterns),
     });
 }
 function definitionsOf(schema) {

package/dist/v1/schema/resolution/origins.d.ts

@@ -1,6 +1,7 @@
 import type { DefinitionRef } from '../../addressing/index.js';
 import type { FunctionDefinition, MethodDefinition } from '../../language/callable/model/callable.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { CoreEndpointRef } from '../../language/core/model/core.js';
 import type { PolicyDefinition } from '../../language/policy/model/policy.js';
 import type { JsonSchema } from '../../language/value/model/schema.js';
 import type { DomainSchemaIR } from '../model/schema.js';
@@ -15,6 +16,8 @@ export declare function collectUsedForeignOrigins(schema: DomainSchemaIR): Reado
 /** Complete structured references in one schema, in canonical order. */
 export declare function collectDomainDefinitionRefs(schema: DomainSchemaIR): readonly DefinitionRef[];
 export declare function collectCoreRefs(schema: DomainSchemaIR, add: ReferenceCollector): void;
+/** The owning Domain addresses no Definition, and a Method is addressed through its owner Class. */
+export declare function coreEndpointDefinitionRef(endpoint: CoreEndpointRef): DefinitionRef | undefined;
 export declare function collectClassRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
 export declare function collectClassPolicyRefs(declaration: ClassDefinition, add: ReferenceCollector): void;
 export declare function collectEndpointRefs(declaration: Extract<ClassDefinition, {

package/dist/v1/schema/resolution/origins.js

@@ -36,12 +36,20 @@ export function collectCoreRefs(schema, add) {
         add(node.class, 'core');
     for (const edge of schema.core.edges) {
         add(edge.class, 'core');
-        if (edge.source.kind !== 'domain')
-            add(edge.source, 'core');
-        if (edge.target.kind !== 'domain')
-            add(edge.target, 'core');
+        for (const endpoint of [edge.source, edge.target]) {
+            const ref = coreEndpointDefinitionRef(endpoint);
+            // An endpoint names the Definition without instantiating it, exactly like an accepts contract.
+            if (ref !== undefined)
+                add(ref, 'endpoint');
+        }
     }
 }
+/** The owning Domain addresses no Definition, and a Method is addressed through its owner Class. */
+export function coreEndpointDefinitionRef(endpoint) {
+    if (endpoint.kind === 'domain')
+        return undefined;
+    return endpoint.kind === 'method' ? endpoint.owner : endpoint;
+}
 export function collectClassRefs(declaration, add) {
     declaration.extends.forEach((ref) => add(ref, 'extends'));
     Object.values(declaration.properties).forEach((property) => collectValueDefinitionRefs(property.schema, add));

package/dist/v1/schema/validation/core.js

@@ -1,5 +1,7 @@
 import { Key } from '../../addressing/key.js';
 import { compareUnicode, definitionRefIndex } from '../../addressing/ordering.js';
+import { isMethodExecutable } from '../../language/callable/executable.js';
+import { policyObjectKey, policyObjectOrigin, projectedMemberClass, } from '../../language/policy/model/policy.js';
 import { validateJsonInstance } from '../../language/value/evaluate/validate.js';
 import { diagnostic } from '../diagnostic.js';
 const formatDefinitionRef = Key.of;
@@ -42,8 +44,8 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
     const edges = [];
     for (const [index, edge] of environment.candidate.core.edges.entries()) {
         const pointer = `/core/edges/${index}`;
-        const source = resolveCoreEndpoint(edge.source, `${pointer}/source`, nodesByRef, diagnostics);
-        const target = resolveCoreEndpoint(edge.target, `${pointer}/target`, nodesByRef, diagnostics);
+        const source = resolveCoreEndpoint(environment, edge.source, `${pointer}/source`, nodesByRef, diagnostics);
+        const target = resolveCoreEndpoint(environment, edge.target, `${pointer}/target`, nodesByRef, diagnostics);
         const resolved = environment.resolve(edge.class);
         if (edge.class.origin !== environment.candidate.origin ||
             resolved === undefined ||
@@ -75,14 +77,37 @@ function resolveCoreEdges(environment, analysis, registry, nodesByRef, diagnosti
     }
     return edges;
 }
-function resolveCoreEndpoint(ref, pointer, nodesByRef, diagnostics) {
+function resolveCoreEndpoint(environment, ref, pointer, nodesByRef, diagnostics) {
     if (ref.kind === 'domain')
         return { kind: 'domain', ref, key: 'domain' };
-    const node = nodesByRef.get(definitionRefIndex(ref));
-    if (node === undefined) {
-        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${formatDefinitionRef(ref)} does not name a declared local Core Node.`, formatDefinitionRef(ref)));
+    const undeclared = () => {
+        const key = policyObjectKey(ref);
+        diagnostics.push(diagnostic('DV_CORE_REF', pointer, `Core endpoint ${key} does not name a declared local Definition.`, key));
+        return undefined;
+    };
+    if (policyObjectOrigin(ref) !== environment.candidate.origin)
+        return undeclared();
+    if (ref.kind === 'core')
+        return nodesByRef.get(definitionRefIndex(ref)) ?? undeclared();
+    if (!declaresProjectedMember(environment, ref))
+        return undeclared();
+    return { kind: 'member', key: policyObjectKey(ref), classRef: projectedMemberClass(ref) };
+}
+/** Only a projected declaration can carry a Core fact; an abstract Method is never projected. */
+function declaresProjectedMember(environment, ref) {
+    const candidate = environment.candidate;
+    if (ref.kind === 'method') {
+        const owner = candidate.classes[ref.owner.name];
+        const method = owner?.kind === 'node' ? owner.methods[ref.name] : undefined;
+        return method !== undefined && isMethodExecutable(owner, method);
     }
-    return node;
+    if (ref.kind === 'class')
+        return Object.hasOwn(candidate.classes, ref.name);
+    if (ref.kind === 'function')
+        return Object.hasOwn(candidate.functions, ref.name);
+    if (ref.kind === 'policy')
+        return Object.hasOwn(candidate.policies, ref.name);
+    return Object.hasOwn(candidate.views, ref.name);
 }
 function endpointSatisfies(environment, endpoint, accepts) {
     // The owning Domain is a graph-projection identity, not a Definition declared by this DSL.
@@ -157,41 +182,68 @@ function validateCoreEdgeSet(environment, edges, nodesByRef, diagnostics) {
     }
 }
 function validateCardinality(environment, declaration, edges, nodesByRef, diagnostics) {
+    const subjects = cardinalitySubjects(edges, nodesByRef);
     if (declaration.orientation === 'undirected') {
         const [first, second] = declaration.endpoints;
-        for (const node of nodesByRef.values()) {
-            const matchesFirst = classSatisfies(environment, node.classRef, first.accepts);
-            const matchesSecond = classSatisfies(environment, node.classRef, second.accepts);
+        for (const subject of subjects) {
+            const matchesFirst = classSatisfies(environment, subject.classRef, first.accepts);
+            const matchesSecond = classSatisfies(environment, subject.classRef, second.accepts);
             if (!matchesFirst && !matchesSecond)
                 continue;
-            const degree = edges.filter((edge) => edge.source.key === node.key || edge.target.key === node.key).length;
+            const degree = edges.filter((edge) => edge.source.key === subject.key || edge.target.key === subject.key).length;
             if (matchesFirst)
-                checkIncidentBound(first, degree, node, diagnostics);
+                checkBound(first, first.incident, degree, subject, diagnostics);
             if (matchesSecond && !sameIncidentEndpointContract(first, second)) {
-                checkIncidentBound(second, degree, node, diagnostics);
+                checkBound(second, second.incident, degree, subject, diagnostics);
             }
         }
         return;
     }
-    for (const node of nodesByRef.values()) {
-        if (classSatisfies(environment, node.classRef, declaration.endpoints.source.accepts)) {
-            const degree = edges.filter((edge) => edge.source.key === node.key).length;
-            checkBound(declaration.endpoints.source, declaration.endpoints.source.outgoing, degree, node, diagnostics);
+    for (const subject of subjects) {
+        if (classSatisfies(environment, subject.classRef, declaration.endpoints.source.accepts)) {
+            const degree = edges.filter((edge) => edge.source.key === subject.key).length;
+            checkBound(declaration.endpoints.source, declaration.endpoints.source.outgoing, degree, subject, diagnostics);
         }
-        if (classSatisfies(environment, node.classRef, declaration.endpoints.target.accepts)) {
-            const degree = edges.filter((edge) => edge.target.key === node.key).length;
-            checkBound(declaration.endpoints.target, declaration.endpoints.target.incoming, degree, node, diagnostics);
+        if (classSatisfies(environment, subject.classRef, declaration.endpoints.target.accepts)) {
+            const degree = edges.filter((edge) => edge.target.key === subject.key).length;
+            checkBound(declaration.endpoints.target, declaration.endpoints.target.incoming, degree, subject, diagnostics);
+        }
+    }
+}
+/**
+ * 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, nodesByRef) {
+    const subjects = new Map();
+    for (const node of nodesByRef.values()) {
+        subjects.set(node.key, {
+            key: node.key,
+            classRef: node.classRef,
+            pointer: `/core/nodes/${escapePointer(node.slug)}`,
+            minimum: true,
+        });
+    }
+    for (const edge of edges) {
+        for (const endpoint of [edge.source, edge.target]) {
+            if (endpoint.kind !== 'member' || subjects.has(endpoint.key))
+                continue;
+            subjects.set(endpoint.key, {
+                key: endpoint.key,
+                classRef: endpoint.classRef,
+                pointer: edge.pointer,
+                minimum: false,
+            });
         }
     }
+    return Object.freeze([...subjects.values()]);
 }
-function checkBound(endpoint, count, degree, node, diagnostics) {
+function checkBound(endpoint, count, degree, subject, diagnostics) {
     const [minimum, maximum] = countBounds(count);
-    if (degree >= minimum && degree <= maximum)
+    if (degree <= maximum && (degree >= minimum || !subject.minimum))
         return;
-    diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', `/core/nodes/${escapePointer(node.slug)}`, `Core degree ${degree} violates ${endpoint.role} Edge count ${count}.`));
-}
-function checkIncidentBound(endpoint, degree, node, diagnostics) {
-    checkBound(endpoint, endpoint.incident, degree, node, diagnostics);
+    diagnostics.push(diagnostic('DV_CORE_EDGE_CONSTRAINTS', subject.pointer, `Core degree ${degree} violates ${endpoint.role} Edge count ${count}.`));
 }
 function sameIncidentEndpointContract(left, right) {
     return (left.incident === right.incident &&

package/dist/v1/schema/validation/domain.structure.js

@@ -61,14 +61,19 @@ const coreRefSchema = strictObject({
     name: coreSlugSchema,
 });
 const domainRefSchema = strictObject({ kind: literal('domain') });
-const coreEndpointRefSchema = discriminatedUnion('kind', [coreRefSchema, domainRefSchema]);
-const policyObjectRefSchema = discriminatedUnion('kind', [
+/** Every Definition whose installed projection resolves through one exact member Path. */
+const projectedMemberRefOptions = [
     strictObject({ kind: literal('method'), owner: classRefSchema, name: memberNameSchema }),
     classRefSchema,
     functionRefSchema,
     policyRefSchema,
     viewRefSchema,
     coreRefSchema,
+];
+const policyObjectRefSchema = discriminatedUnion('kind', projectedMemberRefOptions);
+const coreEndpointRefSchema = discriminatedUnion('kind', [
+    ...projectedMemberRefOptions,
+    domainRefSchema,
 ]);
 const edgeEndpointBaseShape = {
     role: memberNameSchema,

package/dist/value/accept.d.ts

@@ -6,3 +6,12 @@ import { type Options } from './limits.js';
  * Every source property is obtained from one descriptor snapshot. Accessors are never invoked.
  */
 export declare function accept(input: unknown, options?: Options): Value;
+/** Admit unknown data into a deeply immutable snapshot; owned subtrees may be shared. */
+export declare function acceptImmutable(input: unknown, options?: Options): Value;
+/** Admit a read-only snapshot, sharing owned immutable subtrees without freezing new wrappers. */
+export declare function acceptForRead(input: unknown, options?: Options): Value;
+/**
+ * Private PropertyValues owner seam. Retain immediate recursive values, not the enclosing
+ * dictionary: its canonical coordinates are re-admitted by the Property owner on every use.
+ */
+export declare function acceptPropertyRoot(input: unknown): Value;