@astrale-os/kernel-client 0.6.0-beta.16 → 0.6.0-beta.18

package/dist/client/result.d.ts

@@ -1,10 +1,10 @@
-import type { BinaryResult, CallableResult } from '@astrale-os/kernel-core/callable';
+import type { BinaryOutput, CallableResult } from '@astrale-os/kernel-core/callable';
 import type { Value } from '@astrale-os/kernel-dsl/value';
 import type { invocation as protocol } from '@astrale-os/kernel-protocol';
 /** Caller-visible value accepted from one admitted remote invocation. */
 export type Input = Value;
-/** Caller-visible finite binary response. */
-export type Binary = BinaryResult;
+/** Caller-visible buffered or streaming binary response. */
+export type Binary = BinaryOutput;
 /** Caller-owned remote stream. */
 export interface Stream extends AsyncIterable<Value> {
     cancel(reason?: string): Promise<void>;

package/dist/client/result.js

@@ -24,5 +24,8 @@ async function rejectMismatch(expected, result) {
     if (result.kind === 'stream') {
         await result.stream.cancel(`Expected ${expected} Function result.`).catch(() => undefined);
     }
+    if (result.kind === 'binary' && !(result.value.body instanceof Uint8Array)) {
+        await result.value.body[Symbol.asyncIterator]().return?.();
+    }
     mismatch(expected, result.kind);
 }

package/dist/schema/contracts.d.ts

@@ -1,11 +1,11 @@
 import type { installation } from '@astrale-os/kernel-core/schema';
-import type { DesiredInstallation as CoreDesiredInstallation, InstallInput, InstallOutput, UninstallInput, UninstallOutput } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
+import type { DomainRequest as CoreDomainRequest, InstallInput, InstallReceipt as CoreInstallReceipt, UninstallInput, UninstallOutput } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
 export type OperationId = installation.OperationId;
 /** Canonical caller input accepted by the Kernel install syscall. */
-export type DesiredInstallation = CoreDesiredInstallation;
+export type DomainRequest = CoreDomainRequest;
 export type InstallRequest = InstallInput;
 /** Admitted terminal install receipt returned by the Kernel. */
-export type InstallReceipt = InstallOutput;
+export type InstallReceipt = CoreInstallReceipt;
 /** Canonical caller input accepted by the Kernel uninstall syscall. */
 export type UninstallRequest = UninstallInput;
 /** Admitted terminal uninstall receipt returned by the Kernel. */

package/dist/schema/index.d.ts

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

package/dist/schema/introspection.js

@@ -11,5 +11,9 @@ export async function introspect(invoke, limits, request, options) {
     if (result.value.mediaType !== schema.installation.introspection.MEDIA_TYPE) {
         throw new TypeError('Schema introspection returned an unsupported media type.');
     }
+    if (!(result.value.body instanceof Uint8Array)) {
+        await result.value.body[Symbol.asyncIterator]().return?.();
+        throw new TypeError('Schema introspection returned a streaming binary result.');
+    }
     return schema.installation.introspection.decode(request, result.value.body, limits);
 }

package/dist/schema/schema.d.ts

@@ -1,19 +1,19 @@
-import type { introspection } from '@astrale-os/kernel-core/schema';
-import type * as protocolSchema from '@astrale-os/kernel-protocol/schema';
+import type { Key } from '@astrale-os/kernel-dsl/v1';
+import * as protocolSchema from '@astrale-os/kernel-protocol/schema';
 import type { Call, Result } from '../client/index.js';
 import type { RequestOptions } from '../transport/index.js';
-import type { InstallReceipt, InstallRequest, UninstallReceipt, UninstallRequest } from './contracts.js';
+import type { InstallRequest, UninstallReceipt, UninstallRequest } from './contracts.js';
 export type SchemaCall = (call: Call, options?: RequestOptions) => Promise<Result>;
 export interface SchemaOptions extends protocolSchema.installation.introspection.Limits {
 }
-export type ReadyInstallation = protocolSchema.installation.introspection.Installation & {
-    readonly state: 'ready';
-    readonly readiness: protocolSchema.installation.introspection.Digest;
-};
+export type DomainInfo = protocolSchema.installation.introspection.DomainInfo;
+export type DomainBundle = protocolSchema.installation.introspection.DomainBundle;
+export type InstallResult = protocolSchema.installation.InstallResult;
 export interface SchemaApi {
-    install(request: InstallRequest, options?: RequestOptions): Promise<InstallReceipt>;
+    install(request: InstallRequest, options?: RequestOptions): Promise<InstallResult>;
     uninstall(request: UninstallRequest, options?: RequestOptions): Promise<UninstallReceipt>;
-    introspect<Input extends introspection.Introspection>(request: Input, options?: RequestOptions): Promise<protocolSchema.installation.introspection.ResultFor<Input>>;
+    inspect(origin: Key.Origin, options?: RequestOptions): Promise<DomainInfo>;
+    bundle(origin: Key.Origin, options?: RequestOptions): Promise<DomainBundle>;
 }
 /** Bind the canonical Schema lifecycle syscalls to one caller-scoped value-call capability. */
 export declare function createSchema(call: SchemaCall, limits: SchemaOptions): SchemaApi;

package/dist/schema/schema.js

@@ -1,9 +1,10 @@
 import { Path } from '@astrale-os/kernel-core/path';
-import { installOutput, uninstallOutput, } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
+import { uninstallOutput } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
 import { install, uninstall } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+import * as protocolSchema from '@astrale-os/kernel-protocol/schema';
 import { call as invocation } from '../client/index.js';
 import { acceptOutput } from './admission.js';
-import { introspect as inspect } from './introspection.js';
+import { introspect } from './introspection.js';
 const INSTALL_PATH = Path.project(install).raw;
 const UNINSTALL_PATH = Path.project(uninstall).raw;
 /** Bind the canonical Schema lifecycle syscalls to one caller-scoped value-call capability. */
@@ -13,18 +14,54 @@ export function createSchema(call, limits) {
     const admittedLimits = admitLimits(limits);
     return Object.freeze({
         async install(request, options) {
-            const output = value(await call(invocation(INSTALL_PATH, request), options));
-            return acceptOutput(installOutput, output);
+            const result = await call(invocation(INSTALL_PATH, request), options);
+            if (result.kind !== 'binary') {
+                throw new TypeError('Schema install returned a non-binary result.');
+            }
+            if (result.value.mediaType !== protocolSchema.installation.MEDIA_TYPE) {
+                throw new TypeError('Schema install returned an unsupported media type.');
+            }
+            if (!(result.value.body instanceof Uint8Array)) {
+                await result.value.body[Symbol.asyncIterator]().return?.();
+                throw new TypeError('Schema install returned a streaming binary result.');
+            }
+            const decoded = await protocolSchema.installation.decode(result.value.body, installationResultLimit(admittedLimits.maximumPublicationBytes, request.domains.length));
+            proveInstallResult(request, decoded);
+            return decoded;
         },
         async uninstall(request, options) {
             const output = value(await call(invocation(UNINSTALL_PATH, request), options));
             return acceptOutput(uninstallOutput, output);
         },
-        async introspect(request, options) {
-            return inspect(call, admittedLimits, request, options);
+        async inspect(origin, options) {
+            return introspect(call, admittedLimits, { kind: 'inspect', origin }, options);
+        },
+        async bundle(origin, options) {
+            return introspect(call, admittedLimits, { kind: 'bundle', origin }, options);
         },
     });
 }
+function installationResultLimit(maximumDomainBytes, roots) {
+    const perDomain = maximumDomainBytes + 4_096;
+    if (roots > Math.floor((Number.MAX_SAFE_INTEGER - 4_096) / perDomain)) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    return perDomain * roots + 4_096;
+}
+function proveInstallResult(request, result) {
+    if (result.changed) {
+        if (result.receipt.operation !== request.operation) {
+            throw new TypeError('Schema install result does not match the requested operation.');
+        }
+        if (result.receipt.transitions.length > request.domains.length) {
+            throw new TypeError('Schema install result contains more transitions than requested Domains.');
+        }
+        return;
+    }
+    if (result.domains.length !== request.domains.length) {
+        throw new TypeError('Schema unchanged result does not match the requested Domain count.');
+    }
+}
 function value(result) {
     if (result.kind !== 'value')
         throw new TypeError('Schema syscall returned a non-value result.');

package/dist/session/bound.d.ts

@@ -1,5 +1,4 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth';
-import type { ReadyInstallation } from '../schema/index.js';
 import type { SessionControlOptions } from './context/index.js';
 import type { CallableReference, InputOfReference, OutputOfReference } from './reference.js';
 import type { SessionRequestOptions } from './routing/index.js';
@@ -15,7 +14,6 @@ export interface BoundSessionSource {
     invoke<const Reference extends CallableReference>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
     stream(call: Call, options?: SessionRequestOptions): Promise<Stream>;
     binary(call: Call, options?: SessionRequestOptions): Promise<Binary>;
-    installation(origin: string, options?: SessionControlOptions): Promise<ReadyInstallation>;
     viewsFor(target: Parameters<import('./session.js').ClientSession['viewsFor']>[0], options?: SessionControlOptions): Promise<ViewCatalog>;
 }
 export interface BoundSessionControls {
@@ -37,7 +35,6 @@ export interface BoundClientSession extends GraphApi {
     invoke<const Reference extends CallableReference>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
     stream(call: Call, options?: SessionRequestOptions): Promise<Stream>;
     binary(call: Call, options?: SessionRequestOptions): Promise<Binary>;
-    installation(origin: string, options?: SessionControlOptions): Promise<ReadyInstallation>;
     viewsFor: BoundSessionSource['viewsFor'];
 }
 /** Capture one Session into the ordinary graph, auth, and invocation Kernel journey. */

package/dist/session/bound.js

@@ -11,14 +11,12 @@ export function bindSession(source, controls) {
     const invokeSource = capture(source, 'invoke');
     const streamSource = capture(source, 'stream');
     const binarySource = capture(source, 'binary');
-    const installationSource = capture(source, 'installation');
     const viewsForSource = capture(source, 'viewsFor');
     const dispatch = (input, options) => dispatchSource(input, requestOptions(options, admittedControls));
     const call = (input, options) => callSource(input, requestOptions(options, admittedControls));
     const invoke = (reference, input, options) => invokeSource(reference, input, requestOptions(options, admittedControls));
     const stream = (input, options) => streamSource(input, requestOptions(options, admittedControls));
     const binary = (input, options) => binarySource(input, requestOptions(options, admittedControls));
-    const installation = (origin, options) => installationSource(origin, controlOptions(options, admittedControls));
     const viewsFor = (target, options) => viewsForSource(target, controlOptions(options, admittedControls));
     const graph = createGraph(call);
     const auth = createAuth((target, input, options) => call(createCall(target, input), options));
@@ -31,7 +29,6 @@ export function bindSession(source, controls) {
         invoke,
         stream,
         binary,
-        installation,
         viewsFor,
     });
 }

package/dist/session/index.d.ts

@@ -1,6 +1,5 @@
 export type { SessionControlOptions, SessionPolicy } from './context/index.js';
 export { bindSession, type BoundClientSession, type BoundSessionControls, type BoundSessionSource, } from './bound.js';
-export type { ReadyInstallation } from '../schema/index.js';
 export type { SessionSnapshot } from './discovery/index.js';
 export type { Auth, SessionAuth, SessionEnvelopeTransport, SessionRequestOptions, } from './routing/index.js';
 export { ClientSession, connect, type ClientSessionOptions, type ConnectOptions, } from './session.js';

package/dist/session/reference.d.ts

@@ -2,7 +2,7 @@ import type { Path as PathValue, PathLike } from '@astrale-os/kernel-core/path';
 import type { CallableInputOf, CallableOutputOf, CallableResultOf, Domain, MethodInheritance, ResolvedFunction, ResolvedMethod } from '@astrale-os/kernel-dsl/v1';
 import type { Revision } from '@astrale-os/kernel-dsl/v1/addressing';
 import { type Key as KeyType } from '@astrale-os/kernel-dsl/v1/addressing';
-import type { Binary, Input, Result } from '../client/index.js';
+import type { Binary, Input } from '../client/index.js';
 declare const REFERENCE_INPUT: unique symbol;
 declare const REFERENCE_OUTPUT: unique symbol;
 export interface CallableReference<InputValue extends Input = Input, Output = unknown> {
@@ -10,7 +10,7 @@ export interface CallableReference<InputValue extends Input = Input, Output = un
     readonly revision: Revision;
     readonly callable: KeyType.Callable;
     readonly target: PathValue;
-    readonly outputMode: Exclude<Result['kind'], 'redirect'>;
+    readonly outputMode: 'value' | 'stream' | 'binary';
     readonly [REFERENCE_INPUT]?: InputValue;
     readonly [REFERENCE_OUTPUT]?: Output;
 }
@@ -19,7 +19,7 @@ export interface InstanceCallableReference<InputValue extends Input = Input, Out
     readonly origin: KeyType.Origin;
     readonly revision: Revision;
     readonly callable: KeyType.Callable;
-    readonly outputMode: Exclude<Result['kind'], 'redirect'>;
+    readonly outputMode: 'value' | 'stream' | 'binary';
 }
 export type InputOfReference<Reference extends CallableReference> = Reference extends CallableReference<infer InputValue, unknown> ? InputValue : never;
 export type OutputOfReference<Reference extends CallableReference> = Reference extends CallableReference<infer _Input, infer Output> ? Output : never;

package/dist/session/routing/dispatch.d.ts

@@ -1,7 +1,6 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { Call, Result } from '../../client/index.js';
 import type { SessionOperation, SessionPolicy } from '../context/index.js';
-import type { SessionDiscovery } from '../discovery/index.js';
 import type { SessionAuth } from './auth.js';
 import type { RouteCache } from './cache.js';
 import type { ClientPoolCapability } from './envelope.js';
@@ -16,7 +15,6 @@ export interface SessionDispatcherOptions {
     readonly cache: RouteCache;
     readonly policy: Readonly<SessionPolicy>;
     readonly envelopeTransport: SessionEnvelopeTransport;
-    readonly discovery: SessionDiscovery;
     readonly requireOpen: () => void;
 }
 export declare class SessionDispatcher {
@@ -27,7 +25,6 @@ export declare class SessionDispatcher {
     private followSource;
     private dispatchDestinationWithRecovery;
     private dispatchDestination;
-    private sourceKernel;
 }
 export declare function requireResultKind<Kind extends 'value' | 'stream' | 'binary'>(expected: Kind, result: Result): Extract<Result, {
     kind: Kind;

package/dist/session/routing/dispatch.js

@@ -15,8 +15,8 @@ export class SessionDispatcher {
         // Authority is resolved before warm lookup so changed credentials or delegation cannot reuse a
         // carrier minted for a different caller partition.
         const auth = await resolveAuth(this.state.auth, call, operation);
-        const source = await this.sourceKernel(operation);
-        const cacheKey = await this.state.cache.key(source.issuer, call, auth, expected);
+        const source = this.state.kernel;
+        const cacheKey = await this.state.cache.key(source, call, auth, expected);
         const dispatch = Object.freeze({
             call,
             auth,
@@ -46,7 +46,7 @@ export class SessionDispatcher {
         if (result.kind !== 'redirect')
             return result;
         const redirect = result.redirect;
-        if (redirect.route.via.issuer !== state.source.issuer) {
+        if (redirect.route.via.issuer !== state.source) {
             throw new ClientError('Redirect issuer differs from the session-pinned source Kernel identity.');
         }
         requireExpectedPublication(redirect.route, state.expected);
@@ -55,7 +55,7 @@ export class SessionDispatcher {
     }
     async dispatchDestinationWithRecovery(learned, state, options, operation, trace) {
         try {
-            return await this.dispatchDestination(learned, state.call, options, operation, state.expected, trace);
+            return await this.dispatchDestination(learned, state.call, options, operation, state.source, state.expected, trace);
         }
         catch (cause) {
             const stale = isAdmittedStaleRouteError(cause);
@@ -79,8 +79,8 @@ export class SessionDispatcher {
             return this.followSource(refreshed, state, options, operation);
         }
     }
-    async dispatchDestination(learned, call, options, operation, expected, trace) {
-        if (learned.route.via.issuer !== (await this.sourceKernel(operation)).issuer) {
+    async dispatchDestination(learned, call, options, operation, source, expected, trace) {
+        if (learned.route.via.issuer !== source) {
             throw new ClientError('Learned route issuer differs from the session-pinned source Kernel.');
         }
         requireExpectedPublication(learned.route, expected);
@@ -97,13 +97,6 @@ export class SessionDispatcher {
         }
         return result;
     }
-    async sourceKernel(operation) {
-        const snapshot = await this.state.discovery.snapshot(operation);
-        if (snapshot.kernel !== this.state.kernel) {
-            throw new ClientError('Session discovery returned another Kernel identity.');
-        }
-        return Object.freeze({ issuer: snapshot.publication.identity.issuer });
-    }
 }
 function isRouteCompatibilityConflict(input) {
     if (!(input instanceof ResponseError))
@@ -130,6 +123,9 @@ export function requireResultKind(expected, result) {
         return result;
     if (result.kind === 'stream')
         void result.stream.cancel(`Expected ${expected} result.`);
+    if (result.kind === 'binary' && !(result.value.body instanceof Uint8Array)) {
+        void result.value.body[Symbol.asyncIterator]().return?.();
+    }
     throw new ClientError(`Function returned ${result.kind}; ${expected} was required.`);
 }
 function authenticated(client, credential) {

package/dist/session/session.d.ts

@@ -1,11 +1,10 @@
 import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { PathLike } from '@astrale-os/kernel-core/path';
-import type { Key } from '@astrale-os/kernel-dsl/v1';
 import type { Domain } from '@astrale-os/kernel-dsl/v1/domain';
 import type { Call, Input, Result } from '../client/index.js';
 import type { DomainBinding, GraphApi } from '../graph/index.js';
 import type { ClientFactory, ClientPool as ClientPoolType } from '../pool/index.js';
-import type { ReadyInstallation, SchemaApi } from '../schema/index.js';
+import type { SchemaApi } from '../schema/index.js';
 import type { ClientWarning } from '../transport/auto/index.js';
 import type { Fetch } from '../transport/http/index.js';
 import type { WebSocketConstructor } from '../transport/websocket/index.js';
@@ -52,12 +51,11 @@ export declare class ClientSession {
     bind<const DomainValue extends Domain>(domain: DomainValue): DomainBinding<DomainValue>;
     snapshot(options?: SessionControlOptions): Promise<SessionSnapshot>;
     viewsFor(target: PathLike, options?: SessionControlOptions): Promise<ViewCatalog>;
-    installation(origin: Key.Origin, options?: SessionControlOptions): Promise<ReadyInstallation>;
     dispatch(call: Call, options?: SessionRequestOptions): Promise<Result>;
     call(call: Call, options?: SessionRequestOptions): Promise<Input>;
     invoke<const Reference extends CallableReference>(reference: Reference, input: InputOfReference<Reference>, options?: SessionRequestOptions): Promise<OutputOfReference<Reference>>;
     stream(call: Call, options?: SessionRequestOptions): Promise<import("../client/result.js").Stream>;
-    binary(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-core/callable").BinaryResult>;
+    binary(call: Call, options?: SessionRequestOptions): Promise<import("@astrale-os/kernel-core/callable").BinaryOutput>;
     close(): void;
     private requireOpen;
     private invokeDomainMethod;

package/dist/session/session.js

@@ -1,6 +1,6 @@
 import { Path } from '@astrale-os/kernel-core/path';
 import { Client } from '../client/index.js';
-import { ClientError, SessionError } from '../errors/index.js';
+import { SessionError } from '../errors/index.js';
 import { createDomainBinding } from '../graph/domain/binding.js';
 import { createGraph } from '../graph/index.js';
 import { ClientPool } from '../pool/index.js';
@@ -87,7 +87,6 @@ export class ClientSession {
             cache: this.routes,
             policy,
             envelopeTransport: admitEnvelopeTransport(options.envelopeTransport ?? 'http'),
-            discovery: this.discovery,
             requireOpen: () => this.requireOpen(),
         });
         this.schema = createSchema((request, options) => this.dispatch(request, options), {
@@ -107,23 +106,6 @@ export class ClientSession {
         this.requireOpen();
         return resolveViewsFor(async (call, operation) => requireResultKind('value', await this.dispatcher.dispatch(call, {}, operation)).value, this.admitTargetViews, target, this.operation(admitControlOptions(options)));
     }
-    async installation(origin, options) {
-        const result = await this.schema.introspect({
-            from: { kind: 'installation', origin },
-            select: {
-                state: true,
-                target: true,
-                source: true,
-                bundle: true,
-                readiness: true,
-                capabilities: true,
-            },
-        }, options);
-        if (result?.state !== 'ready' || result.readiness === null) {
-            throw new ClientError(`Domain ${origin} is not ready on this Kernel.`);
-        }
-        return result;
-    }
     dispatch(call, options) {
         const admitted = admitRequestOptions(options);
         return this.dispatcher.dispatch(call, admitted, this.operation(admitted));

package/dist/transport/http/byte-stream.d.ts

@@ -0,0 +1,17 @@
+import type { ControlledSignal } from '../index.js';
+/** Single-consumer HTTP byte stream preserving invocation lifetime and backpressure. */
+export declare class HttpByteStream implements AsyncIterable<Uint8Array> {
+    private readonly maximumBytes;
+    private readonly control;
+    private readonly reader;
+    private claimed;
+    private terminal;
+    private bytes;
+    private interruption;
+    constructor(body: ReadableStream<Uint8Array>, maximumBytes: number, control: ControlledSignal);
+    [Symbol.asyncIterator](): AsyncIterator<Uint8Array>;
+    cancel(reason?: unknown): Promise<void>;
+    private next;
+    private interrupt;
+    private cancelReader;
+}

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

@@ -0,0 +1,86 @@
+import { ProtocolError } from '../../errors/index.js';
+import { asError } from '../index.js';
+/** Single-consumer HTTP byte stream preserving invocation lifetime and backpressure. */
+export class HttpByteStream {
+    maximumBytes;
+    control;
+    reader;
+    claimed = false;
+    terminal = false;
+    bytes = 0;
+    interruption;
+    constructor(body, maximumBytes, control) {
+        this.maximumBytes = maximumBytes;
+        this.control = control;
+        this.reader = body.getReader();
+        const abort = () => void this.interrupt(control.signal.reason);
+        if (control.signal.aborted)
+            abort();
+        else
+            control.signal.addEventListener('abort', abort, { once: true });
+    }
+    [Symbol.asyncIterator]() {
+        if (this.claimed)
+            throw new TypeError('streaming binary admits exactly one consumer.');
+        this.claimed = true;
+        return {
+            next: () => this.next(),
+            return: async () => {
+                await this.cancel('streaming binary consumer stopped');
+                return { done: true, value: undefined };
+            },
+            throw: async (error) => {
+                await this.cancel('streaming binary consumer failed');
+                throw error;
+            },
+        };
+    }
+    async cancel(reason = 'streaming binary cancelled') {
+        if (this.terminal)
+            return;
+        this.terminal = true;
+        this.control.cancel(reason);
+        await this.cancelReader(reason);
+        this.control.close();
+    }
+    async next() {
+        if (this.interruption !== undefined)
+            throw this.interruption;
+        if (this.terminal)
+            return { done: true, value: undefined };
+        try {
+            const next = await this.reader.read();
+            if (this.interruption !== undefined)
+                throw this.interruption;
+            if (next.done) {
+                this.terminal = true;
+                this.control.close();
+                return { done: true, value: undefined };
+            }
+            this.bytes += next.value.byteLength;
+            if (this.bytes > this.maximumBytes) {
+                throw new ProtocolError(`streaming binary exceeds maximumResponseBytes (${this.maximumBytes}).`);
+            }
+            return { done: false, value: new Uint8Array(next.value) };
+        }
+        catch (error) {
+            await this.cancel(error);
+            throw error;
+        }
+    }
+    async interrupt(reason) {
+        if (this.terminal || this.interruption !== undefined)
+            return;
+        this.interruption = asError(reason ?? new Error('streaming binary was cancelled.'));
+        await this.cancelReader(this.interruption);
+        this.control.close();
+    }
+    async cancelReader(reason) {
+        try {
+            await this.reader.cancel(reason);
+        }
+        catch {
+            // Cancellation follows an already chosen terminal outcome.
+        }
+    }
+}

package/dist/transport/http/transport.js

@@ -3,6 +3,7 @@ import * as protocol from '@astrale-os/kernel-protocol/invocation';
 import { ProtocolError, ResponseError, TransportError } from '../../errors/index.js';
 import { invocationFailure } from '../failure.js';
 import { asError, controlledSignal, positiveInteger, requireLive, } from '../index.js';
+import { HttpByteStream } from './byte-stream.js';
 import { binaryHeaders, codecForResponse, decodeProtocol, normalizeMediaType, readBoundedBody, requireId, } from './response.js';
 import { HttpStream } from './stream.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
@@ -64,8 +65,9 @@ export class HttpTransport {
             const streamFraming = response.headers.get(protocol.http.STREAM_FRAMING_FIELD);
             const binaryId = response.headers.get(protocol.http.REQUEST_ID_FIELD);
             const binaryManifest = response.headers.get(protocol.http.BINARY_HEADERS_FIELD);
+            const binaryDelivery = response.headers.get(protocol.http.BINARY_DELIVERY_FIELD);
             const hasStreamSignal = streamFraming !== null;
-            const hasBinarySignal = binaryId !== null || binaryManifest !== null;
+            const hasBinarySignal = binaryId !== null || binaryManifest !== null || binaryDelivery !== null;
             if (hasStreamSignal && hasBinarySignal) {
                 throw new ProtocolError('server returned conflicting stream and binary response signals.');
             }
@@ -73,7 +75,13 @@ export class HttpTransport {
                 if (binaryId === null || binaryManifest === null) {
                     throw new ProtocolError('server returned an incomplete binary response signal.');
                 }
-                return await this.decodeBinary(response, requestId, binaryId, control);
+                if (binaryDelivery !== null && binaryDelivery !== protocol.http.STREAMING_BINARY_DELIVERY) {
+                    throw new ProtocolError('server returned an unsupported binary delivery signal.');
+                }
+                const binary = await this.decodeBinary(response, requestId, binaryId, binaryDelivery !== null, control);
+                if (!(binary.value.body instanceof Uint8Array))
+                    handedOff = true;
+                return binary;
             }
             const responseCodec = await codecForResponse(response.headers.get('content-type'));
             if (responseCodec === undefined) {
@@ -149,10 +157,7 @@ export class HttpTransport {
             signal: control.signal,
         });
     }
-    async decodeBinary(response, requestId, binaryId, control) {
-        if (!response.ok) {
-            throw new ProtocolError('server returned binary data with an error status.');
-        }
+    async decodeBinary(response, requestId, binaryId, streaming, control) {
         if (binaryId !== String(requestId)) {
             throw new ProtocolError(`binary response requestId ${JSON.stringify(binaryId)} does not match request requestId ${requestId}.`);
         }
@@ -160,17 +165,33 @@ export class HttpTransport {
         if (mediaType === undefined) {
             throw new ProtocolError('binary response has no media type.');
         }
-        const body = await readBoundedBody(response, this.maximumResponseBytes, control.signal);
-        requireLive(control);
         const headerNames = decodeProtocol('binary application-header manifest', () => protocol.http.decodeBinaryHeaderNames(response.headers.get(protocol.http.BINARY_HEADERS_FIELD)));
         const headers = binaryHeaders(response.headers, headerNames);
         const invocation = decodeProtocol('binary InvocationId field', () => protocol.http.decodeInvocationId(response.headers.get(protocol.http.INVOCATION_FIELD)));
+        if (streaming) {
+            if (response.body === null)
+                throw new ProtocolError('streaming binary has no body.');
+            requireLive(control);
+            return {
+                kind: 'binary',
+                invocation,
+                value: {
+                    body: new HttpByteStream(response.body, this.maximumResponseBytes, control),
+                    mediaType,
+                    ...(response.status === 200 ? {} : { status: response.status }),
+                    ...(Object.keys(headers).length === 0 ? {} : { headers }),
+                },
+            };
+        }
+        const body = await readBoundedBody(response, this.maximumResponseBytes, control.signal);
+        requireLive(control);
         const binary = decodeProtocol('binary response', () => protocol.decodeBinaryResponse({
             kind: 'binary',
             requestId,
             invocation,
             body,
             mediaType,
+            status: response.status,
             ...(Object.keys(headers).length === 0 ? {} : { headers }),
         }));
         requireLive(control);
@@ -180,6 +201,7 @@ export class HttpTransport {
             value: {
                 body: binary.body,
                 mediaType: binary.mediaType,
+                ...(binary.status === 200 ? {} : { status: binary.status }),
                 ...(binary.headers === undefined ? {} : { headers: binary.headers }),
             },
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/kernel-client",
-  "version": "0.6.0-beta.16",
+  "version": "0.6.0-beta.18",
   "description": "Universal Client — protocol-first, transport-agnostic",
   "keywords": [
     "astrale",
@@ -65,18 +65,18 @@
     "access": "public"
   },
   "dependencies": {
-    "@astrale-os/kernel-core": ">=0.9.0-beta.10 <1.0.0",
-    "@astrale-os/kernel-dsl": ">=0.2.0-beta.8 <1.0.0",
-    "@astrale-os/kernel-protocol": ">=0.5.0-beta.10 <1.0.0",
     "@tanstack/pacer": "0.20.1",
-    "msgpackr": "^2.0.5"
+    "msgpackr": "^2.0.5",
+    "@astrale-os/kernel-core": "0.9.0-beta.14",
+    "@astrale-os/kernel-protocol": "0.5.0-beta.14",
+    "@astrale-os/kernel-dsl": "0.2.0-beta.11"
   },
   "devDependencies": {
-    "@astrale-os/kernel-server": ">=0.5.0-beta.11 <1.0.0",
     "@astrale/typescript-config": "npm:@jsr/astrale__typescript-config@~1.1.0",
     "@types/node": "^22.0.0",
     "typescript": "7.0.2",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.10",
+    "@astrale-os/kernel-server": "0.5.0-beta.15"
   },
   "scripts": {
     "build": "tsc",