@astrale-os/kernel-dsl 0.2.0-beta.8 → 0.2.0

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

@@ -1,7 +1,7 @@
 import { json } from '@astrale-os/kernel-dsl/value';
 import { Key, PropertyKey } from '../../addressing/index.js';
 import { definitionRefIndex } from '../../addressing/ordering.js';
-import { normalizePolicyChecks } from '../../language/policy/normalization/normalize.js';
+import { composeMethods } from '../../language/callable/composition.js';
 import { canonicalizeValueSchema } from '../../language/value/profile/canonicalize.js';
 import { diagnostic } from '../diagnostic.js';
 const formatDefinitionRef = Key.of;
@@ -41,7 +41,7 @@ export function analyzeDefinitions(environment) {
             declaration,
             properties,
             ...(data === undefined ? {} : { data }),
-            methods,
+            ...methods,
         };
         result.set(key, analysis);
         visiting.delete(key);
@@ -62,8 +62,9 @@ function ownFields(owner, declaration) {
             name,
             schema: property.schema,
             required: property.required,
-            visibility: property.visibility,
             ...(property.auto === undefined ? {} : { auto: property.auto }),
+            ...(property.immutable === undefined ? {} : { immutable: property.immutable }),
+            ...(property.state === undefined ? {} : { state: property.state }),
         });
     }
     return result;
@@ -107,75 +108,39 @@ function mergeData(owner, declaration, parents, diagnostics) {
     };
 }
 function mergeMethods(owner, declaration, parents, diagnostics) {
-    if (!('methods' in declaration))
-        return new Map();
-    const inherited = new Map();
-    for (const parent of parents) {
-        for (const [name, method] of parent.methods) {
-            const entries = inherited.get(name) ?? [];
-            if (!entries.some((entry) => entry.identity === method.identity))
-                entries.push(method);
-            inherited.set(name, entries);
-        }
-    }
-    const result = new Map();
-    for (const [name, entries] of inherited) {
-        if (entries.length === 1)
-            result.set(name, entries[0]);
-    }
-    for (const [name, ownMethod] of Object.entries(declaration.methods)) {
-        const parentsForName = inherited.get(name) ?? [];
-        for (const parent of parentsForName) {
-            if (parent.declaration.inheritance === 'sealed') {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} cannot override sealed ${formatDefinitionRef(parent.owner)}.${name}.`));
-            }
-            if (!sameMethodSignature(ownMethod, parent.declaration)) {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} does not exactly preserve its inherited signature.`));
-            }
-            if (parent.declaration.inheritance !== 'abstract' &&
-                canonicalPolicy(parent.declaration.policy) !== canonicalPolicy(ownMethod.policy)) {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Method ${name} changes an executable inherited Policy.`));
-            }
-        }
-        result.set(name, {
-            identity: `${definitionRefIndex(owner)}\u0000method\u0000${name}`,
-            owner,
-            name,
-            declaration: ownMethod,
-        });
-        inherited.delete(name);
-    }
-    for (const [name, entries] of inherited) {
-        if (entries.length > 1) {
-            diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Inherited method ${name} is ambiguous and has no local override.`));
-        }
-    }
-    if (declaration.kind === 'node' && !declaration.abstract) {
-        for (const [name, method] of result) {
-            if (method.declaration.inheritance === 'abstract') {
-                diagnostics.push(diagnostic('DV_METHOD_COMPOSITION', '', `Concrete Class ${owner.name} leaves method ${name} abstract.`));
-            }
-        }
-    }
-    return result;
+    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))));
 }
-function sameMethodSignature(left, right) {
-    return (json.serialize(canonicalizeValueSchema(left.input, 'callable-input')) ===
-        json.serialize(canonicalizeValueSchema(right.input, 'callable-input')) &&
-        canonicalMethodOutput(left) === canonicalMethodOutput(right) &&
-        left.auth === right.auth &&
-        left.static === right.static);
+/** The exact signature required by abstract Method composition. */
+export function sameMethodSignature(left, right) {
+    return json.serialize(methodSignature(left)) === json.serialize(methodSignature(right));
+}
+/**
+ * Shared canonical signature used by admission and compatibility explanations. The execution
+ * modifier appears only when durable, so absent and `durable: false` are the same signature.
+ */
+export function methodSignature(value) {
+    return {
+        input: canonicalizeValueSchema(value.input, 'callable-input'),
+        output: canonicalMethodOutput(value),
+        auth: value.auth,
+        static: value.static,
+        ...(value.execution?.durable === true ? { execution: { durable: true } } : {}),
+    };
 }
 function canonicalMethodOutput(value) {
     switch (value.output.mode) {
         case 'value':
-            return `value:${json.serialize(canonicalizeValueSchema(value.output.schema, 'callable-output'))}`;
+            return {
+                mode: 'value',
+                schema: canonicalizeValueSchema(value.output.schema, 'callable-output'),
+            };
         case 'stream':
-            return `stream:${json.serialize(canonicalizeValueSchema(value.output.item, 'callable-output'))}`;
+            return { mode: 'stream', item: canonicalizeValueSchema(value.output.item, 'callable-output') };
         case 'binary':
-            return 'binary';
+            return { mode: 'binary' };
     }
 }
-function canonicalPolicy(value) {
-    return json.serialize(value === undefined ? null : normalizePolicyChecks(value));
-}

package/dist/v1/schema/canonical/revision.d.ts

@@ -1,6 +1,6 @@
 import type { Revision } from '../../addressing/index.js';
 import { type DomainSchema, type DomainSchemaIR } from '../model/schema.js';
-export interface CanonicalDomainSchema {
+interface CanonicalDomainSchema {
     readonly schema: DomainSchema;
     readonly bytes: Uint8Array;
     readonly revision: Revision;
@@ -9,3 +9,4 @@ export declare function canonicalDomainSchema(value: DomainSchema): CanonicalDom
 /** Internal acceptance seam. The caller must establish whole-Domain validity first. */
 export declare function canonicalDomainSchemaAfterValidation(value: DomainSchemaIR): CanonicalDomainSchema;
 export declare function revisionOfDomainSchema(schema: DomainSchema): Revision;
+export {};

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

@@ -2,6 +2,8 @@ import { json } from '@astrale-os/kernel-dsl/value';
 import { asDomainSchema } from '../model/schema.js';
 import { digestDomainSchemaBytes } from './domain.digest.js';
 import { canonicalizeDomainSchema } from './domain.js';
+// Only canonical schemas created here own a retained revision, never caller-owned input.
+const revisions = new WeakMap();
 export function canonicalDomainSchema(value) {
     return canonicalDomainSchemaAfterValidation(value);
 }
@@ -10,8 +12,9 @@ export function canonicalDomainSchemaAfterValidation(value) {
     const schema = asDomainSchema(canonicalizeDomainSchema(value));
     const bytes = json.encode(schema);
     const revision = digestDomainSchemaBytes(bytes);
+    revisions.set(schema, revision);
     return Object.freeze({ schema, bytes, revision });
 }
 export function revisionOfDomainSchema(schema) {
-    return canonicalDomainSchema(schema).revision;
+    return revisions.get(schema) ?? canonicalDomainSchema(schema).revision;
 }

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

@@ -0,0 +1,3 @@
+export { compare, compareMeaning, compareStructure } from './compare.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';

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

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

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

@@ -0,0 +1,39 @@
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type { CallableExecution, CallableOutput, CallableInputContract, FunctionDefinition, MethodDefinition } from '../../../language/callable/model/callable.js';
+import type { ResolvedFunction, ResolvedMethod } from '../../../language/callable/resolved.js';
+import type { EffectiveMethod } from '../../analysis/class.js';
+import type { Fingerprint } from '../model.js';
+export declare function methodExistence(method: EffectiveMethod): Value;
+/**
+ * A Method as a Policy object resolves it: its owner's own declaration and whether that Class can
+ * execute it. Dispatch and the signature are the caller's, not the Policy's.
+ */
+export declare function methodObject(method: EffectiveMethod, owner: {
+    readonly abstract: boolean;
+}): Value;
+export declare function methodSignature(method: EffectiveMethod): Value;
+export declare function methodInheritance(method: EffectiveMethod): Value;
+export declare function functionSignature(declaration: FunctionDefinition): Value;
+export declare function functionExistence(): Value;
+/**
+ * Fingerprint the contract a caller compiles against, independently of its Domain revision: the
+ * exact key, the owner, dispatch and abstractness of a Method, the semantic input and output
+ * contracts, and the durable execution modifier; authorization is excluded
+ * (DM-CALLABLE-FINGERPRINT). A static consumer pins this instead of a Domain revision, so a
+ * dependency release that leaves the callable contract untouched keeps every bound invocation
+ * valid.
+ */
+export declare function callableFingerprint(callable: ResolvedFunction | ResolvedMethod): Fingerprint;
+type CallableSignature = {
+    readonly static?: boolean;
+    readonly abstract?: boolean;
+    readonly execution?: CallableExecution;
+    readonly input: CallableInputContract;
+    readonly output: CallableOutput;
+};
+/**
+ * The `always` fields of CALLABLE_FIELDS: dispatch shape, the execution modifier, and the semantic
+ * input and output.
+ */
+export declare function callableSignature(declaration: Pick<FunctionDefinition, 'input' | 'output' | 'execution'> | Pick<MethodDefinition, 'static' | 'abstract' | 'input' | 'output' | 'execution'>): CallableSignature;
+export {};

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

@@ -0,0 +1,101 @@
+import { isMethodExecutable } from '../../../language/callable/executable.js';
+import { isBinaryInput } from '../../../language/callable/model/callable.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';
+export function methodExistence(method) {
+    return deepFreeze({
+        coordinate: 'method',
+        owner: keyForDefinitionRef(method.owner),
+        name: method.name,
+        static: method.declaration.static,
+        abstract: method.declaration.abstract,
+    });
+}
+/**
+ * A Method as a Policy object resolves it: its owner's own declaration and whether that Class can
+ * execute it. Dispatch and the signature are the caller's, not the Policy's.
+ */
+export function methodObject(method, owner) {
+    return deepFreeze({
+        coordinate: 'method',
+        owner: keyForDefinitionRef(method.owner),
+        name: method.name,
+        executable: isMethodExecutable(owner, method.declaration),
+    });
+}
+export function methodSignature(method) {
+    return deepFreeze({
+        coordinate: 'method',
+        owner: keyForDefinitionRef(method.owner),
+        name: method.name,
+        ...callableSignature(method.declaration),
+    });
+}
+export function methodInheritance(method) {
+    return deepFreeze({
+        coordinate: 'method',
+        owner: keyForDefinitionRef(method.owner),
+        name: method.name,
+        abstract: method.declaration.abstract,
+        ...inheritedSignature(method.declaration),
+    });
+}
+export function functionSignature(declaration) {
+    return deepFreeze({
+        coordinate: 'function',
+        ...callableSignature(declaration),
+    });
+}
+export function functionExistence() {
+    return Object.freeze({ coordinate: 'function' });
+}
+/**
+ * Fingerprint the contract a caller compiles against, independently of its Domain revision: the
+ * exact key, the owner, dispatch and abstractness of a Method, the semantic input and output
+ * contracts, and the durable execution modifier; authorization is excluded
+ * (DM-CALLABLE-FINGERPRINT). A static consumer pins this instead of a Domain revision, so a
+ * dependency release that leaves the callable contract untouched keeps every bound invocation
+ * valid.
+ */
+export function callableFingerprint(callable) {
+    // This digest input travels in every bound invocation and is recomputed by the Kernel; its
+    // shape is frozen, `kind` included, so a Kernel upgrade never invalidates an unchanged pin.
+    return fingerprintMeaning('owner' in callable
+        ? {
+            kind: 'method',
+            key: callable.key,
+            owner: callable.owner.key,
+            ...callableSignature(callable),
+        }
+        : { kind: 'function', key: callable.key, ...callableSignature(callable) });
+}
+/**
+ * The `always` fields of CALLABLE_FIELDS: dispatch shape, the execution modifier, and the semantic
+ * input and output.
+ */
+export function callableSignature(declaration) {
+    return {
+        ...fieldsOf({ declaration, roles: CALLABLE_FIELDS }),
+        input: isBinaryInput(declaration.input)
+            ? {
+                mode: 'binary',
+                metadata: semanticValueSchema(declaration.input.metadata),
+                maximumBytes: declaration.input.maximumBytes,
+            }
+            : semanticValueSchema(declaration.input),
+        output: semanticOutput(declaration.output),
+    };
+}
+function semanticOutput(output) {
+    switch (output.mode) {
+        case 'value':
+            return { mode: 'value', schema: semanticValueSchema(output.schema) };
+        case 'stream':
+            return { mode: 'stream', item: semanticValueSchema(output.item) };
+        case 'binary':
+            return { mode: 'binary' };
+    }
+}

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

@@ -0,0 +1,47 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { Key as SemanticKey } from '../../../addressing/index.js';
+import type { EffectiveField } from '../../analysis/class.js';
+import type { Context } from '../context.js';
+import type { ClassCoordinate } from '../coordinate.js';
+import type { DependencyMeaningLevel } from '../fields.js';
+import type { Report } from '../report.js';
+import type { ComparisonContext, SubjectPair } from '../scope.js';
+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.
+ */
+export declare function classMeaning(context: Context, coordinate: ClassCoordinate, level: DependencyMeaningLevel, onto?: ClassRequirement): {
+    readonly meaning: JsonValue;
+    readonly requirement: ClassRequirement;
+} | undefined;
+/**
+ * What a Policy pattern reads of an Edge it matches: its orientation and the Classes each endpoint
+ * accepts, without cardinalities or roles. Undirected endpoints form an unordered pair.
+ */
+export declare function edgeEndpoints(context: Context, coordinate: ClassCoordinate): JsonValue | undefined;
+export declare function propertyMeaning(field: EffectiveField): JsonValue;
+/**
+ * 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
+ * Class stops extending that owner, and is not compared at all when another origin owns it: only the
+ * Class's own identity set shows those losses. Every loss is recorded, a Property its owner removed
+ * included, and only a loss is: a comparison that keeps every identity keeps its facts and evidence
+ * bytes, and an added ancestor or Property obliges nothing. The target is projected onto the source
+ * identities, as inherited ancestry is, so the differences name the lost Properties.
+ */
+export declare function compareLostProperties({ pair, report, }: {
+    readonly pair: SubjectPair;
+    readonly report: Report;
+}): void;
+/** 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;
+    readonly pair: SubjectPair;
+    readonly report: Report;
+}): void;
+export {};

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

@@ -0,0 +1,160 @@
+import { compareUnicode } from '../../../addressing/ordering.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';
+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.
+ */
+export function classMeaning(context, coordinate, level, onto) {
+    const owner = context.schemas.get(coordinate.ref.origin);
+    const declaration = owner?.classes[coordinate.ref.name];
+    const analysis = owner === undefined ? undefined : effectiveDefinition(context, owner, coordinate.ref);
+    if (owner === undefined || declaration === undefined || analysis === undefined)
+        return undefined;
+    const ancestors = ancestorKeys(context, coordinate.ref);
+    const requirement = Object.freeze({
+        ancestors,
+    });
+    const meaning = {
+        coordinate: 'class',
+        level: level,
+        ...fieldsOf({ declaration, roles: CLASS_FIELDS, level }),
+        ...(level === 'inherit'
+            ? {
+                extends: onto === undefined
+                    ? ancestors
+                    : onto.ancestors.filter((ancestor) => ancestors.includes(ancestor)),
+                policies: Object.fromEntries(Object.entries(declaration.policies)
+                    .filter(([, policy]) => policy !== undefined)
+                    .map(([role, policy]) => [role, classPolicyMeaning(policy)])),
+                ...(declaration.kind === 'node'
+                    ? {
+                        data: analysis.data === undefined
+                            ? null
+                            : {
+                                owner: keyForDefinitionRef(analysis.data.owner),
+                                declaration: analysis.data.declaration,
+                            },
+                    }
+                    : { endpoints: declaration.endpoints, constraints: declaration.constraints }),
+            }
+            : {}),
+    };
+    return { meaning: deepFreeze(meaning), requirement };
+}
+/**
+ * A named Policy compares by its key; `false` or Policy checks by their value, as a callable's
+ * Policy does.
+ */
+function classPolicyMeaning(policy) {
+    if (policy === false)
+        return false;
+    return isClassRuleChecks(policy) ? policy : keyForDefinitionRef(policy);
+}
+/**
+ * What a Policy pattern reads of an Edge it matches: its orientation and the Classes each endpoint
+ * accepts, without cardinalities or roles. Undirected endpoints form an unordered pair.
+ */
+export function edgeEndpoints(context, coordinate) {
+    const declaration = context.schemas.get(coordinate.ref.origin)?.classes[coordinate.ref.name];
+    if (declaration?.kind !== 'edge')
+        return undefined;
+    const accepts = ({ accepts: refs }) => refs.map(keyForDefinitionRef).sort(compareUnicode);
+    return deepFreeze(declaration.orientation === 'directed'
+        ? {
+            coordinate: 'class',
+            orientation: 'directed',
+            source: accepts(declaration.endpoints.source),
+            target: accepts(declaration.endpoints.target),
+        }
+        : {
+            coordinate: 'class',
+            orientation: 'undirected',
+            endpoints: declaration.endpoints
+                .map(accepts)
+                .sort((left, right) => compareUnicode(left.join('\n'), right.join('\n'))),
+        });
+}
+export function propertyMeaning(field) {
+    return deepFreeze({
+        coordinate: 'property',
+        owner: keyForDefinitionRef(field.owner),
+        name: field.name,
+        ...fieldsOf({ declaration: field, roles: PROPERTY_FIELDS }),
+        schema: semanticValueSchema(field.schema),
+    });
+}
+function ancestorKeys(context, ref) {
+    const seen = new Set();
+    const visit = (current) => {
+        const declaration = context.schemas.get(current.origin)?.classes[current.name];
+        if (declaration === undefined)
+            return;
+        for (const parent of declaration.extends) {
+            const key = keyForDefinitionRef(parent);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            visit(parent);
+        }
+    };
+    visit(ref);
+    return [...seen].sort(compareUnicode);
+}
+/**
+ * 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
+ * Class stops extending that owner, and is not compared at all when another origin owns it: only the
+ * Class's own identity set shows those losses. Every loss is recorded, a Property its owner removed
+ * included, and only a loss is: a comparison that keeps every identity keeps its facts and evidence
+ * bytes, and an added ancestor or Property obliges nothing. The target is projected onto the source
+ * identities, as inherited ancestry is, so the differences name the lost Properties.
+ */
+export function compareLostProperties({ pair, report, }) {
+    if (pair.source?.kind !== 'class' || pair.target?.kind !== 'class')
+        return;
+    const kept = pair.target.analysis.properties;
+    const identities = [...pair.source.analysis.properties.keys()].sort(compareUnicode);
+    if (identities.every((identity) => kept.has(identity)))
+        return;
+    report.record({
+        pair,
+        facet: 'class.properties',
+        before: propertyIdentities(identities),
+        after: propertyIdentities(identities.filter((identity) => kept.has(identity))),
+        requirement: { kind: 'class.properties' },
+    });
+}
+function propertyIdentities(identities) {
+    return deepFreeze({
+        coordinate: 'class',
+        properties: Object.fromEntries(identities.map((identity) => [identity, true])),
+    });
+}
+/** 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')
+        return;
+    for (const field of pair.target.analysis.properties.values()) {
+        if (pair.source.analysis.properties.has(field.identity) ||
+            !field.required ||
+            field.auto !== undefined)
+            continue;
+        const coordinate = propertyCoordinate(field.owner, field.name);
+        report.note({ coordinate, usage: usageOf(pair.source.schema, 'member', pair.coordinate.key) });
+        report.record({
+            pair: context.pair(coordinate),
+            facet: 'property.required',
+            after: propertyMeaning(field),
+            requirement: { kind: 'property.required', satisfied: false },
+        });
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type { Facet } from '../model.js';
+import type { ComparisonContext, SubjectPair } from '../scope.js';
+/** Shared facet comparisons know declarations, never installation or an analysis mode. */
+export declare function compareFacet({ context, pair, facet, }: {
+    readonly context: ComparisonContext;
+    readonly pair: SubjectPair;
+    readonly facet: Exclude<Facet, 'class.composition' | 'class.properties' | 'property.required'>;
+}): {
+    readonly before?: Value;
+    readonly after?: Value;
+};

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

@@ -0,0 +1,53 @@
+import { methodInheritance, functionSignature, functionExistence, methodObject, methodSignature, methodExistence, } from './callables.js';
+import { classMeaning, edgeEndpoints, propertyMeaning } from './classes.js';
+import { memberMeaning } from './members.js';
+/** Shared facet comparisons know declarations, never installation or an analysis mode. */
+export function compareFacet({ context, pair, facet, }) {
+    if (facet === 'class.reference' || facet === 'class.inherit') {
+        if (pair.coordinate.kind !== 'class')
+            throw new TypeError('Class facet requires a Class coordinate.');
+        const level = facet === 'class.inherit' ? 'inherit' : 'reference';
+        const before = classMeaning(context.before, pair.coordinate, level);
+        const after = classMeaning(context.after, pair.coordinate, level, before?.requirement);
+        return { before: before?.meaning, after: after?.meaning };
+    }
+    if (facet === 'class.endpoints') {
+        if (pair.coordinate.kind !== 'class')
+            throw new TypeError('Class facet requires a Class coordinate.');
+        return {
+            before: edgeEndpoints(context.before, pair.coordinate),
+            after: edgeEndpoints(context.after, pair.coordinate),
+        };
+    }
+    const value = (subject) => {
+        if (subject === undefined)
+            return undefined;
+        switch (facet) {
+            case 'property':
+                return subject.kind === 'property' ? propertyMeaning(subject.field) : undefined;
+            case 'method.existence':
+                return subject.kind === 'method' ? methodExistence(subject.method) : undefined;
+            case 'method.object':
+                return subject.kind === 'method'
+                    ? methodObject(subject.method, subject.schema.classes[subject.method.owner.name])
+                    : undefined;
+            case 'method.signature':
+                return subject.kind === 'method' ? methodSignature(subject.method) : undefined;
+            case 'method.inheritance':
+                return subject.kind === 'method' ? methodInheritance(subject.method) : undefined;
+            case 'function.existence':
+                return functionExistence();
+            case 'function.signature':
+                return subject.kind === 'member'
+                    ? functionSignature(subject.schema.functions[subject.coordinate.ref.name])
+                    : undefined;
+            case 'policy':
+            case 'view':
+            case 'core':
+                return subject.kind === 'member'
+                    ? memberMeaning(subject.schema, subject.coordinate.ref)
+                    : undefined;
+        }
+    };
+    return { before: value(pair.source), after: value(pair.target) };
+}

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

@@ -0,0 +1,4 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { DomainSchema } from '../../model/schema.js';
+import type { MemberRef } from '../coordinate.js';
+export declare function memberMeaning(owner: DomainSchema, ref: MemberRef): JsonValue | undefined;

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

@@ -0,0 +1,49 @@
+import { deepFreeze } from '../../canonical/freeze.js';
+import { CORE_FIELDS, POLICY_FIELDS, VIEW_FIELDS, fieldsOf } from '../fields.js';
+import { functionSignature } from './callables.js';
+export function memberMeaning(owner, ref) {
+    const meaning = memberMeaningOf(owner, ref);
+    return meaning === undefined ? undefined : deepFreeze(meaning);
+}
+function memberMeaningOf(owner, ref) {
+    if (ref.origin !== owner.origin)
+        return undefined;
+    switch (ref.kind) {
+        case 'function': {
+            const declaration = owner.functions[ref.name];
+            return declaration === undefined ? undefined : functionSignature(declaration);
+        }
+        case 'policy': {
+            const declaration = owner.policies[ref.name];
+            return declaration === undefined
+                ? undefined
+                : {
+                    coordinate: 'policy',
+                    ...fieldsOf({ declaration, roles: POLICY_FIELDS }),
+                };
+        }
+        case 'view': {
+            const declaration = owner.views[ref.name];
+            return declaration === undefined
+                ? undefined
+                : {
+                    coordinate: 'view',
+                    ...fieldsOf({ declaration, roles: VIEW_FIELDS }),
+                };
+        }
+        case 'core': {
+            const node = owner.core.nodes[ref.name];
+            return node === undefined
+                ? undefined
+                : {
+                    coordinate: 'core',
+                    ...fieldsOf({ declaration: node, roles: CORE_FIELDS }),
+                    edges: incidentCoreEdges(owner, ref.name).map((edge) => fieldsOf({ declaration: edge, roles: CORE_FIELDS })),
+                };
+        }
+    }
+}
+function incidentCoreEdges(owner, name) {
+    return owner.core.edges.filter((edge) => (edge.source.kind === 'core' && edge.source.name === name) ||
+        (edge.target.kind === 'core' && edge.target.name === name));
+}

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

@@ -0,0 +1,5 @@
+import type { JsonSchema } from '../../../language/value/model/schema.js';
+import type { Fingerprint } from '../model.js';
+/** Drop annotation keywords wherever a schema keyword nests a schema; never inside data. */
+export declare function semanticValueSchema(value: JsonSchema): JsonSchema;
+export declare function fingerprintMeaning(value: unknown): Fingerprint;