@astrale-os/kernel-client 0.6.0-beta.64 → 0.6.0-beta.65

package/dist/schema/index.d.ts

@@ -1,3 +1,3 @@
-export { createSchema, DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS, type SchemaApi, type SchemaCall, type SchemaOptions, type DomainBundle, type DomainInfo, type InstallResult, } from './schema.js';
+export { createSchema, DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS, type SchemaApi, type SchemaCall, type SchemaOptions, type DomainBundle, type DomainDependencies, type DomainInfo, type InstallResult, } from './schema.js';
 export { acceptOperationId, createOperationId } from './operation.js';
 export type { DomainRequest, InstallReceipt, InstallRequest, OperationId, UninstallReceipt, UninstallRequest, } from './contracts.js';

package/dist/schema/schema.d.ts

@@ -9,12 +9,14 @@ export interface SchemaOptions extends protocolSchema.installation.introspection
 }
 export type DomainInfo = protocolSchema.installation.introspection.DomainInfo;
 export type DomainBundle = protocolSchema.installation.introspection.DomainBundle;
+export type DomainDependencies = protocolSchema.installation.introspection.DomainDependencies;
 export type InstallResult = protocolSchema.installation.InstallResult;
 export interface SchemaApi {
     install(request: InstallRequest, options?: RequestOptions): Promise<InstallResult>;
     uninstall(request: UninstallRequest, options?: RequestOptions): Promise<UninstallReceipt>;
     inspect(origin: Key.Origin, options?: RequestOptions): Promise<DomainInfo>;
     bundle(origin: Key.Origin, options?: RequestOptions): Promise<DomainBundle>;
+    dependencies(origin: Key.Origin, options?: RequestOptions): Promise<DomainDependencies>;
 }
 export declare const DEFAULT_SCHEMA_LIFECYCLE_TIMEOUT_MS = 110000;
 /** Bind the canonical Schema lifecycle syscalls to one caller-scoped value-call capability. */

package/dist/schema/schema.js

@@ -43,6 +43,9 @@ export function createSchema(call, limits) {
         async bundle(origin, options) {
             return introspect(call, admittedLimits, { kind: 'bundle', origin }, options);
         },
+        async dependencies(origin, options) {
+            return introspect(call, admittedLimits, { kind: 'dependencies', origin }, options);
+        },
     });
 }
 function snapshotUninstallRequest(request) {

package/dist/session/bound.js

@@ -23,7 +23,8 @@ export function bindSession(source, controls) {
     const uninstall = (request, options) => schemaSource.uninstall(request, controlOptions(options, admittedControls));
     const inspect = (origin, options) => schemaSource.inspect(origin, controlOptions(options, admittedControls));
     const bundle = (origin, options) => schemaSource.bundle(origin, controlOptions(options, admittedControls));
-    const schema = Object.freeze({ install, uninstall, inspect, bundle });
+    const dependencies = (origin, options) => schemaSource.dependencies(origin, controlOptions(options, admittedControls));
+    const schema = Object.freeze({ install, uninstall, inspect, bundle, dependencies });
     const graph = createGraph(call);
     const auth = createAuth((target, input, options) => call(createCall(target, input), options));
     return Object.freeze({
@@ -82,6 +83,7 @@ function captureSchema(input) {
         uninstall: capture(input, 'uninstall'),
         inspect: capture(input, 'inspect'),
         bundle: capture(input, 'bundle'),
+        dependencies: capture(input, 'dependencies'),
     });
 }
 function invalid() {

package/dist/session/reference.d.ts

@@ -1,13 +1,17 @@
 import type { Path as PathValue, PathLike } from '@astrale-os/kernel-core/path';
 import type { CallableInputOf, CallableOutputOf, CallableResultOf, Domain, ResolvedFunction, ExecutableMethod } from '@astrale-os/kernel-dsl/v1';
 import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
+import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
 import { type Key as KeyType } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { Binary, Input } from '../client/index.js';
 declare const REFERENCE_INPUT: unique symbol;
 declare const REFERENCE_OUTPUT: unique symbol;
 export interface CallableReference<InputValue = Input, Output = unknown> {
     readonly origin: KeyType.Origin;
+    /** @deprecated Informational only; dispatch pins `fingerprint` and revision pinning will be removed. */
     readonly revision: Revision;
+    /** Meaning fingerprint of the callable; a generated reference always carries one. */
+    readonly fingerprint?: dslSchema.MeaningFingerprint;
     readonly callable: KeyType.Callable;
     readonly target: PathValue;
     readonly outputMode: 'value' | 'stream' | 'binary';
@@ -18,6 +22,7 @@ export interface InstanceCallableReference<InputValue = Input, Output = unknown>
     (receiver: PathLike): CallableReference<InputValue, Output>;
     readonly origin: KeyType.Origin;
     readonly revision: Revision;
+    readonly fingerprint: dslSchema.MeaningFingerprint;
     readonly callable: KeyType.Callable;
     readonly outputMode: 'value' | 'stream' | 'binary';
 }

package/dist/session/reference.js

@@ -1,5 +1,7 @@
 import { Path } from '@astrale-os/kernel-core/path';
+import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
 import { callableAddress, Key, patterns, } from '@astrale-os/kernel-dsl/v1/addressing';
+const FINGERPRINT_PATTERN = /^sha256:[0-9a-f]{64}$/u;
 export function reference(domain, callable) {
     if (Key.origin(callable.key) !== domain.origin)
         invalid();
@@ -8,6 +10,7 @@ export function reference(domain, callable) {
     const common = Object.freeze({
         origin: domain.origin,
         revision: domain.revision,
+        fingerprint: dslSchema.callableFingerprint(callable),
         callable: callable.key,
         outputMode: callable.output.mode,
     });
@@ -33,7 +36,9 @@ export function admitReference(input) {
         typeof input.callable !== 'string' ||
         !Key.is(input.callable) ||
         Key.origin(input.callable) !== input.origin ||
-        !['value', 'stream', 'binary'].includes(input.outputMode))
+        !['value', 'stream', 'binary'].includes(input.outputMode) ||
+        (input.fingerprint !== undefined &&
+            (typeof input.fingerprint !== 'string' || !FINGERPRINT_PATTERN.test(input.fingerprint))))
         invalid();
     const target = Path.from(input.target);
     if (!matchesCallable(target, input.callable))
@@ -41,6 +46,7 @@ export function admitReference(input) {
     return Object.freeze({
         origin: input.origin,
         revision: input.revision,
+        ...(input.fingerprint === undefined ? {} : { fingerprint: input.fingerprint }),
         callable: input.callable,
         target,
         outputMode: input.outputMode,

package/dist/session/routing/dispatch.js

@@ -122,6 +122,7 @@ function isRouteCompatibilityConflict(input) {
         ...(input.data === undefined ? {} : { data: input.data }),
     });
     return (failure?.data.code === invocationProtocol.SCHEMA_REVISION_MISMATCH ||
+        failure?.data.code === invocationProtocol.CALLABLE_FINGERPRINT_MISMATCH ||
         failure?.data.code === invocationProtocol.SERVICE_TRUST_REQUIRED);
 }
 function requireTargetPublication(route, target) {

package/dist/session/session.js

@@ -1,4 +1,5 @@
 import { Path } from '@astrale-os/kernel-core/path';
+import { schema as dslSchema } from '@astrale-os/kernel-dsl/v1';
 import { Client } from '../client/index.js';
 import { SessionError } from '../errors/index.js';
 import { createDomainBinding } from '../graph/domain/binding.js';
@@ -128,10 +129,13 @@ export class ClientSession {
         const instance = last?.kind === 'method' && last.dispatch === 'instance'
             ? Path.fromAST({ anchor, steps: steps.slice(0, -1) }).raw
             : undefined;
+        // A generated reference pins the callable meaning; a hand-written one still pins the revision.
         const result = await this.dispatcher.dispatch({
             target: Object.freeze({
                 callable: admittedReference.callable,
-                revision: admittedReference.revision,
+                ...(admittedReference.fingerprint === undefined
+                    ? { revision: admittedReference.revision }
+                    : { fingerprint: admittedReference.fingerprint }),
                 ...(instance === undefined ? {} : { instance }),
             }),
             input,
@@ -174,6 +178,7 @@ export class ClientSession {
         return this.invoke({
             origin: owner.origin,
             revision: owner.revision,
+            fingerprint: dslSchema.callableFingerprint(method),
             callable: method.key,
             target: Path.instanceMethod(Path.id(node.id), method.key),
             outputMode: method.output.mode,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-client",
-  "version": "0.6.0-beta.64",
+  "version": "0.6.0-beta.65",
   "description": "Universal Client — protocol-first, transport-agnostic",
   "keywords": [
     "astrale",
@@ -65,14 +65,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": "0.9.0-beta.49",
-    "@astrale-os/kernel-dsl": "0.2.0-beta.34",
-    "@astrale-os/kernel-protocol": "0.5.0-beta.55",
+    "@astrale-os/kernel-core": "0.9.0-beta.50",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.35",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.56",
     "@tanstack/pacer": "0.20.1",
     "msgpackr": "^2.0.5"
   },
   "devDependencies": {
-    "@astrale-os/kernel-server": "0.5.0-beta.57",
+    "@astrale-os/kernel-server": "0.5.0-beta.58",
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
     "@types/node": "^22.0.0",
     "typescript": "7.0.2",