@astrale-os/kernel-dsl 1.0.0-beta.2 → 1.0.0-beta.20

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

@@ -1,22 +1,11 @@
-import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
 import { canonicalDomainSchemaAfterValidation } from '../canonical/revision.js';
 import { emptyDomainSchemaLookup } from '../dependency/lookup.js';
-import { SchemaError, diagnostic } from '../diagnostic.js';
+import { SchemaError } from '../diagnostic.js';
 import { rememberDomainClosure } from '../resolution/closure.js';
 import { validateDomainSchemaSemantics } from '../validation/domain.js';
-import { routeDomainSchema } from '../validation/domain.route.js';
+import { structureDomainSchema } from '../validation/domain.route.js';
 export function acceptDomainSchema(input, lookup = emptyDomainSchemaLookup()) {
-    let admitted;
-    try {
-        admitted = acceptJsonValue(input);
-    }
-    catch (error) {
-        if (error instanceof JsonBoundaryError) {
-            throw new SchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
-        }
-        throw error;
-    }
-    const structured = routeDomainSchema(admitted);
+    const structured = structureDomainSchema(input);
     const validation = validateDomainSchemaSemantics(structured, lookup);
     if (validation.diagnostics.length > 0)
         throw new SchemaError(validation.diagnostics);

package/dist/v1/schema/admission/callable.d.ts

@@ -0,0 +1,21 @@
+import type { ClassRef } from '../../addressing/index.js';
+import type { CallableValidation } from '../../domain/validation/create.js';
+import type { CallableDefinition } from '../../language/callable/model/callable.js';
+import type { DomainSchema } from '../model/schema.js';
+/** One admitted callable contract and the validators of its exact owner environment. */
+export interface AcceptedCallable extends CallableValidation {
+    readonly definition: CallableDefinition;
+}
+/**
+ * Accept one callable contract in the exact environment of its owner Domain, by the one validation
+ * every contract passes wherever it is declared (`validateContract`, `validateContractPolicy`,
+ * `validateCheckBudget`): the structure of a Function declaration without `ref`, its value schemas
+ * against the owner registry, its execution modifier and admission age, and its Policy with the
+ * budget of its checks. `receiver` is the owner Node Class whose Node receives the call and which
+ * the Policy names `self`: the Class of a Function instance, whose Node carries the contract, or
+ * the owner of an instance Method. Without it, as at a Function declaration, the Policy names none.
+ * Returns the canonical definition and its validators.
+ */
+export declare function acceptCallable(input: unknown, owner: DomainSchema, options?: {
+    readonly receiver?: ClassRef;
+}): AcceptedCallable;

package/dist/v1/schema/admission/callable.js

@@ -0,0 +1,96 @@
+import { accept as acceptJsonValue, BoundaryError as JsonBoundaryError, } from '@astrale-os/kernel-dsl/value';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { isBinaryInput } from '../../language/callable/model/callable.js';
+import { deepFreeze } from '../../language/freeze.js';
+import { measureChecks } from '../../language/policy/analysis/budgets.js';
+import { PolicyTyping } from '../../language/policy/analysis/typing.js';
+import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
+import {} from '../../language/value/evaluate/preparation.js';
+import { analyzeDefinitions } from '../analysis/class.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { canonicalizeCallable } from '../normalization/domain.js';
+import { lookupForDomainClosure } from '../resolution/closure.js';
+import { buildDomainResolutionContext } from '../resolution/context.js';
+import { callableValidation } from '../resolution/domain.js';
+import { createDomainValueSchemaRegistry } from '../resolution/value.registry.js';
+import { validateContract } from '../validation/callable.js';
+import { parseCallableContract } from '../validation/domain.structure.js';
+import { validateCheckBudget } from '../validation/policy/budgets.js';
+import { PolicyValidationContext } from '../validation/policy/context.js';
+import { validatePolicyReferences } from '../validation/policy/references.js';
+import { validateContractPolicy } from '../validation/policy/uses.js';
+// An accepted DomainSchema is immutable and retains its closure, so its environment is reusable.
+const environments = new WeakMap();
+/**
+ * Accept one callable contract in the exact environment of its owner Domain, by the one validation
+ * every contract passes wherever it is declared (`validateContract`, `validateContractPolicy`,
+ * `validateCheckBudget`): the structure of a Function declaration without `ref`, its value schemas
+ * against the owner registry, its execution modifier and admission age, and its Policy with the
+ * budget of its checks. `receiver` is the owner Node Class whose Node receives the call and which
+ * the Policy names `self`: the Class of a Function instance, whose Node carries the contract, or
+ * the owner of an instance Method. Without it, as at a Function declaration, the Policy names none.
+ * Returns the canonical definition and its validators.
+ */
+export function acceptCallable(input, owner, options = {}) {
+    let value;
+    try {
+        value = acceptJsonValue(input);
+    }
+    catch (error) {
+        if (error instanceof JsonBoundaryError) {
+            throw new SchemaError([diagnostic('DV_JSON_VALUE', error.pointer, error.message)]);
+        }
+        throw error;
+    }
+    const callable = parseCallableContract(value);
+    const environment = ownerEnvironment(owner);
+    const { receiver } = options;
+    if (receiver !== undefined) {
+        const resolved = environment.resolution.resolve(receiver);
+        if (resolved === undefined ||
+            resolved.ref.kind !== 'class' ||
+            resolved.kind !== 'node' ||
+            definitionRefIndex(resolved.ref) !== definitionRefIndex(receiver) ||
+            receiver.origin !== owner.origin) {
+            throw new SchemaError([
+                diagnostic('DV_REF_RESOLVES', '', 'A receiver must be a Node Class of the owner Domain.'),
+            ]);
+        }
+    }
+    const issues = [];
+    validateContract(callable, '', environment.registry, issues);
+    if (typeof callable.policy === 'object') {
+        const policies = new PolicyValidationContext(environment.resolution, environment.analysis);
+        // Normalizes the owner's named Policies, which the Policy's checks are typed against.
+        validatePolicyReferences(policies);
+        validateContractPolicy(policies, new PolicyTyping(policies), callable, '', receiver);
+        // A document measures its own check trees (`validatePolicyBudgets`); this one is in none.
+        validateCheckBudget(policies, '/policy', measureChecks(normalizePolicyChecks(callable.policy)));
+        issues.push(...policies.diagnostics);
+    }
+    if (issues.length > 0)
+        throw new SchemaError(issues);
+    const definition = deepFreeze(canonicalizeCallable(callable));
+    const validation = callableValidation(isBinaryInput(definition.input) ? definition.input.metadata : definition.input, definition.output.mode === 'binary'
+        ? undefined
+        : definition.output.mode === 'value'
+            ? definition.output.schema
+            : definition.output.item, environment.registry, 
+    // Patterns live with these validators: carried contracts never grow a process-wide pool.
+    new Map());
+    return Object.freeze({ ...validation, definition });
+}
+function ownerEnvironment(owner) {
+    const cached = environments.get(owner);
+    if (cached !== undefined)
+        return cached;
+    const lookup = lookupForDomainClosure(owner);
+    const resolution = buildDomainResolutionContext(owner, lookup);
+    const environment = Object.freeze({
+        resolution,
+        analysis: analyzeDefinitions(resolution),
+        registry: createDomainValueSchemaRegistry(owner, lookup),
+    });
+    environments.set(owner, environment);
+    return environment;
+}

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

@@ -3,39 +3,48 @@ import { Key, PropertyKey } from '../../addressing/index.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
 import { composeMethods } from '../../language/callable/composition.js';
 import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 import { diagnostic } from '../diagnostic.js';
 const formatDefinitionRef = Key.of;
 export function analyzeDefinitions(environment) {
     const diagnostics = [];
     const result = new Map();
     const visiting = new Set();
+    // A dependency was accepted against this same exact closure: a rule breaks here only at a Class
+    // of the candidate, or on an incomplete closure, which the dependency diagnostics report. An
+    // unresolved parent is reported where the candidate names it, by Class validation.
+    const reporter = (owner) => (code, at, message, ref) => {
+        if (owner.origin !== environment.candidate.origin)
+            return;
+        const pointer = `/classes/${escapePointerToken(owner.name)}${at}`;
+        diagnostics.push(diagnostic(code, pointer, message, ref));
+    };
     const analyze = (ref) => {
         const key = definitionRefIndex(ref);
         const cached = result.get(key);
         if (cached !== undefined)
             return cached;
-        if (visiting.has(key)) {
-            diagnostics.push(diagnostic('DV_CLASS_ACYCLIC', '', `Inheritance cycle reaches ${formatDefinitionRef(ref)}.`, formatDefinitionRef(ref)));
-            return undefined;
-        }
         const resolved = environment.resolveAny(ref);
         if (resolved === undefined)
             return undefined;
         visiting.add(key);
+        const report = reporter(ref);
         const declaration = resolved.declaration;
         const parents = declaration.extends;
-        const parentAnalyses = parents.flatMap((parent) => {
+        const parentAnalyses = parents.flatMap((parent, index) => {
             const target = environment.resolveAny(parent);
-            if (target === undefined) {
-                diagnostics.push(diagnostic('DV_REF_RESOLVES', '', `Inheritance ref ${formatDefinitionRef(parent)} does not resolve.`, formatDefinitionRef(parent)));
+            if (target?.ref.kind !== 'class')
+                return [];
+            if (visiting.has(definitionRefIndex(target.ref))) {
+                report('DV_CLASS_ACYCLIC', `/extends/${index}`, `Inheritance cycle reaches ${formatDefinitionRef(parent)}.`, formatDefinitionRef(parent));
                 return [];
             }
-            const analysis = target.ref.kind === 'class' ? analyze(target.ref) : undefined;
+            const analysis = analyze(target.ref);
             return analysis === undefined ? [] : [analysis];
         });
         const properties = mergeFields(parentAnalyses.map((parent) => parent.properties), ownFields(ref, declaration));
-        const data = mergeData(ref, declaration, parentAnalyses, diagnostics);
-        const methods = mergeMethods(ref, declaration, parentAnalyses, diagnostics);
+        const data = mergeData(ref, declaration, parentAnalyses, report);
+        const methods = mergeMethods(ref, declaration, parentAnalyses, report);
         const analysis = {
             ref,
             declaration,
@@ -82,7 +91,7 @@ function mergeFields(inherited, own) {
     }
     return result;
 }
-function mergeData(owner, declaration, parents, diagnostics) {
+function mergeData(owner, declaration, parents, report) {
     let effective;
     for (const parent of parents) {
         if (parent.data === undefined)
@@ -92,14 +101,15 @@ function mergeData(owner, declaration, parents, diagnostics) {
             continue;
         }
         if (effective.identity !== parent.data.identity) {
-            diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data has distinct declaring owners ${formatDefinitionRef(effective.owner)} and ${formatDefinitionRef(parent.data.owner)}.`));
+            const index = declaration.extends.findIndex((ref) => definitionRefIndex(ref) === definitionRefIndex(parent.ref));
+            report('DV_DATA_COMPOSITION', `/extends/${index}`, `Data has distinct declaring owners ${formatDefinitionRef(effective.owner)} and ${formatDefinitionRef(parent.data.owner)}.`);
         }
     }
     const own = 'data' in declaration ? declaration.data : undefined;
     if (own === undefined)
         return effective;
     if (effective !== undefined) {
-        diagnostics.push(diagnostic('DV_DATA_COMPOSITION', '', `Data redeclares the inherited contract from ${formatDefinitionRef(effective.owner)}.`));
+        report('DV_DATA_COMPOSITION', '/data', `Data redeclares the inherited contract from ${formatDefinitionRef(effective.owner)}.`);
     }
     return {
         identity: `${definitionRefIndex(owner)}\u0000data`,
@@ -107,12 +117,20 @@ function mergeData(owner, declaration, parents, diagnostics) {
         declaration: own,
     };
 }
-function mergeMethods(owner, declaration, parents, diagnostics) {
+function mergeMethods(owner, declaration, parents, report) {
     const own = new Map(Object.entries('methods' in declaration ? declaration.methods : {}).map(([name, method]) => [
         name,
         { key: `${Key.of(owner)}.method.${name}`, owner, name, declaration: method },
     ]));
-    return composeMethods(parents, own, declaration.abstract, (left, right) => sameMethodSignature(left.declaration, right.declaration), (message) => diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', message, Key.of(owner))));
+    return composeMethods(parents, own, declaration.abstract, (left, right) => sameMethodSignature(left.declaration, right.declaration), 
+    // A changed signature is the local Method's; an ambiguous or missing one needs a local Method.
+    (message, issue) => {
+        const local = issue.kind === 'signature'
+            ? [...own.values()].find(({ key }) => key === issue.local)
+            : undefined;
+        const at = local === undefined ? '/methods' : `/methods/${escapePointerToken(local.name)}`;
+        report('DV_METHOD_COMPOSITION', at, message, Key.of(owner));
+    });
 }
 /** The exact signature required by abstract Method composition. */
 export function sameMethodSignature(left, right) {

package/dist/v1/schema/canonical/revision.js

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
+import { digestRevisionBytes } from '../../addressing/revision.js';
 import { asDomainSchema } from '../model/schema.js';
-import { digestDomainSchemaBytes } from './domain.digest.js';
-import { canonicalizeDomainSchema } from './domain.js';
+import { normalizeDomainSchema } from '../normalization/domain.js';
 // Only canonical schemas created here own a retained revision, never caller-owned input.
 const revisions = new WeakMap();
 export function canonicalDomainSchema(value) {
@@ -9,9 +9,9 @@ export function canonicalDomainSchema(value) {
 }
 /** Internal acceptance seam. The caller must establish whole-Domain validity first. */
 export function canonicalDomainSchemaAfterValidation(value) {
-    const schema = asDomainSchema(canonicalizeDomainSchema(value));
+    const schema = asDomainSchema(normalizeDomainSchema(value));
     const bytes = json.encode(schema);
-    const revision = digestDomainSchemaBytes(bytes);
+    const revision = digestRevisionBytes(bytes);
     revisions.set(schema, revision);
     return Object.freeze({ schema, bytes, revision });
 }

package/dist/v1/schema/compatibility/api.d.ts

@@ -1,3 +1,4 @@
 export { compare, compareMeaning, compareStructure } from './compare.js';
+export { closedParents } from './extension.js';
 export { requiredBump } from './versioning/index.js';
-export type { Analysis, Assessment, Bump, Comparison, ComparisonEntry, ComparisonEvidence, ComparisonRequest, ComparisonScope, Facet, Fingerprint, MeaningComparison, Observation, RequiredBump, SchemaIdentity, StructureComparison, Subject, Usage, VersionChange, } from './model.js';
+export type { Analysis, Assessment, Bump, Comparison, ComparisonEntry, ComparisonEvidence, ComparisonRequest, ComparisonScope, DiagnosticCode, Facet, Fingerprint, MeaningComparison, Observation, RequiredBump, SchemaIdentity, StructureComparison, Subject, Usage, VersionChange, } from './model.js';

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

@@ -1,2 +1,3 @@
 export { compare, compareMeaning, compareStructure } from './compare.js';
+export { closedParents } from './extension.js';
 export { requiredBump } from './versioning/index.js';

package/dist/v1/schema/compatibility/comparators/callables.js

@@ -1,7 +1,7 @@
 import { isMethodExecutable } from '../../../language/callable/executable.js';
 import { isBinaryInput } from '../../../language/callable/model/callable.js';
+import { deepFreeze } from '../../../language/freeze.js';
 import { methodSignature as inheritedSignature } from '../../analysis/class.js';
-import { deepFreeze } from '../../canonical/freeze.js';
 import { keyForDefinitionRef } from '../coordinate.js';
 import { CALLABLE_FIELDS, fieldsOf } from '../fields.js';
 import { fingerprintMeaning, semanticValueSchema } from './values.js';

package/dist/v1/schema/compatibility/comparators/classes.d.ts

@@ -1,5 +1,6 @@
 import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
 import type { Key as SemanticKey } from '../../../addressing/index.js';
+import type { Inheritance } from '../../../language/class/model/class.js';
 import type { EffectiveField } from '../../analysis/class.js';
 import type { Context } from '../context.js';
 import type { ClassCoordinate } from '../coordinate.js';
@@ -10,10 +11,12 @@ interface ClassRequirement {
     readonly ancestors: readonly SemanticKey[];
 }
 /**
- * A reference needs the Class to exist with its kind, abstractness and orientation; inheritance
- * additionally takes on the source ancestors, class policies, data contract and, for an Edge, the
- * endpoint and constraint contracts. A target projected onto a source requirement keeps only the
- * ancestors the source named, so a superset satisfies it while a removal changes it.
+ * A reference needs the Class to exist with its kind, abstractness and orientation, and, for an
+ * Edge, the uniqueness tuples that cover it, its ancestors' included: a dependent may name one of
+ * its Edges by any of them. Inheritance additionally takes on the source ancestors, class
+ * policies, data contract and, for an Edge, the endpoint and constraint contracts. A target
+ * projected onto a source requirement keeps only the ancestors the source named, so a superset
+ * satisfies it while a removal changes it.
  */
 export declare function classMeaning(context: Context, coordinate: ClassCoordinate, level: DependencyMeaningLevel, onto?: ClassRequirement): {
     readonly meaning: JsonValue;
@@ -38,6 +41,8 @@ export declare function compareLostProperties({ pair, report, }: {
     readonly pair: SubjectPair;
     readonly report: Report;
 }): void;
+/** Which Classes may extend a Class, as an extension facet compares it. */
+export declare function inheritanceMeaning(inheritance: Inheritance): JsonValue;
 /** Newly required data is an obligation even though it was absent from the source footprint. */
 export declare function compareAddedProperties({ context, pair, report, }: {
     readonly context: ComparisonContext;

package/dist/v1/schema/compatibility/comparators/classes.js

@@ -1,6 +1,7 @@
 import { compareUnicode } from '../../../addressing/ordering.js';
+import { compareEdgeUniqueTuples, coveringEdgeUniqueTuples, } from '../../../language/class/unique.js';
+import { deepFreeze } from '../../../language/freeze.js';
 import { isClassRuleChecks } from '../../../language/policy/model/policy.js';
-import { deepFreeze } from '../../canonical/freeze.js';
 import { effectiveDefinition } from '../context.js';
 import { propertyCoordinate } from '../coordinate.js';
 import { keyForDefinitionRef } from '../coordinate.js';
@@ -8,10 +9,12 @@ import { CLASS_FIELDS, PROPERTY_FIELDS, fieldsOf } from '../fields.js';
 import { usageOf } from '../references.js';
 import { semanticValueSchema } from './values.js';
 /**
- * A reference needs the Class to exist with its kind, abstractness and orientation; inheritance
- * additionally takes on the source ancestors, class policies, data contract and, for an Edge, the
- * endpoint and constraint contracts. A target projected onto a source requirement keeps only the
- * ancestors the source named, so a superset satisfies it while a removal changes it.
+ * A reference needs the Class to exist with its kind, abstractness and orientation, and, for an
+ * Edge, the uniqueness tuples that cover it, its ancestors' included: a dependent may name one of
+ * its Edges by any of them. Inheritance additionally takes on the source ancestors, class
+ * policies, data contract and, for an Edge, the endpoint and constraint contracts. A target
+ * projected onto a source requirement keeps only the ancestors the source named, so a superset
+ * satisfies it while a removal changes it.
  */
 export function classMeaning(context, coordinate, level, onto) {
     const owner = context.schemas.get(coordinate.ref.origin);
@@ -23,10 +26,12 @@ export function classMeaning(context, coordinate, level, onto) {
     const requirement = Object.freeze({
         ancestors,
     });
+    const covering = coveringTuples(context, declaration);
     const meaning = {
         coordinate: 'class',
         level: level,
         ...fieldsOf({ declaration, roles: CLASS_FIELDS, level }),
+        ...(covering.length === 0 ? {} : { unique: covering }),
         ...(level === 'inherit'
             ? {
                 extends: onto === undefined
@@ -51,12 +56,12 @@ export function classMeaning(context, coordinate, level, onto) {
     return { meaning: deepFreeze(meaning), requirement };
 }
 /**
- * A named Policy compares by its key; `false` or Policy checks by their value, as a callable's
+ * A named Policy compares by its key; a constant or Policy checks by their value, as a callable's
  * Policy does.
  */
 function classPolicyMeaning(policy) {
-    if (policy === false)
-        return false;
+    if (typeof policy === 'boolean')
+        return policy;
     return isClassRuleChecks(policy) ? policy : keyForDefinitionRef(policy);
 }
 /**
@@ -109,6 +114,18 @@ function ancestorKeys(context, ref) {
     visit(ref);
     return [...seen].sort(compareUnicode);
 }
+/**
+ * The uniqueness tuples covering an Edge Class (`coveringEdgeUniqueTuples`): those it and each of
+ * its ancestors declare, each with the Class declaring it, whose extent it bounds, in Class then
+ * tuple order. A Node Class's own tuples stay its declared field.
+ */
+function coveringTuples(context, declaration) {
+    if (declaration.kind !== 'edge')
+        return [];
+    return [
+        ...coveringEdgeUniqueTuples(declaration, (ref) => context.schemas.get(ref.origin)?.classes[ref.name]),
+    ].sort((left, right) => compareUnicode(left.class, right.class) || compareEdgeUniqueTuples(left.fields, right.fields));
+}
 /**
  * A Class a dependent references or inherits keeps every effective Property it had, whichever
  * ancestor declares it. Each Property is compared on its owner, which still declares it when the
@@ -139,6 +156,10 @@ function propertyIdentities(identities) {
         properties: Object.fromEntries(identities.map((identity) => [identity, true])),
     });
 }
+/** Which Classes may extend a Class, as an extension facet compares it. */
+export function inheritanceMeaning(inheritance) {
+    return deepFreeze({ coordinate: 'class', inheritance });
+}
 /** Newly required data is an obligation even though it was absent from the source footprint. */
 export function compareAddedProperties({ context, pair, report, }) {
     if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')

package/dist/v1/schema/compatibility/comparators/index.d.ts

@@ -5,7 +5,7 @@ import type { ComparisonContext, SubjectPair } from '../scope.js';
 export declare function compareFacet({ context, pair, facet, }: {
     readonly context: ComparisonContext;
     readonly pair: SubjectPair;
-    readonly facet: Exclude<Facet, 'class.composition' | 'class.properties' | 'property.required'>;
+    readonly facet: Exclude<Facet, 'class.composition' | 'class.properties' | 'class.inheritance' | 'property.required'>;
 }): {
     readonly before?: Value;
     readonly after?: Value;

package/dist/v1/schema/compatibility/comparators/members.js

@@ -1,4 +1,4 @@
-import { deepFreeze } from '../../canonical/freeze.js';
+import { deepFreeze } from '../../../language/freeze.js';
 import { CORE_FIELDS, POLICY_FIELDS, VIEW_FIELDS, fieldsOf } from '../fields.js';
 import { functionSignature } from './callables.js';
 export function memberMeaning(owner, ref) {

package/dist/v1/schema/compatibility/comparators/values.js

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
+import { digestRevisionBytes } from '../../../addressing/revision.js';
 import { isValueObject as isJsonObject } from '../../../language/value/model/object.js';
 import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, } from '../../../language/value/syntax/keywords.js';
-import { digestDomainSchemaBytes } from '../../canonical/domain.digest.js';
 import { ANNOTATION_KEYWORDS } from '../fields.js';
 /** Drop annotation keywords wherever a schema keyword nests a schema; never inside data. */
 export function semanticValueSchema(value) {
@@ -30,7 +30,7 @@ export function semanticValueSchema(value) {
     return semantic;
 }
 export function fingerprintMeaning(value) {
-    return digestDomainSchemaBytes(json.encode(value));
+    return digestRevisionBytes(json.encode(value));
 }
 function isJsonSchema(value) {
     return typeof value === 'boolean' || isJsonObject(value);

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

@@ -20,10 +20,10 @@ export function keyForDefinitionRef(ref) {
 /** Interpret one canonical V1 Key as a Definition or a Class member location. */
 export function keyReference(key) {
     const semantic = key.slice(key.indexOf(':') + 1);
+    // A Core slug may hold `.`: the name of a Core key is the whole rest of its coordinate.
+    if (semantic.startsWith('core.'))
+        return { kind: 'core', name: semantic.slice('core.'.length) };
     const parts = semantic.split('.');
-    if (parts[0] === 'core' && parts.length === 2) {
-        return { kind: 'core', name: parts[1] };
-    }
     if (parts.length === 2) {
         return { kind: parts[0], name: parts[1] };
     }

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

@@ -1,5 +1,6 @@
 import { compareUnicode } from '../../addressing/ordering.js';
 import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
+import { escapePointerToken } from '../../language/value/syntax/pointer.js';
 /** Structural differences between two portable values, leaf by leaf, in JSON Pointer order. */
 export function differences(before, after) {
     const found = [];
@@ -17,7 +18,7 @@ function collect(before, after, path, found) {
     if (isJsonObject(before) && isJsonObject(after)) {
         const keys = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort(compareUnicode);
         for (const key of keys) {
-            collect(before[key], after[key], `${path}/${escape(key)}`, found);
+            collect(before[key], after[key], `${path}/${escapePointerToken(key)}`, found);
         }
         return;
     }
@@ -34,6 +35,3 @@ function collect(before, after, path, found) {
         ...(after === undefined ? {} : { after }),
     }));
 }
-function escape(segment) {
-    return segment.replaceAll('~', '~0').replaceAll('/', '~1');
-}

package/dist/v1/schema/compatibility/extension.d.ts

@@ -0,0 +1,11 @@
+import type { Key } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
+/**
+ * The Classes of the target's origin that a Class of the dependent extends and the target does not
+ * open to it, as Keys in order (DM-CLASS-INHERITANCE). A parent the target no longer declares is
+ * not closed: losing it is an ancestry change.
+ */
+export declare function closedParents({ dependent, target, }: {
+    readonly dependent: DomainSchema;
+    readonly target: DomainSchema;
+}): readonly Key[];

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

@@ -0,0 +1,22 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+import { admitsForeignSubclass } from '../../language/class/inheritance.js';
+import { keyForDefinitionRef } from './coordinate.js';
+/**
+ * The Classes of the target's origin that a Class of the dependent extends and the target does not
+ * open to it, as Keys in order (DM-CLASS-INHERITANCE). A parent the target no longer declares is
+ * not closed: losing it is an ancestry change.
+ */
+export function closedParents({ dependent, target, }) {
+    const closed = new Set();
+    if (dependent.origin === target.origin)
+        return [];
+    for (const declaration of Object.values(dependent.classes))
+        for (const parent of declaration.extends) {
+            if (parent.origin !== target.origin)
+                continue;
+            const declared = target.classes[parent.name];
+            if (declared !== undefined && !admitsForeignSubclass(declared))
+                closed.add(keyForDefinitionRef(parent));
+        }
+    return Object.freeze([...closed].sort(compareUnicode));
+}

package/dist/v1/schema/compatibility/fields.d.ts

@@ -15,7 +15,7 @@ export type DependencyMeaningLevel = 'reference' | 'inherit';
  * compile until it is classified, so meaning can only be narrowed by an explicit decision.
  */
 export type FieldRole = 'always' | 'inherit' | 'members' | {
-    readonly excluded: 'identity' | 'annotation' | 'authorization' | 'presentation';
+    readonly excluded: 'identity' | 'annotation' | 'authorization' | 'extension' | 'presentation';
 };
 /** The coordinate Key already names the declaration; its `ref` is never repeated in the meaning. */
 export declare const CLASS_FIELDS: Readonly<{
@@ -24,12 +24,16 @@ export declare const CLASS_FIELDS: Readonly<{
     }>;
     kind: "always";
     abstract: "always";
+    inheritance: Readonly<{
+        excluded: 'extension';
+    }>;
     orientation: "always";
     extends: "inherit";
     policies: "inherit";
     data: "inherit";
     endpoints: "inherit";
     constraints: "inherit";
+    unique: "always";
     properties: "members";
     methods: "members";
     description: Readonly<{
@@ -50,9 +54,11 @@ export declare const PROPERTY_FIELDS: Readonly<{
     }>;
 }>;
 /**
- * The auth level and Policy check are decided by the Runtime at invocation, never compiled against.
- * The execution modifier decides what an invocation returns; an accepted Schema carries it only
- * when durable, so ordinary callables keep their meaning unchanged.
+ * The auth level, the Policy check and the admission age are authorization: decided by the Runtime
+ * at invocation, never compiled against. The admission age only bounds how old the admission a
+ * destination decides a call under may be. The execution modifier decides what an invocation
+ * returns; an accepted Schema carries it only when durable, so ordinary callables keep their meaning
+ * unchanged.
  */
 export declare const CALLABLE_FIELDS: Readonly<{
     ref: Readonly<{
@@ -63,6 +69,9 @@ export declare const CALLABLE_FIELDS: Readonly<{
     static: "always";
     abstract: "always";
     execution: "always";
+    admission: Readonly<{
+        excluded: 'authorization';
+    }>;
     auth: Readonly<{
         excluded: 'authorization';
     }>;
@@ -114,12 +123,16 @@ export declare const FIELD_ROLES: Readonly<{
         }>;
         kind: "always";
         abstract: "always";
+        inheritance: Readonly<{
+            excluded: 'extension';
+        }>;
         orientation: "always";
         extends: "inherit";
         policies: "inherit";
         data: "inherit";
         endpoints: "inherit";
         constraints: "inherit";
+        unique: "always";
         properties: "members";
         methods: "members";
         description: Readonly<{
@@ -148,6 +161,9 @@ export declare const FIELD_ROLES: Readonly<{
         static: "always";
         abstract: "always";
         execution: "always";
+        admission: Readonly<{
+            excluded: 'authorization';
+        }>;
         auth: Readonly<{
             excluded: 'authorization';
         }>;