@astrale-os/kernel-client 0.6.0-beta.77 → 0.6.0-beta.79

package/dist/session/content.d.ts

@@ -3,8 +3,6 @@ import type { Ref } from '@astrale-os/kernel-protocol/artifact';
 import { Path } from '@astrale-os/kernel-core/path';
 import type { Binary, Input, Result } from '../client/index.js';
 import type { SessionControlOptions, SessionOperation } from './context/index.js';
-import type { CallableReference } from './reference.js';
-import type { SessionRequestOptionsWithBody } from './routing/index.js';
 export interface ContentLocation {
     readonly node: string;
     readonly property: string;
@@ -23,7 +21,6 @@ export interface ContentApi {
 }
 export interface ContentSessionDependencies {
     readonly operation: (options: SessionControlOptions) => SessionOperation;
-    readonly invoke: (reference: CallableReference<unknown, unknown, 'binary'>, input: unknown, options: SessionRequestOptionsWithBody, operation: SessionOperation) => Promise<unknown>;
     readonly dispatch: (target: Path, input: Input, operation: SessionOperation, body?: Blob) => Promise<Result>;
 }
 /** Transfer immutable content over the authenticated Session routing conversation. */

package/dist/session/content.js

@@ -1,14 +1,13 @@
 import { NodeId } from '@astrale-os/kernel-core/graph/node';
 import { Path } from '@astrale-os/kernel-core/path';
-import { download, meaning, upload, } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+import { download, upload } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
 import { PropertyKey } from '@astrale-os/kernel-dsl/v1/addressing';
 import * as artifact from '@astrale-os/kernel-protocol/artifact';
 import { CODES } from '@astrale-os/kernel-protocol/errors';
 import { ClientError, ProtocolError, ResponseError, TransportError } from '../errors/index.js';
 import { admitControlOptions, runSessionOperation } from './context/index.js';
-import { kernelReference } from './reference.js';
 import { requireResultKind } from './routing/index.js';
-const UPLOAD = kernelReference(upload, meaning.upload);
+const UPLOAD = Path.project(upload);
 const DOWNLOAD = Path.project(download);
 const CONTENT_TIMEOUT_MS = 30 * 60 * 1_000;
 const MAXIMUM_ATTEMPTS = 3;
@@ -21,8 +20,8 @@ export function createContentApi(dependencies) {
         let last;
         for (let attempt = 0; attempt < MAXIMUM_ATTEMPTS; attempt++) {
             try {
-                const result = await dependencies.invoke(UPLOAD, { mediaType }, { body }, operation);
-                return uploadResult(result);
+                const result = await dependencies.dispatch(UPLOAD, { mediaType }, operation, body);
+                return uploadResult(requireResultKind('value', result).value);
             }
             catch (cause) {
                 last = cause;

package/dist/session/execution.js

@@ -1,13 +1,13 @@
 import { Path } from '@astrale-os/kernel-core/path';
-import { execution as methods, meaning, } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+import { execution as methods } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
 import { kernelReference } from './reference.js';
 const bound = {
-    status: kernelReference(methods.status, meaning.execution.status),
-    result: kernelReference(methods.result, meaning.execution.result),
-    cancel: kernelReference(methods.cancel, meaning.execution.cancel),
-    signal: kernelReference(methods.signal, meaning.execution.signal),
-    resume: kernelReference(methods.resume, meaning.execution.resume),
-    delete: kernelReference(methods.delete, meaning.execution.delete),
+    status: kernelReference(methods.status),
+    result: kernelReference(methods.result),
+    cancel: kernelReference(methods.cancel),
+    signal: kernelReference(methods.signal),
+    resume: kernelReference(methods.resume),
+    delete: kernelReference(methods.delete),
 };
 function receiver(execution) {
     return Path.id(typeof execution === 'string' ? execution : execution.id);

package/dist/session/reference.d.ts

@@ -1,5 +1,4 @@
 import type { Path as PathValue, PathLike } from '@astrale-os/kernel-core/path';
-import type { FunctionRef } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
 import type { CallableInputOf, CallableInputModeOf, CallableOutputOf, CallableResultOf, Domain, ResolvedFunction, ExecutableMethod } from '@astrale-os/kernel-dsl/v1';
 import type { MethodAddress, Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import type { MeaningFingerprint } from '@astrale-os/kernel-dsl/v1/schema/fingerprint';
@@ -12,7 +11,7 @@ declare const REFERENCE_OUTPUT: unique symbol;
 export interface CallableReference<InputValue = Input, Output = unknown, InputMode extends 'value' | 'binary' = 'value' | 'binary'> {
     readonly origin: KeyType.Origin;
     /** @deprecated Informational only; dispatch pins `fingerprint` and revision pinning will be removed. */
-    readonly revision: Revision;
+    readonly revision?: Revision;
     /** Meaning fingerprint of the callable; a generated reference always carries one. */
     readonly fingerprint?: MeaningFingerprint;
     readonly callable: KeyType.Callable;
@@ -25,8 +24,8 @@ export interface CallableReference<InputValue = Input, Output = unknown, InputMo
 export interface InstanceCallableReference<InputValue = Input, Output = unknown> {
     (receiver: PathLike): CallableReference<InputValue, Output>;
     readonly origin: KeyType.Origin;
-    readonly revision: Revision;
-    readonly fingerprint: MeaningFingerprint;
+    readonly revision?: Revision;
+    readonly fingerprint?: MeaningFingerprint;
     readonly callable: KeyType.Callable;
     readonly outputMode: 'value' | 'stream' | 'binary';
 }
@@ -47,12 +46,10 @@ export declare function reference<const Callable extends ResolvedFunction | Exec
 /** Project one exact resolved instance Method into a receiver-bound typed Client reference. */
 export declare function reference<const Callable extends ExecutableInstanceMethod>(domain: Pick<Domain, 'origin' | 'revision'>, callable: Callable): InstanceCallableReference<ReferenceInput<Callable>, ReferenceOutput<Callable>>;
 /**
- * Reference a Kernel callable from its Core coordinate and precomputed meaning, so runtime code never
- * loads the Kernel Schema. Core keeps each meaning equal to the resolved Kernel; every Kernel
- * callable referenced this way answers a value.
+ * Reference a Kernel instance Method by its Core coordinate, without a meaning pin, as the Session
+ * addresses every Kernel syscall. Loading the Session therefore never resolves the Kernel Schema.
  */
-export declare function kernelReference(callable: FunctionRef<'kernel.astrale.ai'>, fingerprint: MeaningFingerprint): CallableReference<unknown>;
-export declare function kernelReference(callable: MethodAddress, fingerprint: MeaningFingerprint): InstanceCallableReference<unknown>;
+export declare function kernelReference(method: MethodAddress): InstanceCallableReference<unknown>;
 export declare function admitReference(input: CallableReference<unknown>): CallableReference<unknown>;
 export declare function matchesCallable(target: PathValue, callable: KeyType.Callable): boolean;
 export {};

package/dist/session/reference.js

@@ -1,5 +1,4 @@
 import { Path } from '@astrale-os/kernel-core/path';
-import { meaning } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
 import { callableAddress, Key, MethodKey, patterns, } from '@astrale-os/kernel-dsl/v1/addressing';
 import { callableFingerprint } from '@astrale-os/kernel-dsl/v1/schema/fingerprint';
 const FINGERPRINT_PATTERN = /^sha256:[0-9a-f]{64}$/u;
@@ -27,19 +26,18 @@ export function reference(domain, callable) {
         : Path.project(callable.ref);
     return admitReference({ ...common, target });
 }
-export function kernelReference(callable, fingerprint) {
-    const key = callable.kind === 'method' ? MethodKey.of(callable.owner, callable.name) : Key.of(callable);
+/**
+ * Reference a Kernel instance Method by its Core coordinate, without a meaning pin, as the Session
+ * addresses every Kernel syscall. Loading the Session therefore never resolves the Kernel Schema.
+ */
+export function kernelReference(method) {
+    const callable = MethodKey.of(method.owner, method.name);
     const common = Object.freeze({
-        origin: Key.origin(key),
-        revision: meaning.revision,
-        fingerprint,
-        callable: key,
+        origin: Key.origin(callable),
+        callable,
         outputMode: 'value',
     });
-    if (callable.kind === 'function')
-        return admitReference({ ...common, target: Path.project(callable) });
-    const method = key;
-    const bind = (receiver) => admitReference({ ...common, target: Path.instanceMethod(Path.from(receiver), method) });
+    const bind = (receiver) => admitReference({ ...common, target: Path.instanceMethod(Path.from(receiver), callable) });
     return Object.assign(bind, common);
 }
 export function admitReference(input) {
@@ -47,8 +45,8 @@ export function admitReference(input) {
         invalid();
     if (typeof input.origin !== 'string' ||
         !patterns.origin.test(input.origin) ||
-        typeof input.revision !== 'string' ||
-        !patterns.revision.test(input.revision) ||
+        (input.revision !== undefined &&
+            (typeof input.revision !== 'string' || !patterns.revision.test(input.revision))) ||
         typeof input.callable !== 'string' ||
         !Key.is(input.callable) ||
         Key.origin(input.callable) !== input.origin ||
@@ -61,7 +59,7 @@ export function admitReference(input) {
         invalid();
     return Object.freeze({
         origin: input.origin,
-        revision: input.revision,
+        ...(input.revision === undefined ? {} : { revision: input.revision }),
         ...(input.fingerprint === undefined ? {} : { fingerprint: input.fingerprint }),
         callable: input.callable,
         target,

package/dist/session/session.d.ts

@@ -84,7 +84,6 @@ export declare class ClientSession {
     invoke<const Reference extends CallableReference<unknown>>(reference: InputModeOfReference<Reference> extends 'binary' ? never : Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
     invoke<const Reference extends CallableReference<unknown, unknown, 'binary'>>(reference: Reference, input: InputOfReference<Reference>, options: SessionRequestOptionsWithBody): Promise<OutputOfReference<Reference>>;
     private dispatchWith;
-    private invokeWith;
     stream(call: Call, options?: SessionRequestOptions): Promise<import("../client/result.js").Stream>;
     binary(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-core/callable").BinaryOutput>;
     close(): void;

package/dist/session/session.js

@@ -126,7 +126,6 @@ export class ClientSession {
         });
         this.content = createContentApi({
             operation: (options) => this.operation(options),
-            invoke: (reference, input, options, operation) => this.invokeWith(reference, input, options, operation),
             dispatch: (target, input, operation, body) => this.dispatcher.dispatchHttp({ target, input }, {}, operation, body),
         });
         this.schema = createSchema((request, options) => this.dispatch(request, options), {
@@ -172,16 +171,6 @@ export class ClientSession {
         return requireResultKind('value', result).value;
     }
     async invoke(reference, input, options) {
-        return this.invokeWith(reference, input, options);
-    }
-    dispatchWith(call, options, requireHttp = false) {
-        const admitted = admitInvocationOptions(options);
-        const operation = this.operation(admitted.options);
-        return admitted.body === undefined && !requireHttp
-            ? this.dispatcher.dispatch(call, admitted.options, operation)
-            : this.dispatcher.dispatchHttp(call, admitted.options, operation, admitted.body);
-    }
-    async invokeWith(reference, input, options, sharedOperation) {
         const admittedReference = admitReference(reference);
         const admitted = admitInvocationOptions(options);
         const { anchor, steps } = admittedReference.target.ast;
@@ -189,18 +178,21 @@ 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.
+        // A generated reference pins the callable meaning, a hand-written one its revision, and a Kernel
+        // reference nothing, like every other syscall the Session addresses.
         const call = {
             target: Object.freeze({
                 callable: admittedReference.callable,
-                ...(admittedReference.fingerprint === undefined
-                    ? { revision: admittedReference.revision }
-                    : { fingerprint: admittedReference.fingerprint }),
+                ...(admittedReference.fingerprint !== undefined
+                    ? { fingerprint: admittedReference.fingerprint }
+                    : admittedReference.revision !== undefined
+                        ? { revision: admittedReference.revision }
+                        : {}),
                 ...(instance === undefined ? {} : { instance }),
             }),
             input,
         };
-        const operation = sharedOperation ?? this.operation(admitted.options);
+        const operation = this.operation(admitted.options);
         const result = await (admitted.body === undefined && admittedReference.outputMode !== 'binary'
             ? this.dispatcher.dispatch(call, admitted.options, operation)
             : this.dispatcher.dispatchHttp(call, admitted.options, operation, admitted.body));
@@ -211,6 +203,13 @@ export class ClientSession {
                 ? narrowed.stream
                 : narrowed.value;
     }
+    dispatchWith(call, options, requireHttp = false) {
+        const admitted = admitInvocationOptions(options);
+        const operation = this.operation(admitted.options);
+        return admitted.body === undefined && !requireHttp
+            ? this.dispatcher.dispatch(call, admitted.options, operation)
+            : this.dispatcher.dispatchHttp(call, admitted.options, operation, admitted.body);
+    }
     async stream(call, options) {
         const result = await this.dispatch(call, options);
         return requireResultKind('stream', result).stream;

package/dist/transport/http/byte-stream.js

@@ -64,7 +64,7 @@ export class HttpByteStream {
             }
             this.bytes += next.value.byteLength;
             if (this.expectedBytes !== undefined && this.bytes > this.expectedBytes) {
-                throw new ProtocolError(`streaming binary exceeded declared Content-Length (${this.expectedBytes}).`);
+                throw new ProtocolError(`streaming binary exceeded its declared length (${this.expectedBytes}).`);
             }
             if (this.bytes > this.maximumBytes) {
                 throw new ProtocolError(`streaming binary exceeds maximumResponseBytes (${this.maximumBytes}).`);

package/dist/transport/http/transport.js

@@ -197,11 +197,14 @@ export class HttpTransport {
         if (streaming) {
             if (response.body === null)
                 throw new ProtocolError('streaming binary has no body.');
-            const length = response.headers.get('content-length');
+            // An intermediary may rewrite Content-Length (for example when it compresses the body), so the
+            // protocol length wins; Content-Length only counts for a Server that predates the field.
+            const declared = response.headers.get(protocol.http.BINARY_LENGTH_FIELD);
+            const length = declared ?? response.headers.get('content-length');
             const expectedBytes = length === null ? undefined : Number(length);
             if (length !== null &&
                 (!/^(?:0|[1-9][0-9]*)$/u.test(length) || !Number.isSafeInteger(expectedBytes))) {
-                throw new ProtocolError('streaming binary has an invalid Content-Length.');
+                throw new ProtocolError(`streaming binary has an invalid ${declared === null ? 'Content-Length' : protocol.http.BINARY_LENGTH_FIELD}.`);
             }
             if (expectedBytes !== undefined && expectedBytes > this.maximumResponseBytes) {
                 throw new ProtocolError(`streaming binary exceeds maximumResponseBytes (${this.maximumResponseBytes}).`);

package/package.json

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