@astrale-os/kernel-client 0.6.0-beta.1 → 0.6.0-beta.10

package/dist/schema/admission.js

@@ -0,0 +1,17 @@
+import * as portable from '@astrale-os/kernel-dsl/value';
+/** Admit one value result through its Core-owned syscall contract. */
+export function acceptOutput(contract, input) {
+    const value = portable.accept(input);
+    const parsed = contract.safeParse(value);
+    if (!parsed.success)
+        throw new TypeError('Kernel returned an invalid Schema result.');
+    return freeze(parsed.data);
+}
+function freeze(input) {
+    if (input !== null && typeof input === 'object' && !Object.isFrozen(input)) {
+        for (const value of Object.values(input))
+            freeze(value);
+        Object.freeze(input);
+    }
+    return input;
+}

package/dist/schema/contracts.d.ts

@@ -0,0 +1,12 @@
+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';
+export type OperationId = installation.OperationId;
+/** Canonical caller input accepted by the Kernel install syscall. */
+export type DesiredInstallation = CoreDesiredInstallation;
+export type InstallRequest = InstallInput;
+/** Admitted terminal install receipt returned by the Kernel. */
+export type InstallReceipt = InstallOutput;
+/** Canonical caller input accepted by the Kernel uninstall syscall. */
+export type UninstallRequest = UninstallInput;
+/** Admitted terminal uninstall receipt returned by the Kernel. */
+export type UninstallReceipt = UninstallOutput;

package/dist/schema/contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/schema/index.d.ts

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

package/dist/schema/index.js

@@ -0,0 +1,2 @@
+export { createSchema, } from './schema.js';
+export { acceptOperationId, createOperationId } from './operation.js';

package/dist/schema/introspection.d.ts

@@ -0,0 +1,5 @@
+import type { introspection as language } from '@astrale-os/kernel-core/schema';
+import type * as protocol from '@astrale-os/kernel-protocol/schema';
+import type { RequestOptions } from '../transport/index.js';
+import type { SchemaCall, SchemaOptions } from './schema.js';
+export declare function introspect<InputType extends language.Introspection>(invoke: SchemaCall, limits: SchemaOptions, request: InputType, options?: RequestOptions): Promise<protocol.installation.introspection.ResultFor<InputType>>;

package/dist/schema/introspection.js

@@ -0,0 +1,15 @@
+import { Path } from '@astrale-os/kernel-core/path';
+import { introspect as introspectRef } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+import * as schema from '@astrale-os/kernel-protocol/schema';
+import { call } from '../client/index.js';
+const INTROSPECT_PATH = Path.project(introspectRef).raw;
+export async function introspect(invoke, limits, request, options) {
+    const result = await invoke(call(INTROSPECT_PATH, request), options);
+    if (result.kind !== 'binary') {
+        throw new TypeError('Schema introspection returned a non-binary result.');
+    }
+    if (result.value.mediaType !== schema.installation.introspection.MEDIA_TYPE) {
+        throw new TypeError('Schema introspection returned an unsupported media type.');
+    }
+    return schema.installation.introspection.decode(request, result.value.body, limits);
+}

package/dist/schema/operation.d.ts

@@ -0,0 +1,5 @@
+import type { OperationId } from './contracts.js';
+/** Accept one canonical lowercase RFC 9562 UUIDv4 operation identity. */
+export declare function acceptOperationId(input: unknown): OperationId;
+/** Allocate one cryptographically generated operation identity for a new lifecycle request. */
+export declare function createOperationId(): OperationId;

package/dist/schema/operation.js

@@ -0,0 +1,9 @@
+import * as installation from '@astrale-os/kernel-core/schema/installation';
+/** Accept one canonical lowercase RFC 9562 UUIDv4 operation identity. */
+export function acceptOperationId(input) {
+    return installation.acceptOperationId(input);
+}
+/** Allocate one cryptographically generated operation identity for a new lifecycle request. */
+export function createOperationId() {
+    return acceptOperationId(globalThis.crypto.randomUUID());
+}

package/dist/schema/schema.d.ts

@@ -0,0 +1,19 @@
+import type { introspection } from '@astrale-os/kernel-core/schema';
+import type * 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';
+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 interface SchemaApi {
+    install(request: InstallRequest, options?: RequestOptions): Promise<InstallReceipt>;
+    uninstall(request: UninstallRequest, options?: RequestOptions): Promise<UninstallReceipt>;
+    introspect<Input extends introspection.Introspection>(request: Input, options?: RequestOptions): Promise<protocolSchema.installation.introspection.ResultFor<Input>>;
+}
+/** 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

@@ -0,0 +1,43 @@
+import { Path } from '@astrale-os/kernel-core/path';
+import { installOutput, uninstallOutput, } from '@astrale-os/kernel-core/schema/kernel/syscalls/contracts';
+import { install, uninstall } from '@astrale-os/kernel-core/schema/kernel/syscalls/references';
+import { call as invocation } from '../client/index.js';
+import { acceptOutput } from './admission.js';
+import { introspect as inspect } 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. */
+export function createSchema(call, limits) {
+    if (typeof call !== 'function')
+        throw new TypeError('Schema call capability is invalid.');
+    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);
+        },
+        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);
+        },
+    });
+}
+function value(result) {
+    if (result.kind !== 'value')
+        throw new TypeError('Schema syscall returned a non-value result.');
+    return result.value;
+}
+function admitLimits(input) {
+    if (input === null ||
+        typeof input !== 'object' ||
+        !Number.isSafeInteger(input.maximumPublicationBytes) ||
+        input.maximumPublicationBytes < 1 ||
+        !Number.isSafeInteger(input.maximumBundleBytes) ||
+        input.maximumBundleBytes < 1) {
+        throw new TypeError('Schema introspection limits are invalid.');
+    }
+    return Object.freeze({ ...input });
+}

package/dist/session/bound.d.ts

@@ -0,0 +1,44 @@
+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';
+import type { ViewCatalog } from './views/index.js';
+import { type AuthApi } from '../auth/index.js';
+import { type Binary, type Call, type Input, type Result, type Stream } from '../client/index.js';
+import { type GraphApi } from '../graph/index.js';
+/** Exact live Session surface captured by one credential-bound Kernel view. */
+export interface BoundSessionSource {
+    readonly kernel: IssuerId;
+    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<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 {
+    readonly signal: AbortSignal;
+    /** Absolute Unix time in milliseconds. */
+    readonly deadline: number;
+}
+/**
+ * Credential-bound Kernel operations over one caller-owned ClientSession.
+ *
+ * The view owns no credential, transport, route cache, or lifecycle. Its source Session owns all of
+ * those concerns and closing that Session invalidates every operation exposed here.
+ */
+export interface BoundClientSession extends GraphApi {
+    readonly kernel: IssuerId;
+    readonly auth: AuthApi;
+    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<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. */
+export declare function bindSession(source: BoundSessionSource, controls?: BoundSessionControls): BoundClientSession;

package/dist/session/bound.js

@@ -0,0 +1,75 @@
+import { createAuth } from '../auth/index.js';
+import { call as createCall, } from '../client/index.js';
+import { createGraph } from '../graph/index.js';
+/** Capture one Session into the ordinary graph, auth, and invocation Kernel journey. */
+export function bindSession(source, controls) {
+    if (source === null || typeof source !== 'object')
+        invalid();
+    const admittedControls = admitControls(controls);
+    const dispatchSource = capture(source, 'dispatch');
+    const callSource = capture(source, 'call');
+    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));
+    return Object.freeze({
+        ...graph,
+        kernel: source.kernel,
+        auth,
+        dispatch,
+        call,
+        invoke,
+        stream,
+        binary,
+        installation,
+        viewsFor,
+    });
+}
+function admitControls(input) {
+    if (input === undefined)
+        return undefined;
+    if (input === null ||
+        typeof input !== 'object' ||
+        !(input.signal instanceof AbortSignal) ||
+        !Number.isFinite(input.deadline)) {
+        invalid();
+    }
+    return Object.freeze({ signal: input.signal, deadline: input.deadline });
+}
+function requestOptions(options, controls) {
+    return mergeOptions(options, controls);
+}
+function controlOptions(options, controls) {
+    return mergeOptions(options, controls);
+}
+function mergeOptions(options, controls) {
+    if (controls === undefined)
+        return options;
+    if (options?.signal !== undefined && options.signal !== controls.signal) {
+        throw new TypeError('Bound ClientSession cancellation cannot be replaced.');
+    }
+    if (controls.signal.aborted)
+        throw controls.signal.reason ?? new Error('Invocation cancelled.');
+    const remaining = Math.max(1, Math.ceil(controls.deadline - Date.now()));
+    const timeoutMs = options?.timeoutMs === undefined ? remaining : Math.min(options.timeoutMs, remaining);
+    return Object.freeze({ ...options, signal: controls.signal, timeoutMs });
+}
+function capture(source, key) {
+    const value = source[key];
+    if (typeof value !== 'function')
+        invalid();
+    return value.bind(source);
+}
+function invalid() {
+    throw new TypeError('Bound ClientSession source is invalid.');
+}

package/dist/session/context/control.d.ts

@@ -3,4 +3,3 @@ export interface SessionControlOptions {
     readonly timeoutMs?: number;
 }
 export declare function admitControlOptions(input: SessionControlOptions | undefined): Readonly<SessionControlOptions>;
-//# sourceMappingURL=control.d.ts.map

package/dist/session/context/control.js

@@ -15,4 +15,3 @@ export function admitControlOptions(input) {
             : { timeoutMs: platformDuration(input.timeoutMs, 'timeoutMs') }),
     });
 }
-//# sourceMappingURL=control.js.map

package/dist/session/context/index.d.ts

@@ -1,5 +1,4 @@
 export { admitControlOptions, type SessionControlOptions } from './control.js';
 export { DEFAULT_MAXIMUM_BUNDLE_BYTES, DEFAULT_MAXIMUM_PUBLICATION_BYTES, DEFAULT_MAXIMUM_RESPONSE_BYTES, DEFAULT_MAXIMUM_ROUTES, DEFAULT_TIMEOUT_MS, platformDuration, positive, } from './limits.js';
 export { createSessionOperation, runSessionOperation, sessionTransportOptions, type SessionOperation, } from './operation.js';
-export { admitPolicy, allowEndpoint, endpoint, type SessionPolicy } from './policy.js';
-//# sourceMappingURL=index.d.ts.map
+export { admitKernel, admitPolicy, allowEndpoint, kernelInvocationEndpoint, type SessionPolicy, } from './policy.js';

package/dist/session/context/index.js

@@ -1,5 +1,4 @@
 export { admitControlOptions } from './control.js';
 export { DEFAULT_MAXIMUM_BUNDLE_BYTES, DEFAULT_MAXIMUM_PUBLICATION_BYTES, DEFAULT_MAXIMUM_RESPONSE_BYTES, DEFAULT_MAXIMUM_ROUTES, DEFAULT_TIMEOUT_MS, platformDuration, positive, } from './limits.js';
 export { createSessionOperation, runSessionOperation, sessionTransportOptions, } from './operation.js';
-export { admitPolicy, allowEndpoint, endpoint } from './policy.js';
-//# sourceMappingURL=index.js.map
+export { admitKernel, admitPolicy, allowEndpoint, kernelInvocationEndpoint, } from './policy.js';

package/dist/session/context/limits.d.ts

@@ -5,4 +5,3 @@ export declare const DEFAULT_TIMEOUT_MS = 30000;
 export declare const DEFAULT_MAXIMUM_ROUTES = 256;
 export declare function positive(input: number, label: string): number;
 export declare function platformDuration(input: number, label: string): number;
-//# sourceMappingURL=limits.d.ts.map

package/dist/session/context/limits.js

@@ -16,4 +16,3 @@ export function platformDuration(input, label) {
     }
     return admitted;
 }
-//# sourceMappingURL=limits.js.map

package/dist/session/context/operation.d.ts

@@ -17,4 +17,3 @@ export declare function sessionTransportOptions(operation: SessionOperation, ide
 /** Settle independently of a caller capability that ignores its supplied AbortSignal. */
 export declare function runSessionOperation<Result>(operation: SessionOperation, task: (signal: AbortSignal) => Result | PromiseLike<Result>): Promise<Result>;
 export declare function requireSessionOperation(operation: SessionOperation): void;
-//# sourceMappingURL=operation.d.ts.map

package/dist/session/context/operation.js

@@ -1,4 +1,4 @@
-import { ClientError } from '../../errors/index.js';
+import { SessionError } from '../../errors/index.js';
 /** Create one total wall-clock budget for a complete public Client Session operation. */
 export function createSessionOperation(lifecycle, input, defaultTimeoutMs) {
     const timeoutMs = input?.timeoutMs ?? defaultTimeoutMs;
@@ -22,7 +22,7 @@ export function remainingSessionTime(operation) {
     requireSessionOperation(operation);
     const remaining = operation.deadline - Date.now();
     if (remaining < 1)
-        throw new ClientError('Session operation timed out.');
+        throw new SessionError('Session operation timed out.', { failure: 'timeout' });
     return remaining;
 }
 export function sessionTransportOptions(operation, idempotencyKey) {
@@ -33,13 +33,8 @@ export function sessionTransportOptions(operation, idempotencyKey) {
     });
 }
 /** Settle independently of a caller capability that ignores its supplied AbortSignal. */
-export function runSessionOperation(operation, task) {
-    try {
-        requireSessionOperation(operation);
-    }
-    catch (error) {
-        return Promise.reject(error);
-    }
+export async function runSessionOperation(operation, task) {
+    requireSessionOperation(operation);
     let abort;
     const interrupted = new Promise((_resolve, reject) => {
         abort = () => reject(sessionInterruption(operation.signal.reason));
@@ -49,9 +44,14 @@ export function runSessionOperation(operation, task) {
         requireSessionOperation(operation);
         return task(operation.signal);
     });
-    return Promise.race([execution, interrupted]).finally(() => {
-        if (abort !== undefined)
-            operation.signal.removeEventListener('abort', abort);
+    return Promise.race([execution, interrupted])
+        .catch((cause) => {
+        if (operation.signal.aborted)
+            throw sessionInterruption(operation.signal.reason);
+        throw cause;
+    })
+        .finally(() => {
+        operation.signal.removeEventListener('abort', abort);
     });
 }
 export function requireSessionOperation(operation) {
@@ -60,11 +60,13 @@ export function requireSessionOperation(operation) {
     throw sessionInterruption(operation.signal.reason);
 }
 function sessionInterruption(reason) {
+    if (reason instanceof SessionError)
+        return reason;
     if (reason instanceof DOMException && reason.name === 'TimeoutError') {
-        return new ClientError('Session operation timed out.', { cause: reason });
+        return new SessionError('Session operation timed out.', { cause: reason, failure: 'timeout' });
     }
-    return reason instanceof Error
-        ? reason
-        : new ClientError('Session operation was cancelled.', { cause: reason });
+    return new SessionError('Session operation was cancelled.', {
+        cause: reason,
+        failure: 'cancelled',
+    });
 }
-//# sourceMappingURL=operation.js.map

package/dist/session/context/policy.d.ts

@@ -1,10 +1,11 @@
+import { type IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 export interface SessionPolicy {
     readonly maximumRouteAgeMs: number;
     readonly allowEndpoint?: (url: string) => boolean;
     readonly allowInsecureHttp?: boolean;
 }
 export declare function admitPolicy(input: SessionPolicy): Readonly<SessionPolicy>;
-export declare function endpoint(input: string, insecure: boolean): string;
+export declare function admitKernel(input: string, insecure: boolean): IssuerId;
+export declare function kernelInvocationEndpoint(input: IssuerId): string;
 export declare function websocketEndpoint(input: string, insecure: boolean): string;
 export declare function allowEndpoint(url: string, policy: Readonly<SessionPolicy>): void;
-//# sourceMappingURL=policy.d.ts.map

package/dist/session/context/policy.js

@@ -1,3 +1,4 @@
+import { accept as acceptIssuer } from '@astrale-os/kernel-core/auth/issuer';
 import { ClientError } from '../../errors/index.js';
 import { positive } from './limits.js';
 export function admitPolicy(input) {
@@ -16,21 +17,27 @@ export function admitPolicy(input) {
         ...(input.allowInsecureHttp === true ? { allowInsecureHttp: true } : {}),
     });
 }
-export function endpoint(input, insecure) {
+export function admitKernel(input, insecure) {
     let url;
+    let admitted;
     try {
-        url = new URL(input);
+        admitted = acceptIssuer(input);
+        url = new URL(admitted);
     }
     catch (cause) {
-        throw new TypeError('Session endpoint is invalid.', { cause });
+        throw new TypeError('Session Kernel issuer is invalid.', { cause });
     }
     if (url.username !== '' ||
         url.password !== '' ||
         url.hash !== '' ||
+        url.search !== '' ||
         (url.protocol !== 'https:' && !(insecure && url.protocol === 'http:'))) {
-        throw new TypeError('Session endpoint is invalid.');
+        throw new TypeError('Session Kernel issuer is invalid.');
     }
-    return url.toString();
+    return admitted;
+}
+export function kernelInvocationEndpoint(input) {
+    return `${input}/invoke`;
 }
 export function websocketEndpoint(input, insecure) {
     let url;
@@ -60,4 +67,3 @@ export function allowEndpoint(url, policy) {
         throw new ClientError('Endpoint is denied by Session policy.');
     }
 }
-//# sourceMappingURL=policy.js.map

package/dist/session/discovery/bundle.d.ts

@@ -15,4 +15,3 @@ export declare class BundleDiscovery {
     clear(): void;
     private fetch;
 }
-//# sourceMappingURL=bundle.d.ts.map

package/dist/session/discovery/bundle.js

@@ -1,7 +1,8 @@
-import { publication as publicationCodec } from '@astrale-os/kernel-protocol';
+import { decodeBundleValue } from '@astrale-os/kernel-protocol/publication/bundle';
 import { ClientError } from '../../errors/index.js';
-import { allowEndpoint, runSessionOperation } from '../context/index.js';
+import { allowEndpoint } from '../context/index.js';
 import { boundedResponse, requireExactResponse } from './publication.js';
+import { runAcquisition } from './transport.js';
 export class BundleDiscovery {
     options;
     bundles = new Map();
@@ -22,34 +23,33 @@ export class BundleDiscovery {
         this.bundles.clear();
     }
     async fetch(publication, operation) {
-        if (publication.schema.bundle.size > this.options.maximumBytes) {
+        if (publication.schema.bundle.ref.size > this.options.maximumBytes) {
             throw new ClientError('Bundle artifact exceeds its byte limit.');
         }
         const href = publication.schema.bundle.href;
         allowEndpoint(href, this.options.policy);
-        const response = await runSessionOperation(operation, (signal) => this.options.fetch(href, {
-            headers: { accept: publication.schema.bundle.mediaType },
+        const response = await runAcquisition(operation, 'bundle', 'unknown', 'Kernel bundle could not be retrieved.', (signal) => this.options.fetch(href, {
+            headers: { accept: publication.schema.bundle.ref.mediaType },
             redirect: 'manual',
             signal,
         }));
         requireExactResponse(response, href, 'Bundle retrieval');
         if (!response.ok)
             throw new ClientError(`Bundle retrieval returned HTTP ${response.status}.`);
-        if (response.headers.get('content-type') !== publication.schema.bundle.mediaType) {
+        if (response.headers.get('content-type') !== publication.schema.bundle.ref.mediaType) {
             throw new ClientError('Bundle artifact media type differs from its descriptor.');
         }
         const etag = response.headers.get('etag');
-        if (etag !== null && etag !== `"${publication.schema.bundle.digest}"`) {
+        if (etag !== null && etag !== `"${publication.schema.bundle.ref.digest}"`) {
             throw new ClientError('Bundle response ETag differs from its descriptor.');
         }
-        const bytes = await runSessionOperation(operation, (signal) => boundedResponse(response, publication.schema.bundle.size, signal));
-        if (bytes.byteLength !== publication.schema.bundle.size) {
+        const bytes = await runAcquisition(operation, 'bundle', 'receive', 'Kernel bundle response could not be read.', (signal) => boundedResponse(response, publication.schema.bundle.ref.size, signal));
+        if (bytes.byteLength !== publication.schema.bundle.ref.size) {
             throw new ClientError('Bundle artifact size differs from its descriptor.');
         }
-        return publicationCodec.decodeBundle(publication, bytes);
+        return decodeBundleValue(publication, bytes);
     }
 }
 function bundleKey(publication) {
     return `${new URL(publication.schema.bundle.href).origin}\u0000${publication.etag}`;
 }
-//# sourceMappingURL=bundle.js.map

package/dist/session/discovery/discovery.d.ts

@@ -1,15 +1,10 @@
-import type { bundle } from '@astrale-os/kernel-dsl/v1';
-import type { publication } from '@astrale-os/kernel-protocol';
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { SessionOperation, SessionPolicy } from '../context/index.js';
 import type { BundleDiscovery } from './bundle.js';
 import type { PublicationDiscovery } from './publication.js';
 import type { SessionSnapshot } from './snapshot.js';
-export interface DiscoveredSource {
-    readonly publication: publication.Publication;
-    readonly bundle: bundle.Bundle;
-}
 export declare class SessionDiscovery {
-    readonly url: string;
+    readonly kernel: IssuerId;
     private readonly policy;
     private readonly publications;
     private readonly bundles;
@@ -17,11 +12,8 @@ export declare class SessionDiscovery {
     private readonly acquisitionOperation;
     private retained?;
     private flight?;
-    constructor(url: string, policy: Readonly<SessionPolicy>, publications: PublicationDiscovery, bundles: BundleDiscovery, requireOpen: () => void, acquisitionOperation: () => SessionOperation);
+    constructor(kernel: IssuerId, policy: Readonly<SessionPolicy>, publications: PublicationDiscovery, bundles: BundleDiscovery, requireOpen: () => void, acquisitionOperation: () => SessionOperation);
     snapshot(operation: SessionOperation): Promise<SessionSnapshot>;
-    discover(url: string, operation: SessionOperation): Promise<DiscoveredSource>;
-    invalidate(url: string): void;
     clear(): void;
     private acquireSnapshot;
 }
-//# sourceMappingURL=discovery.d.ts.map

package/dist/session/discovery/discovery.js

@@ -2,7 +2,7 @@ import { runSessionOperation } from '../context/index.js';
 import { rootViewCatalog } from '../views/index.js';
 import { createSessionSnapshot } from './snapshot.js';
 export class SessionDiscovery {
-    url;
+    kernel;
     policy;
     publications;
     bundles;
@@ -10,8 +10,8 @@ export class SessionDiscovery {
     acquisitionOperation;
     retained;
     flight;
-    constructor(url, policy, publications, bundles, requireOpen, acquisitionOperation) {
-        this.url = url;
+    constructor(kernel, policy, publications, bundles, requireOpen, acquisitionOperation) {
+        this.kernel = kernel;
         this.policy = policy;
         this.publications = publications;
         this.bundles = bundles;
@@ -33,27 +33,14 @@ export class SessionDiscovery {
             .catch(() => undefined);
         return runSessionOperation(operation, () => flight);
     }
-    async discover(url, operation) {
-        this.requireOpen();
-        const publication = await this.publications.get(url, operation);
-        const artifact = await this.bundles.get(publication, operation);
-        this.requireOpen();
-        return Object.freeze({ publication, bundle: artifact });
-    }
-    invalidate(url) {
-        this.publications.invalidate(url);
-        this.bundles.clear();
-        if (new URL(url).origin === new URL(this.url).origin)
-            this.retained = undefined;
-    }
     clear() {
         this.publications.invalidate();
         this.bundles.clear();
         this.retained = undefined;
     }
     async acquireSnapshot(operation) {
-        const previous = this.publications.current(this.url);
-        const publication = await this.publications.revalidate(this.url, operation);
+        const previous = this.publications.current();
+        const publication = await this.publications.revalidate(operation);
         if (previous !== undefined && previous.etag !== publication.etag)
             this.bundles.clear();
         const artifact = await this.bundles.get(publication, operation);
@@ -61,9 +48,8 @@ export class SessionDiscovery {
         if (this.retained?.publication.etag === publication.etag)
             return this.retained;
         const views = rootViewCatalog(publication, artifact, this.policy);
-        const snapshot = createSessionSnapshot(this.url, publication, artifact, views);
+        const snapshot = createSessionSnapshot(this.kernel, publication, artifact, views);
         this.retained = snapshot;
         return snapshot;
     }
 }
-//# sourceMappingURL=discovery.js.map

package/dist/session/discovery/index.d.ts

@@ -1,18 +1,15 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
 import type { Fetch } from '../../transport/http/index.js';
 import type { SessionOperation, SessionPolicy } from '../context/index.js';
-import type { DiscoveredSource } from './discovery.js';
 import type { SessionSnapshot } from './snapshot.js';
-export type { DiscoveredSource } from './discovery.js';
 export type { SessionSnapshot } from './snapshot.js';
 export interface SessionDiscovery {
-    readonly url: string;
+    readonly kernel: IssuerId;
     snapshot(operation: SessionOperation): Promise<SessionSnapshot>;
-    discover(url: string, operation: SessionOperation): Promise<DiscoveredSource>;
-    invalidate(url: string): void;
     clear(): void;
 }
 export interface SessionDiscoveryOptions {
-    readonly url: string;
+    readonly kernel: IssuerId;
     readonly fetch: Fetch;
     readonly policy: Readonly<SessionPolicy>;
     readonly maximumPublicationBytes: number;
@@ -21,4 +18,3 @@ export interface SessionDiscoveryOptions {
     readonly acquisitionOperation: () => SessionOperation;
 }
 export declare function createSessionDiscovery(options: SessionDiscoveryOptions): SessionDiscovery;
-//# sourceMappingURL=index.d.ts.map

package/dist/session/discovery/index.js

@@ -2,7 +2,8 @@ import { BundleDiscovery } from './bundle.js';
 import { SessionDiscovery as SessionDiscoveryImplementation } from './discovery.js';
 import { PublicationDiscovery } from './publication.js';
 export function createSessionDiscovery(options) {
-    return new SessionDiscoveryImplementation(options.url, options.policy, new PublicationDiscovery({
+    return new SessionDiscoveryImplementation(options.kernel, options.policy, new PublicationDiscovery({
+        kernel: options.kernel,
         fetch: options.fetch,
         policy: options.policy,
         maximumBytes: options.maximumPublicationBytes,
@@ -12,4 +13,3 @@ export function createSessionDiscovery(options) {
         maximumBytes: options.maximumBundleBytes,
     }), options.requireOpen, options.acquisitionOperation);
 }
-//# sourceMappingURL=index.js.map