@astrale-os/kernel-dsl 1.0.0-beta.15 → 1.0.0-beta.16

package/dist/v1/language/policy/analysis/typing.js

@@ -1,5 +1,6 @@
 import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
+import { classSatisfies, isGraphRoot } from '../../class/inheritance.js';
 import { limits } from '../../limits.js';
 import { branchesOf, branchProduct, capBranches, targetMode, termKey, UnionFind, } from './branches.js';
 import { admittedCheckClasses } from './checks.js';
@@ -15,6 +16,9 @@ export class PolicyTyping {
     // paths; for that to merge distinct variables, the Policy expands deeper than
     // `limits.policy.patternDepth`.
     #expansions = new Map();
+    #nodeClasses;
+    #concreteClasses;
+    #satisfaction;
     constructor(scope) {
         this.scope = scope;
     }
@@ -69,7 +73,9 @@ export class PolicyTyping {
         return branches !== undefined && branches.every((branch) => this.branchIsTyped(branch, use));
     }
     #concreteEndpointClasses(accepts) {
-        return this.scope.concreteNodeClasses.filter((candidate) => this.#classSatisfiesEndpoint(candidate, accepts));
+        this.#concreteClasses ??= new Set(this.scope.concreteNodeClasses.map(definitionRefIndex));
+        const concrete = this.#concreteClasses;
+        return this.#satisfyingOneOf(accepts).filter((ref) => concrete.has(definitionRefIndex(ref)));
     }
     #expandedBranches(name, visiting, namespace) {
         if (visiting.has(name))
@@ -158,7 +164,11 @@ export class PolicyTyping {
             if (contract.kind === 'exact')
                 return this.#applyExact(candidates, contract.ref);
             if (contract.kind === 'default') {
-                return uniqueCandidates(this.scope.allNodeClasses.flatMap((ref) => this.#applyExact(candidates, ref)));
+                return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
+                    ? this.#isNodeClass(candidate.ref)
+                        ? [candidate]
+                        : []
+                    : this.#nodeCandidates(candidate)));
             }
             return candidates;
         }
@@ -183,26 +193,30 @@ export class PolicyTyping {
                 if (definitionRefIndex(candidate.ref) === definitionRefIndex(exact))
                     result.push(candidate);
             }
-            else if (candidate.requirements.every((required) => this.scope.classExtends(exact, required))) {
+            else if (candidate.kind === 'node') {
+                if (this.#isNodeClass(exact) && this.#satisfiesLists(exact, candidate.lists)) {
+                    result.push({ kind: 'exact', ref: exact });
+                }
+            }
+            else if (candidate.requirements.every((required) => this.#classExtends(exact, required))) {
                 result.push({ kind: 'exact', ref: exact });
             }
         }
         return uniqueCandidates(result);
     }
     #applyAnyNodeClass(candidates) {
-        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact'
-            ? [candidate]
-            : this.scope.allNodeClasses
-                .filter((ref) => candidate.requirements.every((required) => this.scope.classExtends(ref, required)))
-                .map((ref) => ({ kind: 'exact', ref }))));
+        return uniqueCandidates(candidates.flatMap((candidate) => candidate.kind === 'exact' ? [candidate] : this.#nodeCandidates(candidate)));
     }
     #applyRequirement(candidates, required) {
         const result = [];
         for (const candidate of candidates) {
             if (candidate.kind === 'exact') {
-                if (this.scope.classExtends(candidate.ref, required))
+                if (this.#classExtends(candidate.ref, required))
                     result.push(candidate);
             }
+            else if (candidate.kind === 'node') {
+                result.push(...this.#inhabited([...candidate.lists, [required]]));
+            }
             else {
                 result.push({
                     kind: 'open',
@@ -220,6 +234,11 @@ export class PolicyTyping {
                     result.push(candidate);
                 continue;
             }
+            if (candidate.kind === 'node') {
+                if (accepts.length > 0)
+                    result.push(...this.#inhabited([...candidate.lists, accepts]));
+                continue;
+            }
             for (const accept of accepts) {
                 result.push({
                     kind: 'open',
@@ -230,8 +249,105 @@ export class PolicyTyping {
         return uniqueCandidates(result);
     }
     #classSatisfiesEndpoint(candidate, accepts) {
-        return accepts.some((accept) => this.scope.classExtends(candidate, accept));
+        return accepts.some((accept) => this.#classExtends(candidate, accept));
+    }
+    /** Whether `candidate` is the `required` Class or a same-kind descendant. */
+    #classExtends(candidate, required) {
+        const resolve = (ref) => this.scope.resolveClass(ref);
+        const actual = resolve(candidate);
+        const target = resolve(required);
+        return actual !== undefined && target !== undefined && classSatisfies(actual, target, resolve);
+    }
+    /**
+     * The Node Classes of the closure that satisfy one Class of `accepts`, in closure order: those
+     * `#classSatisfiesEndpoint` accepts, read from the index rather than tested one by one.
+     */
+    #satisfyingOneOf(accepts) {
+        const index = (this.#satisfaction ??= satisfactionIndex(this.scope));
+        const positions = new Set();
+        for (const accept of accepts) {
+            const required = this.scope.resolveClass(accept);
+            if (required?.kind !== 'node')
+                continue;
+            if (isGraphRoot(required))
+                return index.nodeClasses;
+            for (const position of index.satisfying.get(ancestryKey(required.ref)) ?? []) {
+                positions.add(position);
+            }
+        }
+        return [...positions].sort((left, right) => left - right).map((at) => index.nodeClasses[at]);
+    }
+    #satisfiesLists(ref, lists) {
+        return lists.every((accepts) => this.#classSatisfiesEndpoint(ref, accepts));
+    }
+    #isNodeClass(ref) {
+        this.#nodeClasses ??= new Set(this.scope.allNodeClasses.map(definitionRefIndex));
+        return this.#nodeClasses.has(definitionRefIndex(ref));
+    }
+    /** The Node Classes an open or `node` candidate can be. */
+    #nodeCandidates(candidate) {
+        return candidate.kind === 'node'
+            ? [candidate]
+            : this.#inhabited(candidate.requirements.map((required) => [required]));
+    }
+    /**
+     * The `node` candidate of these lists when some Node Class of the closure satisfies them, so that
+     * an empty one is dropped where its expansion would have been empty. A witness is almost always a
+     * Class the lists name; only when none is does the search read the Classes that satisfy the
+     * narrowest list, every witness being one of them.
+     */
+    #inhabited(lists) {
+        const fits = (ref) => this.#isNodeClass(ref) && this.#satisfiesLists(ref, lists);
+        const inhabited = lists.some((accepts) => accepts.some(fits)) ||
+            (lists.length === 0
+                ? this.scope.allNodeClasses
+                : lists
+                    .map((accepts) => this.#satisfyingOneOf(accepts))
+                    .reduce((narrowest, next) => (next.length < narrowest.length ? next : narrowest))).some(fits);
+        return inhabited ? [{ kind: 'node', lists }] : [];
+    }
+}
+/** Classes are satisfied by origin and name, as `classSatisfies` compares them. */
+function ancestryKey(ref) {
+    return `${ref.origin}\u0000${ref.name}`;
+}
+/**
+ * Index each Node Class of the closure under every Class its ancestry reaches, walked as
+ * `classSatisfies` walks it: the Class itself, then each declared parent that resolves to a Node
+ * Class. A Class then satisfies a non-root Node Class exactly when it is indexed under it.
+ */
+function satisfactionIndex(scope) {
+    const nodeClasses = [];
+    const satisfying = new Map();
+    for (const ref of scope.allNodeClasses) {
+        const actual = scope.resolveClass(ref);
+        if (actual?.kind !== 'node')
+            continue;
+        const position = nodeClasses.push(ref) - 1;
+        const seen = new Set();
+        const keys = new Set();
+        const pending = [actual];
+        for (let value = pending.pop(); value !== undefined; value = pending.pop()) {
+            if (seen.has(value))
+                continue;
+            seen.add(value);
+            const key = ancestryKey(value.ref);
+            if (!keys.has(key)) {
+                keys.add(key);
+                const positions = satisfying.get(key);
+                if (positions === undefined)
+                    satisfying.set(key, [position]);
+                else
+                    positions.push(position);
+            }
+            for (const parent of value.extends) {
+                const resolved = scope.resolveClass(parent);
+                if (resolved?.kind === 'node')
+                    pending.push(resolved);
+            }
+        }
     }
+    return { nodeClasses, satisfying };
 }
 function targetContract(term, use) {
     if (use.kind === 'object')
@@ -329,7 +445,12 @@ function uniqueCandidates(values) {
     for (const value of values) {
         const key = value.kind === 'exact'
             ? `exact:${definitionRefIndex(value.ref)}`
-            : `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`;
+            : value.kind === 'open'
+                ? `open:${value.requirements.map(definitionRefIndex).sort().join('|')}`
+                : `node:${value.lists
+                    .map((accepts) => accepts.map(definitionRefIndex).sort().join(','))
+                    .sort()
+                    .join('|')}`;
         result.set(key, value);
     }
     return [...result.values()];

package/dist/v1/language/validation/rule.d.ts

@@ -21,6 +21,12 @@ export interface ValueRule {
     readonly statement: string;
     /** The limits of `schema.limits` the rule enforces, by key, where it enforces some. */
     readonly limits?: readonly [LimitKey, ...LimitKey[]];
+    /**
+     * The conditions of the published JSON Schema of the document that state the rule, where some
+     * do: the URI fragment of each `if` or `not` subschema whose failure refuses a value schema of
+     * the document with `DV_VALUE_SCHEMA` and this rule's code as its `valueCode`.
+     */
+    readonly conditions?: readonly [string, ...string[]];
 }
 /**
  * Every value diagnostic code with the rule it reports. A code added to the language does not

package/dist/v1/language/validation/rule.js

@@ -80,12 +80,7 @@ export const VALUE_RULES = frozen({
     },
     VS_REFERENCE_RESOLUTION: {
         stage: 'context',
-        positions: [
-            '{/path*}/$ref',
-            '{/path*}/x-astrale-path/accepts/{index}',
-            '',
-            '/registry{/path*}',
-        ],
+        positions: ['{/path*}/$ref', '{/path*}/x-astrale-path/accepts/{index}', ''],
         statement: 'A $ref resolves to a location of its own value schema, x-astrale-path accepts Node Classes of the Domain or of a direct dependency, and the schema is checked with the exact dependency closure of its Domain.',
     },
     VS_REGEX_PORTABLE: {
@@ -103,6 +98,7 @@ export const VALUE_RULES = frozen({
         stage: 'schema',
         positions: ['{/path*}/x-astrale-value-kind'],
         statement: 'x-astrale-value-kind declares instant beside type string at any location, or blob as the whole schema of a Property, exactly as values.blob writes it.',
+        conditions: ['#/$defs/value-location/anyOf/1/if'],
     },
     VS_VALUE_KIND_JSON: {
         stage: 'warning',
@@ -115,6 +111,8 @@ function frozen(rules) {
         Object.freeze(Object.freeze(rule).positions);
         if (rule.limits !== undefined)
             Object.freeze(rule.limits);
+        if (rule.conditions !== undefined)
+            Object.freeze(rule.conditions);
     }
     return Object.freeze(rules);
 }

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

@@ -14,6 +14,11 @@ export declare function classifyOrdering(contract: JsonSchema, registry: ValueSc
 /** Recompute the scalar ordering classification from one admitted portable value program. */
 export declare function classifyValueProgramOrdering(program: ValueProgram): OrderingKind | undefined;
 export declare function classifyPreparedOrdering(compiled: CompiledInstanceSchema): OrderingKind | undefined;
+/**
+ * Every value kind `classifyValueKind` returns, frozen, in the order `ValueKind` names them. A kind
+ * added to `ValueKind` does not compile until it is listed here.
+ */
+export declare const VALUE_KINDS: readonly ValueKind[];
 /**
  * The value kind of a property schema (page "Fondations Query v7", § Atoms et value kinds, Y4):
  * the one kind its non-null values admit, `null` being a point of every kind. An annotated

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

@@ -34,6 +34,20 @@ export function classifyPreparedOrdering(compiled) {
         ? kind
         : undefined;
 }
+const valueKinds = {
+    text: true,
+    number: true,
+    instant: true,
+    enum: true,
+    boolean: true,
+    set: true,
+    json: true,
+};
+/**
+ * Every value kind `classifyValueKind` returns, frozen, in the order `ValueKind` names them. A kind
+ * added to `ValueKind` does not compile until it is listed here.
+ */
+export const VALUE_KINDS = Object.freeze(Object.keys(valueKinds));
 /**
  * The value kind of a property schema (page "Fondations Query v7", § Atoms et value kinds, Y4):
  * the one kind its non-null values admit, `null` being a point of every kind. An annotated

package/dist/v1/language/value/reference/closure.js

@@ -36,10 +36,9 @@ export function collectResourceClosure(schema, context, index, pointer) {
             const target = result.resolved.resource;
             if (resources.has(target.key))
                 return;
-            const registered = {
-                ...target,
-                diagnosticPointer: `${pointer}/registry/graphNodePath`,
-            };
+            // The graph NodePath resource is no part of the schema: what it holds is reported at the
+            // $ref that names it.
+            const registered = { ...target, diagnosticPointer: refPointer };
             resources.set(target.key, registered);
             queue.push(registered);
         });

package/dist/v1/language/value/reference/registry.index.d.ts

@@ -5,6 +5,8 @@ export interface RegistryIndex {
     readonly registry: ValueSchemaRegistry;
     readonly domains: ReadonlyMap<string, ValueSchemaDomainRegistry>;
     readonly dependenciesByOwner: ReadonlyMap<string, ReadonlyMap<string, string>>;
+    /** The `definitionRefIndex` of each Node Definition its own Domain lists. */
+    readonly nodeDefinitions: ReadonlySet<string>;
 }
 export declare function indexRegistry(registry: ValueSchemaRegistry, pointer: string): {
     readonly index: RegistryIndex;

package/dist/v1/language/value/reference/registry.index.js

@@ -4,11 +4,21 @@ import { diagnostic } from '../../validation/diagnostic.js';
 import { isValueObject as isJsonObject } from '../model/object.js';
 import { JSON_SCHEMA_DIALECT } from '../model/schema.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../syntax/node-path/schema.js';
+// A registry is an immutable value, and every value schema of a Domain is validated against the
+// same one: an index that admitted it without a diagnostic is reused, so the closure is indexed
+// once per registry rather than once per value schema.
+const admittedIndexes = new WeakMap();
 export function indexRegistry(registry, pointer) {
+    const admitted = admittedIndexes.get(registry);
+    if (admitted !== undefined)
+        return { index: admitted, diagnostics: [] };
     const diagnostics = [];
     const domains = new Map();
     domains.set(registry.current.origin, registry.current);
-    validateDomainRegistry(registry.current, `${pointer}/registry/current`, false, diagnostics);
+    // The registry is the closure the Kernel builds for the schema at `pointer`, not a document: a
+    // fault of one of its entries is a fault of the closure that schema is checked with, reported
+    // there, the entry named in the message.
+    validateDomainRegistry(registry.current, 'current', false, pointer, diagnostics);
     const dependencies = [
         ...registry.directDependencies.map((domain) => ({ domain, lane: 'directDependencies' })),
         ...registry.transitiveDependencies.map((domain) => ({
@@ -17,10 +27,9 @@ export function indexRegistry(registry, pointer) {
         })),
     ];
     dependencies.forEach(({ domain, lane }, index) => {
-        const domainPointer = `${pointer}/registry/${lane}/${index}`;
-        validateDomainRegistry(domain, domainPointer, true, diagnostics);
+        validateDomainRegistry(domain, `${lane}/${index}`, true, pointer, diagnostics);
         if (domain.origin === registry.current.origin || domains.has(domain.origin)) {
-            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', domainPointer, `Registry origin ${domain.origin} is duplicated in the exact closure.`));
+            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Registry origin ${domain.origin} is duplicated in the exact closure, at ${lane}/${index}.`));
             return;
         }
         domains.set(domain.origin, domain);
@@ -37,31 +46,38 @@ export function indexRegistry(registry, pointer) {
             }
         }
     }
-    validateGraphNodePathResource(registry.graphNodePath, `${pointer}/registry/graphNodePath`, diagnostics);
-    return { index: { registry, domains, dependenciesByOwner }, diagnostics };
+    const nodeDefinitions = new Set();
+    for (const domain of domains.values()) {
+        for (const ref of domain.nodeDefinitions) {
+            if (ref.origin === domain.origin)
+                nodeDefinitions.add(definitionRefIndex(ref));
+        }
+    }
+    validateGraphNodePathResource(registry.graphNodePath, pointer, diagnostics);
+    const index = { registry, domains, dependenciesByOwner, nodeDefinitions };
+    if (diagnostics.length === 0)
+        admittedIndexes.set(registry, index);
+    return { index, diagnostics };
 }
 export function isOriginVisibleFrom(index, ownerOrigin, targetOrigin) {
     return (ownerOrigin === targetOrigin ||
         index.dependenciesByOwner.get(ownerOrigin)?.has(targetOrigin) === true);
 }
 export function hasNodeDefinition(index, ref, ownerOrigin) {
-    if (!isOriginVisibleFrom(index, ownerOrigin, ref.origin))
-        return false;
-    return (index.domains
-        .get(ref.origin)
-        ?.nodeDefinitions.some((candidate) => definitionRefIndex(candidate) === definitionRefIndex(ref)) === true);
+    return (isOriginVisibleFrom(index, ownerOrigin, ref.origin) &&
+        index.nodeDefinitions.has(definitionRefIndex(ref)));
 }
-function validateDomainRegistry(domain, pointer, revisionRequired, diagnostics) {
+function validateDomainRegistry(domain, entry, revisionRequired, pointer, diagnostics) {
     if (!DOMAIN_ORIGIN_PATTERN.test(domain.origin)) {
-        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/origin`, 'Registry origin is invalid.'));
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `Registry origin is invalid, at ${entry}.`));
     }
     if ((revisionRequired && domain.revision === undefined) ||
         (domain.revision !== undefined && !DOMAIN_REVISION_PATTERN.test(domain.revision))) {
-        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/revision`, 'A dependency-closure registry entry requires its exact sha256 revision.'));
+        diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `A dependency-closure registry entry requires its exact sha256 revision, at ${entry}.`));
     }
     for (const ref of domain.nodeDefinitions) {
         if (ref.origin !== domain.origin) {
-            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', `${pointer}/nodeDefinitions`, 'A registry domain can list only its own Node Definitions.'));
+            diagnostics.push(diagnostic('VS_REFERENCE_RESOLUTION', pointer, `A registry domain can list only its own Node Definitions, at ${entry}.`));
         }
     }
 }

package/dist/v1/schema/.spec/schemas/domain-schema.schema.json

@@ -46,7 +46,7 @@
             "code": "DV_VALUE_SCHEMA",
             "valueCode": "VS_PATH_EXTENSION",
             "stage": "rule",
-            "statement": "x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema, and reads target node, cardinality one and a non-empty set of Node Class refs it accepts.",
+            "statement": "x-astrale-path annotates only a direct Property of a callable input object, beside exactly the $ref of the graph NodePath schema.",
             "positions": [
                 "#/$defs/value-location/anyOf/1/properties/x-astrale-path"
             ]
@@ -75,6 +75,7 @@
             "stage": "context",
             "statement": "A $ref resolves to a location of its own value schema, and x-astrale-path accepts Node Classes of the Domain or of a direct dependency.",
             "positions": [
+                "#/$defs/path-annotation/properties/accepts/items",
                 "#/$defs/value-location/anyOf/1/properties/$ref"
             ]
         },
@@ -1384,6 +1385,33 @@
             "maxLength": 253,
             "pattern": "^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$"
         },
+        "path-annotation": {
+            "type": "object",
+            "properties": {
+                "target": {
+                    "type": "string",
+                    "const": "node"
+                },
+                "cardinality": {
+                    "type": "string",
+                    "const": "one"
+                },
+                "accepts": {
+                    "type": "array",
+                    "minItems": 1,
+                    "uniqueItems": true,
+                    "items": {
+                        "$ref": "#/$defs/class-ref"
+                    }
+                }
+            },
+            "required": [
+                "target",
+                "cardinality",
+                "accepts"
+            ],
+            "additionalProperties": false
+        },
         "policy-check-expr": {
             "anyOf": [
                 {
@@ -2100,7 +2128,7 @@
                             "type": "string"
                         },
                         "x-astrale-path": {
-                            "type": "object"
+                            "$ref": "#/$defs/path-annotation"
                         },
                         "additionalProperties": {
                             "$ref": "#/$defs/value-subschema"

package/dist/v1/schema/rule.d.ts

@@ -24,6 +24,12 @@ export interface SchemaRule {
     readonly enforces?: string;
     /** The limits of `limits` the rule enforces, by key, where it enforces some. */
     readonly limits?: readonly [LimitKey, ...LimitKey[]];
+    /**
+     * The conditions of the published JSON Schema of the document that state the rule, where some
+     * do: the URI fragment of each `if` or `not` subschema, `#/$defs/edge-class/if`, whose failure
+     * refuses a document with this rule's code.
+     */
+    readonly conditions?: readonly [string, ...string[]];
 }
 /**
  * Every Schema diagnostic code with the rule it reports. A code added to the DSL does not compile

package/dist/v1/schema/rule.js

@@ -38,7 +38,8 @@ export const RULES = deepFreeze({
     },
     DV_CALLABLE_IO: {
         stage: 'rule',
-        positions: [...at('/input/mode'), ...at('/output/mode')],
+        // A Method takes a value input only: its input has no mode.
+        positions: ['/functions/{function}/input/mode', ...at('/output/mode')],
         statement: 'A durable Function or Method takes a value input and returns a value output.',
     },
     DV_CLASS_ABSTRACT: {
@@ -185,6 +186,7 @@ export const RULES = deepFreeze({
         stage: 'structure',
         positions: ANY,
         statement: `The document is portable JSON: as text, UTF-8 that parses, within ${count(defaultLimits.maxBytes)} bytes, with no byte-order mark and no repeated member name; as a value, null, booleans, finite numbers other than negative zero, strings, arrays and plain objects, with no string or member name that holds U+0000 or a lone surrogate or exceeds ${count(defaultLimits.maxStringBytes)} bytes of UTF-8, at most ${count(defaultLimits.maxDepth)} nested arrays and objects, and at most ${count(defaultLimits.maxMembers)} members and items in all.`,
+        conditions: ['#/$defs/portable-string/not'],
     },
     DV_METHOD_ABSTRACT: {
         stage: 'rule',
@@ -247,6 +249,7 @@ export const RULES = deepFreeze({
             ...at('/output/item{/path*}'),
         ],
         statement: 'Every embedded value schema is in the value language: its diagnostic names the refusal in `valueCode`, and the schema of an automatic or State Property is not a blob.',
+        conditions: ['#/$defs/node-property-definition/allOf/0/if'],
     },
     PL_BUDGET: {
         stage: 'rule',
@@ -307,16 +310,19 @@ export const RULES = deepFreeze({
         stage: 'structure',
         positions: ['/functions/{function}/input'],
         statement: 'A Function input in binary mode is a binary input: it declares its metadata and maximumBytes.',
+        conditions: ['#/$defs/function-definition/properties/input/anyOf/1/not'],
     },
     STRUCTURE_CALLABLE_POLICY_AUTH: {
         stage: 'structure',
         positions: at('/policy'),
         statement: 'Only an authorized Function or Method declares a Policy.',
+        conditions: ['#/$defs/function-definition/if', '#/$defs/method-definition/if'],
     },
     STRUCTURE_DEPENDENCY_ALIAS: {
         stage: 'structure',
         positions: ['/dependencies/{alias}'],
         statement: 'A dependency alias is neither prototype nor constructor.',
+        conditions: ['#/$defs/dependency-alias/not'],
     },
     STRUCTURE_DOMAIN_NAME: {
         stage: 'structure',
@@ -338,6 +344,7 @@ export const RULES = deepFreeze({
         stage: 'structure',
         positions: ['/classes/{class}/properties/{property}/schema/x-astrale-value-kind'],
         statement: 'The schema of an Edge Property is not a blob: only a Node holds Blob contents.',
+        conditions: ['#/$defs/edge-property-definition/properties/schema/not'],
     },
     STRUCTURE_EDGE_ORIENTATION: {
         stage: 'structure',
@@ -348,6 +355,7 @@ export const RULES = deepFreeze({
         ],
         statement: 'A directed Edge Class has source and target endpoints and an undirected one two incident endpoints, and only a directed one declares unique tuples or is acyclic.',
         enforces: 'No Edges of an acyclic Class form a directed cycle.',
+        conditions: ['#/$defs/edge-class/if'],
     },
     STRUCTURE_FORMAT: {
         stage: 'structure',
@@ -384,6 +392,10 @@ export const RULES = deepFreeze({
         stage: 'structure',
         positions: ANY,
         statement: 'No object of the document has a member named __proto__, except the transitions of a State.',
+        conditions: [
+            '#/$defs/json-value/anyOf/5/propertyNames/not',
+            '#/$defs/value-schema/anyOf/1/propertyNames/not',
+        ],
     },
     STRUCTURE_REQUIRED: {
         stage: 'structure',

package/dist/v1/schema/validation/class.d.ts

@@ -1,10 +1,14 @@
 import type { ClassRef } from '../../addressing/index.js';
 import type { ClassDefinition } from '../../language/class/model/class.js';
+import type { ValueSchemaRegistry } from '../../language/value/reference/registry.js';
 import type { DefinitionAnalysisResult } from '../analysis/class.js';
 import type { SchemaDiagnostic } from '../diagnostic.js';
 import type { DomainResolutionContext } from '../resolution/context.js';
-/** Validate the semantic contracts owned by Class declarations. */
-export declare function validateDefinitions(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult): readonly SchemaDiagnostic[];
+/**
+ * Validate the semantic contracts owned by Class declarations. `registry` is the candidate's value
+ * registry; each dependency's is built at most once, so the Classes share them.
+ */
+export declare function validateDefinitions(environment: DomainResolutionContext, analysis: DefinitionAnalysisResult, registry: ValueSchemaRegistry): readonly SchemaDiagnostic[];
 /** Whether `child` safely refines its parent Edge contract `parent`. */
 export declare function edgeContractRefines(environment: DomainResolutionContext, child: Extract<ClassDefinition, {
     readonly kind: 'edge';

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

@@ -10,13 +10,24 @@ import { isBlobValueSchema } from '../../language/value/model/blob.js';
 import { classifyOrdering } from '../../language/value/ordering.js';
 import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
-import { createDomainValueSchemaRegistry, createValueSchemaRegistry, } from '../resolution/value.registry.js';
+import { createDomainValueSchemaRegistry } from '../resolution/value.registry.js';
 const formatDefinitionRef = Key.of;
-/** Validate the semantic contracts owned by Class declarations. */
-export function validateDefinitions(environment, analysis) {
+/**
+ * Validate the semantic contracts owned by Class declarations. `registry` is the candidate's value
+ * registry; each dependency's is built at most once, so the Classes share them.
+ */
+export function validateDefinitions(environment, analysis, registry) {
     const diagnostics = [...analysis.diagnostics];
     const schema = environment.candidate;
     let scope;
+    const registries = new Map([[schema.origin, registry]]);
+    const registryOf = (origin) => {
+        if (!registries.has(origin)) {
+            const dependency = environment.dependencies.get(origin);
+            registries.set(origin, dependency === undefined ? undefined : createDomainValueSchemaRegistry(dependency));
+        }
+        return registries.get(origin);
+    };
     for (const [name, declaration] of Object.entries(schema.classes)) {
         const ref = { origin: schema.origin, kind: 'class', name };
         const pointer = `/classes/${escapePointerToken(name)}`;
@@ -27,7 +38,7 @@ export function validateDefinitions(environment, analysis) {
             (declaration.policies.read !== undefined || declaration.policies.traverse !== undefined)) {
             diagnostics.push(diagnostic('DV_CLASS_ABSTRACT', `${pointer}/policies`, 'Abstract Classes cannot declare observation Policies.'));
         }
-        validateFacet(environment, declaration, pointer, diagnostics);
+        validateFacet(registry, declaration, pointer, diagnostics);
         validateParents(environment, ref, declaration.kind, declaration.extends, diagnostics);
         if (declaration.kind === 'edge') {
             validateEdgeContract(environment, ref, declaration, pointer, diagnostics);
@@ -35,12 +46,11 @@ export function validateDefinitions(environment, analysis) {
             validateEdgeLifetimes(scope, ref, declaration, pointer, diagnostics);
             validateEdgeClassComposition(environment, ref, declaration, pointer, diagnostics);
         }
-        validateUniqueProperties(environment, analysis, ref, declaration, pointer, diagnostics);
+        validateUniqueProperties(registryOf, analysis, ref, declaration, pointer, diagnostics);
     }
     return Object.freeze(diagnostics);
 }
-function validateFacet(environment, declaration, pointer, diagnostics) {
-    const valueRegistry = createValueSchemaRegistry(environment);
+function validateFacet(valueRegistry, declaration, pointer, diagnostics) {
     for (const [name, property] of Object.entries(declaration.properties)) {
         const propertyPointer = `${pointer}/properties/${escapePointerToken(name)}`;
         // The structure refuses a blob on an Edge Property and a State Property on an Edge Class.
@@ -147,7 +157,7 @@ function validateEdgeContract(environment, owner, declaration, pointer, diagnost
  * inherit without redefinition, so the key reads one meaning on every descendant it covers. A Node
  * tuple names Properties only; an Edge tuple names them as `{ property }` beside its other fields.
  */
-function validateUniqueProperties(environment, analysis, owner, declaration, pointer, diagnostics) {
+function validateUniqueProperties(registryOf, analysis, owner, declaration, pointer, diagnostics) {
     if (declaration.kind === 'edge' && declaration.orientation !== 'directed')
         return;
     if (declaration.unique === undefined)
@@ -156,20 +166,6 @@ function validateUniqueProperties(environment, analysis, owner, declaration, poi
     if (properties === undefined)
         return;
     const code = declaration.kind === 'node' ? 'DV_NODE_UNIQUE' : 'DV_EDGE_UNIQUE';
-    const registries = new Map();
-    const registryOf = (origin) => {
-        if (!registries.has(origin)) {
-            const schema = environment.dependencies.get(origin);
-            const registry = origin === environment.candidate.origin
-                ? createValueSchemaRegistry(environment)
-                : schema === undefined
-                    ? undefined
-                    : createDomainValueSchemaRegistry(schema);
-            if (registry !== undefined)
-                registries.set(origin, registry);
-        }
-        return registries.get(origin);
-    };
     const check = (key, at) => {
         const property = properties.get(key);
         if (property === undefined) {