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

package/dist/v1/language/callable/composition.d.ts

@@ -10,6 +10,18 @@ export interface MethodComposition<Method> {
     readonly frontier: ReadonlyMap<string, Method>;
     readonly methods: ReadonlyMap<string, Method>;
 }
+/** Structured failure facts; human diagnostic wording is not compatibility evidence. */
+export type MethodCompositionIssue = {
+    readonly kind: 'signature';
+    readonly local: string;
+    readonly required: string;
+} | {
+    readonly kind: 'ambiguous';
+    readonly methods: readonly [string, string];
+} | {
+    readonly kind: 'missing';
+    readonly required: string;
+};
 /** Concrete implementations never discharge a descendant's abstract obligations. */
-export declare function composeMethods<Method extends MethodMember>(parents: readonly MethodComposition<Method>[], own: ReadonlyMap<string, Method>, abstract: boolean, sameSignature: (left: Method, right: Method) => boolean, report: (message: string) => void): MethodComposition<Method>;
+export declare function composeMethods<Method extends MethodMember>(parents: readonly MethodComposition<Method>[], own: ReadonlyMap<string, Method>, abstract: boolean, sameSignature: (left: Method, right: Method) => boolean, report: (message: string, issue: MethodCompositionIssue) => void): MethodComposition<Method>;
 export {};

package/dist/v1/language/callable/composition.js

@@ -5,7 +5,11 @@ export function composeMethods(parents, own, abstract, sameSignature, report) {
     for (const required of requirements.values()) {
         const local = own.get(required.name);
         if (local !== undefined && !sameSignature(local, required)) {
-            report(`Method ${local.key} does not exactly preserve abstract signature ${required.key}.`);
+            report(`Method ${local.key} does not exactly preserve abstract signature ${required.key}.`, {
+                kind: 'signature',
+                local: local.key,
+                required: required.key,
+            });
         }
     }
     for (const local of own.values()) {
@@ -22,7 +26,10 @@ export function composeMethods(parents, own, abstract, sameSignature, report) {
     for (const inherited of frontier.values()) {
         const prior = methods.get(inherited.name);
         if (prior !== undefined && !own.has(inherited.name)) {
-            report(`Inherited Method ${inherited.name} is ambiguous: ${prior.key}, ${inherited.key}.`);
+            report(`Inherited Method ${inherited.name} is ambiguous: ${prior.key}, ${inherited.key}.`, {
+                kind: 'ambiguous',
+                methods: [prior.key, inherited.key],
+            });
         }
         methods.set(inherited.name, inherited);
     }
@@ -34,7 +41,10 @@ export function composeMethods(parents, own, abstract, sameSignature, report) {
             const local = own.get(required.name);
             if (local === undefined && !missing.has(required.name)) {
                 missing.add(required.name);
-                report(`Concrete Class requires a local Method declaration of ${required.key}.`);
+                report(`Concrete Class requires a local Method declaration of ${required.key}.`, {
+                    kind: 'missing',
+                    required: required.key,
+                });
             }
         }
     }

package/dist/v1/language/value/evaluate/evaluator.js

@@ -7,9 +7,15 @@ import { evaluation, mergeAnnotations } from './types.js';
 export function evaluateInstance(compiled, input) {
     return new InstanceEvaluator(compiled).evaluate(compiled.root, input, '');
 }
+/** Bound per-call retention independently of the size or diversity of an input value. */
+const MAX_CACHED_PATTERN_RESULTS = 256;
+const MAX_CACHED_PATTERN_INPUT_LENGTH = 128;
 class InstanceEvaluator {
     compiled;
     active = new Set();
+    searchResults = new Map();
+    fullMatchResults = new Map();
+    patternResultCount = 0;
     constructor(compiled) {
         this.compiled = compiled;
     }
@@ -79,14 +85,20 @@ class InstanceEvaluator {
         });
         const anyOf = schemaList(schema.anyOf);
         if (anyOf !== undefined) {
-            const results = anyOf.map((_, index) => this.evaluate(this.child(location, 'anyOf', index), input, instancePointer));
-            const admitted = results.filter(({ valid }) => valid);
-            if (admitted.length === 0) {
+            let admitted = 0;
+            anyOf.forEach((_, index) => {
+                const branch = this.child(location, 'anyOf', index);
+                if (contradictsRequiredConst(branch.schema, input))
+                    return;
+                const result = this.evaluate(branch, input, instancePointer);
+                if (!result.valid)
+                    return;
+                admitted += 1;
+                mergeAnnotations(properties, items, result);
+            });
+            if (admitted === 0) {
                 failures.push(invalid(instancePointer, 'anyOf', 'Value satisfies no anyOf branch.'));
             }
-            else {
-                admitted.forEach((result) => mergeAnnotations(properties, items, result));
-            }
         }
         const oneOf = schemaList(schema.oneOf);
         if (oneOf !== undefined) {
@@ -166,11 +178,11 @@ class InstanceEvaluator {
                 failures.push(invalid(instancePointer, 'minLength', 'String is below minLength.'));
             }
         }
-        if (typeof schema.pattern === 'string' && !this.compiled.matcher(schema.pattern).test(input)) {
+        if (typeof schema.pattern === 'string' && !this.matchesPattern(schema.pattern, input, false)) {
             failures.push(invalid(instancePointer, 'pattern', 'String does not match pattern.'));
         }
         if (typeof schema.fullMatch === 'string' &&
-            !this.compiled.matcher(schema.fullMatch).matches(input)) {
+            !this.matchesPattern(schema.fullMatch, input, true)) {
             failures.push(invalid(instancePointer, 'fullMatch', 'String does not match fullMatch.'));
         }
     }
@@ -289,9 +301,8 @@ class InstanceEvaluator {
         const patternMatched = new Set();
         let patternsValid = true;
         for (const pattern of Object.keys(patterns)) {
-            const matcher = this.compiled.matcher(pattern);
             for (const name of names) {
-                if (!matcher.test(name))
+                if (!this.matchesPattern(pattern, name, false))
                     continue;
                 patternMatched.add(name);
                 const result = this.evaluate(this.child(location, 'patternProperties', pattern), input[name], appendPointer(instancePointer, name));
@@ -354,6 +365,51 @@ class InstanceEvaluator {
     child(parent, keyword, member) {
         return this.compiled.child(parent, keyword, member);
     }
+    matchesPattern(source, input, whole) {
+        const cacheable = input.length <= MAX_CACHED_PATTERN_INPUT_LENGTH;
+        const cache = whole ? this.fullMatchResults : this.searchResults;
+        if (cacheable) {
+            const found = cache.get(source)?.get(input);
+            if (found !== undefined)
+                return found;
+        }
+        const matcher = this.compiled.matcher(source);
+        const result = whole ? matcher.matches(input) : matcher.test(input);
+        if (cacheable && this.patternResultCount < MAX_CACHED_PATTERN_RESULTS) {
+            let values = cache.get(source);
+            if (values === undefined) {
+                values = new Map();
+                cache.set(source, values);
+            }
+            values.set(input, result);
+            this.patternResultCount++;
+        }
+        return result;
+    }
+}
+/** A required property with a different primitive const makes the entire branch impossible. */
+function contradictsRequiredConst(schema, input) {
+    if (!isJsonObject(schema) || !isJsonObject(input) || !Array.isArray(schema.required)) {
+        return false;
+    }
+    if (!isJsonObject(schema.properties))
+        return false;
+    for (const key of schema.required) {
+        if (typeof key !== 'string' || !Object.hasOwn(input, key))
+            continue;
+        const property = schema.properties[key];
+        if (!isJsonObject(property) || !Object.hasOwn(property, 'const'))
+            continue;
+        const expected = property.const;
+        if ((expected === null ||
+            typeof expected === 'string' ||
+            typeof expected === 'number' ||
+            typeof expected === 'boolean') &&
+            input[key] !== expected) {
+            return true;
+        }
+    }
+    return false;
 }
 function schemaList(input) {
     return Array.isArray(input) ? input : undefined;

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

@@ -40,3 +40,24 @@ export interface DefinitionAnalysisResult {
     readonly diagnostics: readonly SchemaDiagnostic[];
 }
 export declare function analyzeDefinitions(environment: DomainResolutionContext): DefinitionAnalysisResult;
+/** The exact signature required by abstract Method composition. */
+export declare function sameMethodSignature(left: MethodDefinition, right: MethodDefinition): boolean;
+/** Shared canonical signature used by admission and compatibility explanations. */
+export declare function methodSignature(value: MethodDefinition): {
+    input: JsonSchema;
+    output: {
+        mode: string;
+        schema: JsonSchema;
+        item?: undefined;
+    } | {
+        schema?: undefined;
+        mode: string;
+        item: JsonSchema;
+    } | {
+        schema?: undefined;
+        item?: undefined;
+        mode: string;
+    };
+    auth: "anonymous" | "authenticated" | "authorized";
+    static: boolean;
+};

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

@@ -113,20 +113,29 @@ function mergeMethods(owner, declaration, parents, diagnostics) {
     ]));
     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. */
+export function methodSignature(value) {
+    return {
+        input: canonicalizeValueSchema(value.input, 'callable-input'),
+        output: canonicalMethodOutput(value),
+        auth: value.auth,
+        static: value.static,
+    };
 }
 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' };
     }
 }

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

@@ -0,0 +1,2 @@
+export { compare, compareMeaning, compareStructure } from './compare.js';
+export type { Analysis, Assessment, Comparison, ComparisonEntry, ComparisonEvidence, ComparisonRequest, ComparisonScope, Facet, Fingerprint, MeaningComparison, Observation, SchemaIdentity, StructureComparison, Subject, Usage, } from './model.js';

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

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

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

@@ -0,0 +1,28 @@
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type { CallableOutput, FunctionDefinition, MethodDefinition } from '../../../language/callable/model/callable.js';
+import type { ResolvedFunction, ResolvedMethod } from '../../../language/callable/resolved.js';
+import type { JsonSchema } from '../../../language/value/model/schema.js';
+import type { EffectiveMethod } from '../../analysis/class.js';
+import type { Fingerprint } from '../model.js';
+export declare function methodExistence(method: EffectiveMethod): 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, and the semantic input and output
+ * contracts; 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 input: JsonSchema;
+    readonly output: CallableOutput;
+};
+/** The `always` fields of CALLABLE_FIELDS: dispatch shape and the semantic input and output. */
+export declare function callableSignature(declaration: Pick<FunctionDefinition, 'input' | 'output'> | Pick<MethodDefinition, 'static' | 'abstract' | 'input' | 'output'>): CallableSignature;
+export {};

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

@@ -0,0 +1,77 @@
+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,
+    });
+}
+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, and the semantic input and output
+ * contracts; 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 and the semantic input and output. */
+export function callableSignature(declaration) {
+    return {
+        ...fieldsOf({ declaration, roles: CALLABLE_FIELDS }),
+        input: 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,28 @@
+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';
+export 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;
+export declare function propertyMeaning(field: EffectiveField): 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;
+    readonly pair: SubjectPair;
+    readonly report: Report;
+}): void;

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

@@ -0,0 +1,96 @@
+import { compareUnicode } from '../../../addressing/ordering.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(([, ref]) => ref !== undefined)
+                    .map(([role, ref]) => [role, keyForDefinitionRef(ref)])),
+                ...(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 };
+}
+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);
+}
+/** 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' | 'property.required'>;
+}): {
+    readonly before?: Value;
+    readonly after?: Value;
+};

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

@@ -0,0 +1,41 @@
+import { methodInheritance, functionSignature, functionExistence, methodSignature, methodExistence, } from './callables.js';
+import { classMeaning, 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 };
+    }
+    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.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;

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

@@ -0,0 +1,37 @@
+import { json } from '@astrale-os/kernel-dsl/value';
+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) {
+    if (typeof value === 'boolean')
+        return value;
+    const semantic = {};
+    for (const [keyword, entry] of Object.entries(value)) {
+        if (ANNOTATION_KEYWORDS.includes(keyword))
+            continue;
+        if (SCHEMA_SINGLE_KEYWORDS.has(keyword) && isJsonSchema(entry)) {
+            semantic[keyword] = semanticValueSchema(entry);
+        }
+        else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(entry)) {
+            semantic[keyword] = entry.map((item) => isJsonSchema(item) ? semanticValueSchema(item) : item);
+        }
+        else if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(entry)) {
+            semantic[keyword] = Object.fromEntries(Object.entries(entry).map(([name, item]) => [
+                name,
+                isJsonSchema(item) ? semanticValueSchema(item) : item,
+            ]));
+        }
+        else {
+            semantic[keyword] = entry;
+        }
+    }
+    return semantic;
+}
+export function fingerprintMeaning(value) {
+    return digestDomainSchemaBytes(json.encode(value));
+}
+function isJsonSchema(value) {
+    return typeof value === 'boolean' || isJsonObject(value);
+}