@astrale-os/kernel-dsl 0.2.0-beta.42 → 0.2.0-beta.44

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

@@ -4,38 +4,66 @@ import { knownDomainClosure } from '../resolution/closure.js';
 import { resolve } from '../resolution/domain.js';
 import { contextOf } from './context.js';
 import { rootReferences, schemaIdentity, usageOf } from './references.js';
-import { coordinateForKey, resolveSubject } from './subjects.js';
+import { capabilityCoordinates, coordinateForKey, resolveSubject } from './subjects.js';
 export function prepare(request) {
-    const { target } = request;
-    let source;
-    let before;
-    let roots;
-    const dependent = request.scope.kind === 'dependency' ? request.scope.dependent : undefined;
-    if (request.scope.kind === 'dependency') {
-        const retained = retainedContext(request.scope.dependent, target.origin, '/target/origin');
-        source = retained.source;
-        before = retained.context;
-        roots = rootReferences(request.scope.dependent);
-    }
-    else {
-        source = request.scope.source;
+    const { scope, target } = request;
+    if (scope.kind === 'members') {
+        const { source, roots: keys } = scope;
         if (source.origin !== target.origin)
             throw new SchemaError([
                 diagnostic('DM_MEMBER_ORIGIN_MISMATCH', '/target/origin', `Member comparison target ${target.origin} does not match source ${source.origin}.`),
             ]);
-        const keys = request.scope.roots;
         if (!Array.isArray(keys) || keys.length === 0 || new Set(keys).size !== keys.length) {
             throw new SchemaError([
                 diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', 'Member comparison roots must be one non-empty duplicate-free Key set.'),
             ]);
         }
-        resolve(source);
-        before = contextOf(source);
-        roots = keys.map((key, index) => ({
+        return selectMembers(source, target, keys);
+    }
+    const { dependent } = scope;
+    const { source, context: before } = retainedContext(dependent, target.origin, '/target/origin');
+    const keys = scope.capabilities;
+    if (keys !== undefined && !Array.isArray(keys)) {
+        throw new SchemaError([
+            diagnostic('DM_CAPABILITY_INVALID', '/capabilities', 'Declared capabilities must be one Key list.'),
+        ]);
+    }
+    const usage = usageOf(dependent, 'capability');
+    const capabilities = capabilityCoordinates(before, source, keys ?? []).map((coordinate) => ({
+        coordinate,
+        usage,
+    }));
+    return comparisonContext({
+        kind: 'dependency',
+        source,
+        target,
+        dependent,
+        before,
+        roots: [...rootReferences(dependent), ...capabilities],
+        capabilities,
+    });
+}
+/**
+ * Select distinct Keys of the source against a target the caller checked to be of the same origin.
+ * The selection may be empty, which a public request cannot be: `requiredBump` selects every member
+ * of a version that may declare none.
+ */
+export function selectMembers(source, target, keys) {
+    resolve(source);
+    const before = contextOf(source);
+    return comparisonContext({
+        kind: 'members',
+        source,
+        target,
+        before,
+        roots: keys.map((key, index) => ({
             coordinate: coordinateForKey(before, source, key, index),
             usage: usageOf(source, 'selection', key),
-        }));
-    }
+        })),
+        capabilities: [],
+    });
+}
+function comparisonContext({ kind, source, target, dependent, before, roots, capabilities, }) {
     resolve(target);
     const after = contextOf(target);
     const pairs = new Map();
@@ -46,8 +74,9 @@ export function prepare(request) {
         before,
         after,
         roots,
+        capabilities,
         scope: Object.freeze({
-            kind: request.scope.kind,
+            kind,
             source: schemaIdentity(source),
             target: schemaIdentity(target),
             ...(dependent === undefined ? {} : { dependent: schemaIdentity(dependent) }),

package/dist/v1/schema/compatibility/structure/index.js

@@ -11,6 +11,11 @@ export function analyzeStructure(context) {
         kind: 'structure',
         ...result,
         compatible: result.assessments.every(({ satisfied }) => satisfied),
-        evidence: evidenceOf({ kind: 'structure', ...result }),
+        // Version 3 adds declared capability roots; without one, evidence keeps its version-2 bytes.
+        evidence: evidenceOf({
+            kind: 'structure',
+            version: context.capabilities.length > 0 ? 3 : 2,
+            ...result,
+        }),
     });
 }

package/dist/v1/schema/compatibility/structure/requirements.js

@@ -55,9 +55,11 @@ export function compareRequirements({ context, report, }) {
         }
         if (Key.origin(coordinate.key) !== context.source.origin)
             continue;
-        // Class membership does not establish an invocation dependency. Explicit member selection
-        // and inherited abstract obligations do establish requirements; call tracking can add others.
-        const required = facet !== 'method.existence' || usage.relation === 'selection';
+        // Class membership does not establish an invocation dependency. Explicit member selection,
+        // a Method the dependent declares as a capability, and inherited abstract obligations do.
+        const required = facet !== 'method.existence' ||
+            usage.relation === 'selection' ||
+            usage.relation === 'capability';
         report.record({
             pair,
             facet,

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

@@ -32,3 +32,8 @@ export declare function resolveSubject({ context, coordinate, }: {
 export declare function identityOf(coordinate: Coordinate): Subject;
 /** Resolve one caller-supplied Key of the source into an exact coordinate that exists there. */
 export declare function coordinateForKey(context: Context, source: DomainSchema, input: SemanticKey, index: number): Coordinate;
+/**
+ * Resolve the Function, Method and Class Keys a dependent declares as capabilities into exact
+ * coordinates of its retained source. Keys of other origins belong to other comparisons.
+ */
+export declare function capabilityCoordinates(context: Context, source: DomainSchema, capabilities: readonly SemanticKey[]): readonly Coordinate[];

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

@@ -79,6 +79,45 @@ export function coordinateForKey(context, source, input, index) {
     }
     return coordinate;
 }
+/**
+ * Resolve the Function, Method and Class Keys a dependent declares as capabilities into exact
+ * coordinates of its retained source. Keys of other origins belong to other comparisons.
+ */
+export function capabilityCoordinates(context, source, capabilities) {
+    return capabilities.flatMap((key, index) => {
+        if (!Key.is(key))
+            return invalidCapability(key, index, 'is not a canonical semantic Key');
+        if (Key.origin(key) !== source.origin)
+            return [];
+        const coordinate = capabilityCoordinate(source, key);
+        if (coordinate === undefined) {
+            return invalidCapability(key, index, 'is not a Function, Method or Class');
+        }
+        if (resolveSubject({ context, coordinate }) === undefined) {
+            return invalidCapability(key, index, `does not exist in the retained ${source.origin}`);
+        }
+        return [coordinate];
+    });
+}
+/** A capability names a Function, a Method by its declaring Class, or a Class. */
+function capabilityCoordinate(source, key) {
+    const { kind, name, member, ownerName } = keyReference(key);
+    const { origin } = source;
+    if (member === 'method')
+        return methodCoordinate({ origin, kind: 'class', name: ownerName }, name);
+    if (member !== undefined)
+        return undefined;
+    if (kind === 'class')
+        return classCoordinate({ origin, kind: 'class', name });
+    if (kind === 'function')
+        return memberCoordinate({ origin, kind: 'function', name });
+    return undefined;
+}
+function invalidCapability(key, index, reason) {
+    throw new SchemaError([
+        diagnostic('DM_CAPABILITY_INVALID', `/capabilities/${index}`, `Capability ${JSON.stringify(key)} ${reason}.`, typeof key === 'string' ? key : undefined),
+    ]);
+}
 function invalidMemberRoot(key, index, reason) {
     throw new SchemaError([
         diagnostic('DM_MEMBER_ROOT_INVALID', `/roots/${index}`, `Key ${JSON.stringify(key)} ${reason}.`, typeof key === 'string' ? key : undefined),

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

@@ -0,0 +1,8 @@
+import type { DomainSchema } from '../../model/schema.js';
+import type { RequiredBump } from '../model.js';
+/**
+ * Minimum schema bump: unsatisfied requirements are major, additions minor, other changes patch.
+ * Concrete callable authorization and code behavior are outside this floor; abstract Method auth
+ * belongs to the inherited signature. Version arithmetic stays with the caller.
+ */
+export declare function requiredBump(previous: DomainSchema, next: DomainSchema): RequiredBump;

package/dist/v1/schema/compatibility/versioning/index.js

@@ -0,0 +1,50 @@
+import { deepFreeze } from '../../canonical/freeze.js';
+import { SchemaError, diagnostic } from '../../diagnostic.js';
+import { compareFootprint } from '../meaning/footprint.js';
+import { schemaIdentity } from '../references.js';
+import { createReport } from '../report.js';
+import { selectMembers } from '../scope.js';
+import { compareRequirements } from '../structure/requirements.js';
+import { compareAdditions, memberCoordinates } from './members.js';
+import { compareSurface } from './surface.js';
+const LEVELS = ['patch', 'minor', 'major'];
+/**
+ * Minimum schema bump: unsatisfied requirements are major, additions minor, other changes patch.
+ * Concrete callable authorization and code behavior are outside this floor; abstract Method auth
+ * belongs to the inherited signature. Version arithmetic stays with the caller.
+ */
+export function requiredBump(previous, next) {
+    if (previous.origin !== next.origin)
+        throw new SchemaError([
+            diagnostic('DM_MEMBER_ORIGIN_MISMATCH', '/next/origin', `Next version ${next.origin} does not match previous version ${previous.origin}.`),
+        ]);
+    const identities = { previous: schemaIdentity(previous), next: schemaIdentity(next) };
+    if (identities.previous.revision === identities.next.revision)
+        return deepFreeze({ level: 'patch', ...identities, changes: [] });
+    const members = memberCoordinates(previous);
+    const context = selectMembers(previous, next, members.map(({ key }) => key));
+    // Surface observations must win when an existing obligation becomes newly imposed on a Class.
+    const report = createReport();
+    compareSurface({ context, report });
+    compareRequirements({ context, report });
+    compareFootprint({ context, report });
+    compareAdditions({ context, report, previous: members });
+    const { entries, assessments } = report.finish();
+    const unsatisfied = new Set(assessments.filter(({ satisfied }) => !satisfied).map(({ observation }) => observation.id));
+    const changes = entries.flatMap(({ subject, observations }) => observations
+        .filter(({ state }) => state !== 'equal')
+        .map((observation) => ({
+        subject,
+        observation,
+        bump: unsatisfied.has(observation.id)
+            ? 'major'
+            : observation.state === 'added'
+                ? 'minor'
+                : 'patch',
+    })));
+    return deepFreeze({
+        level: changes.reduce((level, { bump }) => (LEVELS.indexOf(bump) > LEVELS.indexOf(level) ? bump : level), 'patch'),
+        ...identities,
+        changes,
+    });
+}

package/dist/v1/schema/compatibility/versioning/members.d.ts

@@ -0,0 +1,12 @@
+import type { DomainSchema } from '../../model/schema.js';
+import type { Coordinate } from '../coordinate.js';
+import type { Report } from '../report.js';
+import type { ComparisonContext } from '../scope.js';
+/** Inherited members count once, at their declaring Class. */
+export declare function memberCoordinates(schema: DomainSchema): readonly Coordinate[];
+/** New declarations impose no requirements here; the surface pass checks obligations on existing Classes. */
+export declare function compareAdditions({ context, report, previous, }: {
+    readonly context: ComparisonContext;
+    readonly report: Report;
+    readonly previous: readonly Coordinate[];
+}): void;

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

@@ -0,0 +1,47 @@
+import { compareFacet } from '../comparators/index.js';
+import { classCoordinate, memberCoordinate, methodCoordinate, propertyCoordinate, } from '../coordinate.js';
+/** Inherited members count once, at their declaring Class. */
+export function memberCoordinates(schema) {
+    const result = [];
+    for (const declaration of Object.values(schema.classes)) {
+        result.push(classCoordinate(declaration.ref));
+        for (const name of Object.keys(declaration.properties))
+            result.push(propertyCoordinate(declaration.ref, name));
+        if (declaration.kind === 'node')
+            for (const name of Object.keys(declaration.methods))
+                result.push(methodCoordinate(declaration.ref, name));
+    }
+    for (const { ref } of [
+        ...Object.values(schema.functions),
+        ...Object.values(schema.policies),
+        ...Object.values(schema.views),
+        ...Object.values(schema.core.nodes),
+    ])
+        result.push(memberCoordinate(ref));
+    return result;
+}
+/** New declarations impose no requirements here; the surface pass checks obligations on existing Classes. */
+export function compareAdditions({ context, report, previous, }) {
+    const known = new Set(previous.map(({ key }) => key));
+    for (const coordinate of memberCoordinates(context.target)) {
+        if (known.has(coordinate.key))
+            continue;
+        const pair = context.pair(coordinate);
+        for (const facet of selectedFacets(coordinate))
+            report.record({ pair, facet, ...compareFacet({ context, pair, facet }) });
+    }
+}
+function selectedFacets(coordinate) {
+    switch (coordinate.kind) {
+        case 'class':
+            return ['class.reference'];
+        case 'property':
+            return ['property'];
+        case 'method':
+            return ['method.existence', 'method.signature'];
+        case 'member':
+            return coordinate.ref.kind === 'function'
+                ? ['function.existence', 'function.signature']
+                : [coordinate.ref.kind];
+    }
+}

package/dist/v1/schema/compatibility/versioning/surface.d.ts

@@ -0,0 +1,11 @@
+import type { Report } from '../report.js';
+import type { ComparisonContext } from '../scope.js';
+/**
+ * Compare inherited contracts and newly imposed obligations on existing Classes.
+ * Obligations are reported at their declaring Method: changed signatures retain their comparison;
+ * an unchanged obligation newly inherited by a Class is added and unsatisfied.
+ */
+export declare function compareSurface({ context, report, }: {
+    readonly context: ComparisonContext;
+    readonly report: Report;
+}): void;

package/dist/v1/schema/compatibility/versioning/surface.js

@@ -0,0 +1,61 @@
+import { methodInheritance } from '../comparators/callables.js';
+import { compareAddedProperties } from '../comparators/classes.js';
+import { compareFacet } from '../comparators/index.js';
+import { fingerprintMeaning } from '../comparators/values.js';
+import { classCoordinate, methodCoordinate } from '../coordinate.js';
+/**
+ * Compare inherited contracts and newly imposed obligations on existing Classes.
+ * Obligations are reported at their declaring Method: changed signatures retain their comparison;
+ * an unchanged obligation newly inherited by a Class is added and unsatisfied.
+ */
+export function compareSurface({ context, report, }) {
+    const established = new Map();
+    const imposed = new Map();
+    for (const declaration of Object.values(context.source.classes)) {
+        if (context.target.classes[declaration.ref.name] === undefined)
+            continue;
+        const pair = context.pair(classCoordinate(declaration.ref));
+        const { source, target } = pair;
+        if (source?.kind !== 'class' || target?.kind !== 'class')
+            continue;
+        report.record({
+            pair,
+            facet: 'class.inherit',
+            ...compareFacet({ context, pair, facet: 'class.inherit' }),
+            requirement: { kind: 'class.inherit' },
+        });
+        compareAddedProperties({ context, pair, report });
+        for (const [key, method] of source.analysis.requirements)
+            if (!established.has(key))
+                established.set(key, method);
+        for (const [key, method] of target.analysis.requirements)
+            if (!source.analysis.requirements.has(key) && !imposed.has(key))
+                imposed.set(key, method);
+    }
+    for (const key of new Set([...established.keys(), ...imposed.keys()])) {
+        const added = imposed.get(key);
+        const method = established.get(key) ?? added;
+        const pair = context.pair(methodCoordinate(method.owner, method.name));
+        const comparison = established.has(key)
+            ? compareFacet({ context, pair, facet: 'method.inheritance' })
+            : undefined;
+        report.record(comparison !== undefined && (added === undefined || changed(comparison))
+            ? {
+                pair,
+                facet: 'method.inheritance',
+                ...comparison,
+                requirement: { kind: 'method.inheritance' },
+            }
+            : {
+                pair,
+                facet: 'method.inheritance',
+                after: methodInheritance(added),
+                requirement: { kind: 'method.inheritance', satisfied: false },
+            });
+    }
+}
+function changed({ before, after }) {
+    return (before === undefined ||
+        after === undefined ||
+        fingerprintMeaning(before) !== fingerprintMeaning(after));
+}

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

@@ -1,4 +1,4 @@
-export type SchemaDiagnosticCode = 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'DV_VIEW_TARGET' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
+export type SchemaDiagnosticCode = 'DM_CAPABILITY_INVALID' | 'DM_MEMBER_ROOT_INVALID' | 'DM_DEPENDENCY_CONTEXT_INVALID' | 'DM_DEPENDENCY_NOT_RETAINED' | 'DM_MEANING_INCONSISTENT' | 'DM_MEMBER_ORIGIN_MISMATCH' | 'DV_ACCEPTANCE_CONTEXT' | 'DV_CALLABLE_AUTH' | 'DV_CALLABLE_IO' | 'DV_CALLABLE_POLICY_AUTH' | 'DV_CLASS_ABSTRACT' | 'DV_CLASS_ACYCLIC' | 'DV_CLASS_KIND' | 'DV_CORE_EDGE_CLASS' | 'DV_CORE_EDGE_CONSTRAINTS' | 'DV_CORE_EDGE_KEY' | 'DV_CORE_EDGE_PROPERTIES' | 'DV_CORE_NODE_CLASS' | 'DV_CORE_NODE_PROPERTIES' | 'DV_CORE_REF' | 'DV_DATA_COMPOSITION' | 'DV_DEPENDENCY_ACYCLIC' | 'DV_DEPENDENCY_DIRECT' | 'DV_DEPENDENCY_EXACT' | 'DV_DEPENDENCY_LIMITS' | 'DV_DEPENDENCY_REVISION_COHERENCE' | 'DV_DEPENDENCY_UNIQUE' | 'DV_EDGE_ACCEPTS' | 'DV_EDGE_CLASS_COMPOSITION' | 'DV_EDGE_CONSTRAINT' | 'DV_EDGE_ROLE' | 'DV_EDGE_UNDIRECTED' | 'DV_JSON_VALUE' | 'DV_METHOD_ABSTRACT' | 'DV_METHOD_COMPOSITION' | 'DV_PROPERTY_AUTO' | 'DV_PROPERTY_COMPOSITION' | 'DV_PROPERTY_STATE' | 'DV_REF_RESOLVES' | 'DV_VALUE_SCHEMA' | 'DV_VIEW_TARGET' | 'PL_BUDGET' | 'PL_COMPOSITION' | 'PL_CONNECTIVITY' | 'PL_REF' | 'PL_REPEAT' | 'PL_TARGET' | 'PL_TYPING' | 'PL_USE' | 'PL_VARIABLE_SCOPE' | 'STRUCTURE_ABSTRACT_POLICY' | 'STRUCTURE_CALLABLE_POLICY_AUTH' | 'STRUCTURE_DUPLICATE_ITEM' | 'STRUCTURE_EDGE_ORIENTATION' | 'STRUCTURE_FORMAT' | 'STRUCTURE_INVALID' | 'STRUCTURE_KEY' | 'STRUCTURE_MAXIMUM' | 'STRUCTURE_MINIMUM' | 'STRUCTURE_MULTIPLE' | 'STRUCTURE_REQUIRED' | 'STRUCTURE_TYPE' | 'STRUCTURE_UNION' | 'STRUCTURE_UNKNOWN_FIELD' | 'STRUCTURE_VALUE' | 'UNSUPPORTED_DOCUMENT_FORMAT' | 'UNSUPPORTED_DSL_VERSION';
 export interface SchemaDiagnostic<out Code extends SchemaDiagnosticCode = SchemaDiagnosticCode> {
     readonly code: Code;
     readonly pointer: string;

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

@@ -11,8 +11,8 @@ export type { SchemaDiagnosticCode as DiagnosticCode } from './diagnostic.js';
 export { acceptDomainSchema as accept } from './admission/accept.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint, compareDependencyMeaning, compareMemberMeaning, describeMeaningChange, footprintOf, meaningOf, } from './compatibility/index.js';
-export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, DependencyMeaningLevel, FieldRole, FootprintEntry, MeaningDifference, MeaningFingerprint, } from './compatibility/index.js';
+export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint } from './compatibility/index.js';
+export type { FieldRole, MeaningDifference, MeaningFingerprint } from './compatibility/index.js';
 export * as compatibility from './compatibility/api.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
@@ -25,5 +25,3 @@ export type { DomainSchemaHeader as Header } from './codec/header.js';
 export type { DomainDependency } from '../addressing/index.js';
 /** The versioned value-schema grammar embedded in declarations. */
 export * as values from './validation/value-api.js';
-export { compareDependencyStructure } from './compatibility/index.js';
-export type { DependencyStructureComparison } from './compatibility/index.js';

package/dist/v1/schema/index.js

@@ -4,7 +4,7 @@ export const resolve = resolveDomainSchema;
 export { acceptDomainSchema as accept } from './admission/accept.js';
 export { decodeDomainSchema as decode, encodeDomainSchema as encode, serializeDomainSchema as serialize, } from './codec/schema.js';
 export { revisionOfDomainSchema as revision } from './canonical/revision.js';
-export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint, compareDependencyMeaning, compareMemberMeaning, describeMeaningChange, footprintOf, meaningOf, } from './compatibility/index.js';
+export { ANNOTATION_KEYWORDS, FIELD_ROLES, callableFingerprint } from './compatibility/index.js';
 export * as compatibility from './compatibility/api.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
@@ -12,4 +12,3 @@ export { compile, load } from '../compiled/index.js';
 export { SchemaError as Error } from './diagnostic.js';
 /** The versioned value-schema grammar embedded in declarations. */
 export * as values from './validation/value-api.js';
-export { compareDependencyStructure } from './compatibility/index.js';

package/dist/v1/schema/validation/policy/typing.d.ts

@@ -12,6 +12,8 @@ export declare class PolicyTyping {
     constructor(context: PolicyValidationContext);
     validatePolicies(): void;
     policyAccepts(name: string, object: ObjectContract): boolean;
+    /** Whether each normalized branch of the Policy is typed for an object of this contract. */
+    policyBranchTyping(name: string, object: ObjectContract): readonly boolean[] | undefined;
     policyAcceptsEdge(name: string, source: ObjectContract, target: ObjectContract): boolean;
     concreteEndpointClasses(accepts: readonly ClassRef[]): readonly ClassRef[];
     endpointsOverlap(left: readonly ClassRef[], right: readonly ClassRef[]): boolean;

package/dist/v1/schema/validation/policy/typing.js

@@ -35,9 +35,13 @@ export class PolicyTyping {
         }
     }
     policyAccepts(name, object) {
+        return this.policyBranchTyping(name, object)?.every(Boolean) ?? false;
+    }
+    /** Whether each normalized branch of the Policy is typed for an object of this contract. */
+    policyBranchTyping(name, object) {
         const branches = this.#expandedBranches(name, new Set(), `$use:${name}`);
         const use = { kind: 'object', object };
-        return branches !== undefined && branches.every((branch) => this.#branchIsTyped(branch, use));
+        return branches?.map((branch) => this.#branchIsTyped(branch, use));
     }
     policyAcceptsEdge(name, source, target) {
         const branches = this.#expandedBranches(name, new Set(), `$edge-use:${name}`);

package/dist/v1/schema/validation/policy/uses.js

@@ -1,6 +1,7 @@
 import { Key } from '../../../addressing/index.js';
 import { definitionRefIndex } from '../../../addressing/ordering.js';
 import { isBinaryInput } from '../../../language/callable/model/callable.js';
+import { admittedCheckClasses, neverAdmittedClasses, } from '../../../language/policy/analysis/checks.js';
 import { normalizePolicyChecks } from '../../../language/policy/normalization/normalize.js';
 import { GRAPH_NODE_PATH_SCHEMA_ID } from '../../../language/value/syntax/node-path/schema.js';
 import { MAX_BRANCHES, MAX_CHECK_DEPTH, MAX_CHECK_LEAVES, measureChecks } from './budgets.js';
@@ -89,9 +90,13 @@ function validateChecks(validation, typing, expression, context) {
         measure.leaves > MAX_CHECK_LEAVES) {
         validation.add('PL_BUDGET', context.pointer, `Callable checks require depth <= ${MAX_CHECK_DEPTH}, branches <= ${MAX_BRANCHES}, and leaves <= ${MAX_CHECK_LEAVES}; got ${measure.depth}, ${measure.branches}, ${measure.leaves}.`);
     }
-    visitChecks(validation, typing, normalized, context, context.pointer);
+    const leaves = new Map();
+    visitChecks(validation, typing, normalized, context, context.pointer, leaves);
+    for (const [object, className] of neverAdmittedClasses(normalized, leaves)) {
+        validation.add('PL_USE', context.pointer, `Callable checks can never admit ${object} of Class ${className}.`, className);
+    }
 }
-function visitChecks(validation, typing, expression, context, pointer) {
+function visitChecks(validation, typing, expression, context, pointer, leaves) {
     if ('sameNode' in expression) {
         for (const [side, object] of Object.entries(expression.sameNode)) {
             const objectPointer = `${pointer}/sameNode/${side}`;
@@ -115,19 +120,26 @@ function visitChecks(validation, typing, expression, context, pointer) {
                 : referenceContracts(validation, expression.object.ref, objectPointer);
         if (contracts === undefined)
             return;
-        for (const contract of contracts) {
-            if (!typing.policyAccepts(expression.check.name, contract)) {
-                validation.add('PL_USE', pointer, `${formatDefinitionRef(expression.check)} is incompatible with the callable object contract.`, formatDefinitionRef(expression.check));
-                break;
-            }
+        const typings = new Map(contracts.map((contract) => [
+            contractName(contract),
+            typing.policyBranchTyping(expression.check.name, contract),
+        ]));
+        const admitted = admittedCheckClasses(typings);
+        if (admitted === undefined) {
+            validation.add('PL_USE', pointer, `${formatDefinitionRef(expression.check)} is incompatible with the callable object contract.`, formatDefinitionRef(expression.check));
+            return;
         }
+        leaves.set(expression, { accepted: [...typings.keys()], admitted });
         return;
     }
     const { key, values } = checkOperands(expression);
     if (values.length === 0) {
         validation.add('PL_COMPOSITION', `${pointer}/${key}`, `${key} must be non-empty.`);
     }
-    values.forEach((child, index) => visitChecks(validation, typing, child, context, `${pointer}/${key}/${index}`));
+    values.forEach((child, index) => visitChecks(validation, typing, child, context, `${pointer}/${key}/${index}`, leaves));
+}
+function contractName(contract) {
+    return contract.kind === 'exact' ? formatDefinitionRef(contract.ref) : 'default';
 }
 function selfContracts(validation, context, pointer) {
     if (!context.instanceMethod || context.receiver === undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.42",
+  "version": "0.2.0-beta.44",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {
@@ -67,6 +67,10 @@
       "types": "./dist/v1/schema/index.d.ts",
       "import": "./dist/v1/schema/index.js"
     },
+    "./v1/schema/compatibility": {
+      "types": "./dist/v1/schema/compatibility/api.d.ts",
+      "import": "./dist/v1/schema/compatibility/api.js"
+    },
     "./v1/schema/fingerprint": {
       "types": "./dist/v1/schema/fingerprint.d.ts",
       "import": "./dist/v1/schema/fingerprint.js"

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

@@ -1,58 +0,0 @@
-/** Historical positional APIs and version-3 wire evidence. New analyses never depend on this adapter. */
-import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
-import type { Definition, Key as SemanticKey, Revision } from '../../../addressing/index.js';
-import type { DomainSchema } from '../../model/schema.js';
-import type { MeaningDifference } from '../diff.js';
-import type { DependencyMeaningLevel } from '../fields.js';
-import type { Fingerprint as MeaningFingerprint } from '../model.js';
-export type DependencyMeaningChangeKind = 'missing' | 'changed' | 'added';
-export type DependencyMeaningChange = {
-    readonly key: SemanticKey;
-    readonly kind: 'missing';
-    readonly sourceFingerprint: MeaningFingerprint;
-} | {
-    readonly key: SemanticKey;
-    readonly kind: 'changed';
-    readonly sourceFingerprint: MeaningFingerprint;
-    readonly targetFingerprint: MeaningFingerprint;
-    /** Every exact path of the meaning that differs, in JSON Pointer order. */
-    readonly differences: readonly MeaningDifference[];
-} | {
-    /** A required, non-automatic Property the target adds to an inherited Class. */
-    readonly key: SemanticKey;
-    readonly kind: 'added';
-    readonly targetFingerprint: MeaningFingerprint;
-    readonly meaning: JsonValue;
-};
-export interface DependencyMeaningComparison {
-    readonly version: 3;
-    readonly dependency: SemanticKey.Origin;
-    readonly source: Revision;
-    readonly target: Revision;
-    readonly footprint: readonly SemanticKey[];
-    readonly changes: readonly DependencyMeaningChange[];
-    readonly fingerprint: MeaningFingerprint;
-}
-/** One footprint entry: the Key, what it is, and for a Class how strongly it is used. */
-export interface FootprintEntry {
-    readonly key: SemanticKey;
-    readonly kind: Definition.Kind | 'property' | 'method';
-    readonly level?: DependencyMeaningLevel;
-}
-export interface DependencyStructureComparison {
-    readonly kind: 'structure';
-    readonly version: 1;
-    readonly dependency: SemanticKey.Origin;
-    readonly source: Revision;
-    readonly target: Revision;
-    readonly footprint: readonly SemanticKey[];
-    readonly changes: readonly DependencyMeaningChange[];
-    readonly fingerprint: MeaningFingerprint;
-}
-export declare function compareDependencyMeaning(dependent: DomainSchema, target: DomainSchema): DependencyMeaningComparison;
-export declare function compareMemberMeaning(source: DomainSchema, target: DomainSchema, roots: readonly [SemanticKey, ...SemanticKey[]]): DependencyMeaningComparison;
-export declare function compareDependencyStructure(dependent: DomainSchema, target: DomainSchema): DependencyStructureComparison;
-export declare function footprintOf(dependent: DomainSchema, origin: SemanticKey.Origin): readonly FootprintEntry[];
-export declare function meaningOf(schema: DomainSchema, key: SemanticKey, level?: DependencyMeaningLevel): JsonValue;
-/** One line an operator can act on, naming the exact paths of a changed meaning. */
-export declare function describeMeaningChange(change: DependencyMeaningChange): string;