@astrale-os/kernel-dsl 0.2.0-beta.34 → 0.2.0-beta.35

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

@@ -1,5 +1,6 @@
 import type { Key as SemanticKey } from '../../addressing/index.js';
 import type { Revision } from '../../addressing/index.js';
+import type { ResolvedFunction, ResolvedMethod } from '../../language/callable/resolved.js';
 import type { DomainSchema } from '../model/schema.js';
 import { Key } from '../../addressing/index.js';
 /**
@@ -42,3 +43,11 @@ export interface DependencyMeaningComparison {
 export declare function compareDependencyMeaning(dependent: DomainSchema, target: DomainSchema): DependencyMeaningComparison;
 /** Compare one explicit non-empty source member surface and its reachable V1 meaning. */
 export declare function compareMemberMeaning(source: DomainSchema, target: DomainSchema, roots: readonly [SemanticKey, ...SemanticKey[]]): DependencyMeaningComparison;
+/**
+ * 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): MeaningFingerprint;

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

@@ -8,7 +8,7 @@ import { revisionOfDomainSchema } from '../canonical/revision.js';
 import { SchemaError, diagnostic } from '../diagnostic.js';
 import { knownDomainClosure, lookupForDomainClosure } from '../resolution/closure.js';
 import { resolve } from '../resolution/domain.js';
-import { collectCallableRefs, collectClassPolicyRefs, collectClassRefs, collectCoreRefs, collectEndpointRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, } from '../resolution/origins.js';
+import { collectCallableContractRefs, collectCallableRefs, collectClassPolicyRefs, collectClassRefs, collectCoreRefs, collectEndpointRefs, collectPolicyDefinitionRefs, collectValueDefinitionRefs, } from '../resolution/origins.js';
 import { validateDomainSchemaSemantics } from '../validation/domain.js';
 const VALUE_SCHEMA_ANNOTATIONS = new Set([
     '$comment',
@@ -59,6 +59,23 @@ export function compareMemberMeaning(source, target, roots) {
     const meanings = collectReachableMeanings(coordinates, source.origin, context);
     return compareSourceMeanings(source, target, meanings);
 }
+/**
+ * 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) {
+    return fingerprintMeaning('owner' in callable
+        ? {
+            kind: 'method',
+            key: callable.key,
+            owner: callable.owner.key,
+            ...semanticMethod(callable),
+        }
+        : { kind: 'function', key: callable.key, ...semanticFunction(callable) });
+}
 function contextOf(root) {
     const schemas = new Map([
         [root.origin, root],
@@ -230,7 +247,7 @@ function collectReachableMeanings(roots, selectedOrigin, context) {
             }
             for (const method of analysis.methods.values()) {
                 retainMeaning(meanings, selectedOrigin, methodCoordinate(method.owner, method.name), methodMeaning(method));
-                collectCallableRefs(method.declaration, push);
+                collectCallableContractRefs(method.declaration, push);
             }
             collectClassPolicyRefs(declaration, push);
         }
@@ -287,7 +304,7 @@ function collectCoordinateSemanticRefs(context, coordinate, add) {
     }
     const method = [...analysis.methods.values()].find((candidate) => MethodKey.of(candidate.owner, candidate.name) === coordinate.key);
     if (method !== undefined)
-        collectCallableRefs(method.declaration, add);
+        collectCallableContractRefs(method.declaration, add);
 }
 function collectMemberSemanticRefs(owner, ref, add) {
     switch (ref.kind) {
@@ -485,19 +502,16 @@ function methodMeaning(method) {
     };
 }
 function semanticFunction(declaration) {
-    const { description: _description, ...rest } = declaration;
     return {
-        ...rest,
         input: semanticValueSchema(declaration.input),
         output: semanticOutput(declaration.output),
     };
 }
 function semanticMethod(declaration) {
-    const { description: _description, ...rest } = declaration;
     return {
-        ...rest,
-        input: semanticValueSchema(declaration.input),
-        output: semanticOutput(declaration.output),
+        static: declaration.static,
+        abstract: declaration.abstract,
+        ...semanticFunction(declaration),
     };
 }
 function semanticOutput(output) {

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

@@ -11,7 +11,7 @@ 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 { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
+export { callableFingerprint, compareDependencyMeaning, compareMemberMeaning, } from './compatibility/meaning.js';
 export type { DependencyMeaningChange, DependencyMeaningChangeKind, DependencyMeaningComparison, DependencyMeaningLevel, MeaningFingerprint, } from './compatibility/meaning.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.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 { compareDependencyMeaning, compareMemberMeaning } from './compatibility/meaning.js';
+export { callableFingerprint, compareDependencyMeaning, compareMemberMeaning, } from './compatibility/meaning.js';
 export { header } from './codec/header.js';
 export { DOMAIN_FORMAT as FORMAT, DOMAIN_VERSION as VERSION } from './model/format.js';
 export { compile, load } from '../compiled/index.js';

package/dist/v1/schema/resolution/origins.d.ts

@@ -21,5 +21,7 @@ export declare function collectEndpointRefs(declaration: Extract<ClassDefinition
     readonly kind: 'edge';
 }>, add: ReferenceCollector): void;
 export declare function collectCallableRefs(declaration: FunctionDefinition | MethodDefinition, add: ReferenceCollector): void;
+/** References inside the contract a caller compiles against: the input and output value schemas. */
+export declare function collectCallableContractRefs(declaration: Pick<FunctionDefinition | MethodDefinition, 'input' | 'output'>, add: ReferenceCollector): void;
 export declare function collectPolicyDefinitionRefs(declaration: PolicyDefinition, add: ReferenceCollector): void;
 export declare function collectValueDefinitionRefs(schema: JsonSchema, add: ReferenceCollector): void;

package/dist/v1/schema/resolution/origins.js

@@ -66,13 +66,17 @@ export function collectEndpointRefs(declaration, add) {
     endpoints[1].accepts.forEach((ref) => add(ref, 'endpoint'));
 }
 export function collectCallableRefs(declaration, add) {
+    collectCallableContractRefs(declaration, add);
+    if (declaration.policy !== undefined)
+        collectPolicyCheckRefs(declaration.policy, add);
+}
+/** References inside the contract a caller compiles against: the input and output value schemas. */
+export function collectCallableContractRefs(declaration, add) {
     collectValueDefinitionRefs(declaration.input, add);
     if (declaration.output.mode === 'value')
         collectValueDefinitionRefs(declaration.output.schema, add);
     if (declaration.output.mode === 'stream')
         collectValueDefinitionRefs(declaration.output.item, add);
-    if (declaration.policy !== undefined)
-        collectPolicyCheckRefs(declaration.policy, add);
 }
 export function collectPolicyDefinitionRefs(declaration, add) {
     collectPolicyExpressionRefs(declaration.expression, add);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-dsl",
-  "version": "0.2.0-beta.34",
+  "version": "0.2.0-beta.35",
   "description": "Astrale Kernel DSL - Schema authoring, inference, and IR serialization",
   "license": "Apache-2.0",
   "repository": {