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

package/dist/session/bound.js

@@ -1,42 +1,75 @@
 import { createAuth } from '../auth/index.js';
+import { call as createCall, } from '../client/index.js';
 import { createGraph } from '../graph/index.js';
-import { createSchemaBoundView } from '../schema/bound/index.js';
-/**
- * Credential-bound view over a `ClientSession`. Every dispatch primitive delegates
- * to the underlying ClientSession with `opts.credential` replaced by the captured
- * credential. `as(next)` returns a fresh view — rebindings don't mutate.
- */
-export function createBoundSessionView(session, credential, opts = {}) {
-    const cred = () => (typeof credential === 'function' ? credential() : credential);
-    const callOpts = (callOptions) => ({
-        ...(opts.delegation !== undefined ? { delegation: opts.delegation } : {}),
-        ...callOptions,
-        credential: cred(),
-    });
-    // One call capability, shared by graph (data plane) and auth (control plane).
-    const boundCall = (method, params) => session.call(method, params, callOpts(undefined));
-    const graph = createGraph(boundCall);
-    const auth = createAuth(boundCall, { credential: cred });
-    // Name the view so `withSchema` can compose over it — the schema-bound surface
-    // closes over THIS view's `call`, so the bound credential rides every dispatch
-    // AND read (the old delegation to `session.withSchema` dropped the credential).
-    const view = {
-        get default() {
-            return session.default;
-        },
-        get registry() {
-            return session.registry;
-        },
+/** 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,
-        call: (method, params, opts) => session.call(method, params, callOpts(opts)),
-        stream: (method, params, opts) => session.stream(method, params, callOpts(opts)),
-        binary: (method, params, opts) => session.binary(method, params, callOpts(opts)),
-        signal: (method, params, opts) => session.signal(method, params, callOpts(opts)),
-        describe: (method) => session.describe(method),
-        withSchema: (schema) => createSchemaBoundView(view, schema),
-        as: (next, nextOpts) => createBoundSessionView(session, next, nextOpts),
-    };
-    return view;
+        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.');
 }
-//# sourceMappingURL=bound.js.map

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

@@ -0,0 +1,5 @@
+export interface SessionControlOptions {
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+}
+export declare function admitControlOptions(input: SessionControlOptions | undefined): Readonly<SessionControlOptions>;

package/dist/session/context/control.js

@@ -0,0 +1,17 @@
+import { platformDuration } from './limits.js';
+export function admitControlOptions(input) {
+    if (input === undefined)
+        return Object.freeze({});
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        throw new TypeError('Session control options are invalid.');
+    }
+    if (input.signal !== undefined && !(input.signal instanceof AbortSignal)) {
+        throw new TypeError('Session cancellation signal is invalid.');
+    }
+    return Object.freeze({
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        ...(input.timeoutMs === undefined
+            ? {}
+            : { timeoutMs: platformDuration(input.timeoutMs, 'timeoutMs') }),
+    });
+}

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

@@ -0,0 +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 { admitKernel, admitPolicy, allowEndpoint, kernelInvocationEndpoint, type SessionPolicy, } from './policy.js';

package/dist/session/context/index.js

@@ -0,0 +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 { admitKernel, admitPolicy, allowEndpoint, kernelInvocationEndpoint, } from './policy.js';

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

@@ -0,0 +1,7 @@
+export declare const DEFAULT_MAXIMUM_PUBLICATION_BYTES: number;
+export declare const DEFAULT_MAXIMUM_BUNDLE_BYTES: number;
+export declare const DEFAULT_MAXIMUM_RESPONSE_BYTES: number;
+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;

package/dist/session/context/limits.js

@@ -0,0 +1,18 @@
+export const DEFAULT_MAXIMUM_PUBLICATION_BYTES = 1024 * 1024;
+export const DEFAULT_MAXIMUM_BUNDLE_BYTES = 16 * 1024 * 1024;
+export const DEFAULT_MAXIMUM_RESPONSE_BYTES = 16 * 1024 * 1024;
+export const DEFAULT_TIMEOUT_MS = 30_000;
+export const DEFAULT_MAXIMUM_ROUTES = 256;
+export function positive(input, label) {
+    if (!Number.isSafeInteger(input) || input < 1) {
+        throw new TypeError(`${label} must be a positive safe integer.`);
+    }
+    return input;
+}
+export function platformDuration(input, label) {
+    const admitted = positive(input, label);
+    if (admitted > 2_147_483_647) {
+        throw new TypeError(`${label} exceeds the platform timer range.`);
+    }
+    return admitted;
+}

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

@@ -0,0 +1,19 @@
+import type { RequestOptions } from '../../transport/index.js';
+export interface SessionOperation {
+    readonly signal: AbortSignal;
+    readonly deadline: number;
+    readonly idempotencyKey?: RequestOptions['idempotencyKey'];
+    /** Atomically spend this operation's sole Stale-or-Miss source-resolution allowance. */
+    claimRecovery(): boolean;
+}
+/** Create one total wall-clock budget for a complete public Client Session operation. */
+export declare function createSessionOperation(lifecycle: AbortSignal, input: {
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+    readonly idempotencyKey?: RequestOptions['idempotencyKey'];
+} | undefined, defaultTimeoutMs: number): SessionOperation;
+export declare function remainingSessionTime(operation: SessionOperation): number;
+export declare function sessionTransportOptions(operation: SessionOperation, idempotencyKey?: RequestOptions['idempotencyKey']): RequestOptions;
+/** 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;

package/dist/session/context/operation.js

@@ -0,0 +1,72 @@
+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;
+    const deadline = Date.now() + timeoutMs;
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const signals = input?.signal === undefined ? [lifecycle, timeout] : [input.signal, lifecycle, timeout];
+    let recoveryClaimed = false;
+    return Object.freeze({
+        signal: AbortSignal.any(signals),
+        deadline,
+        ...(input?.idempotencyKey === undefined ? {} : { idempotencyKey: input.idempotencyKey }),
+        claimRecovery: () => {
+            if (recoveryClaimed)
+                return false;
+            recoveryClaimed = true;
+            return true;
+        },
+    });
+}
+export function remainingSessionTime(operation) {
+    requireSessionOperation(operation);
+    const remaining = operation.deadline - Date.now();
+    if (remaining < 1)
+        throw new SessionError('Session operation timed out.', { failure: 'timeout' });
+    return remaining;
+}
+export function sessionTransportOptions(operation, idempotencyKey) {
+    return Object.freeze({
+        signal: operation.signal,
+        timeoutMs: remainingSessionTime(operation),
+        ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
+    });
+}
+/** Settle independently of a caller capability that ignores its supplied AbortSignal. */
+export async function runSessionOperation(operation, task) {
+    requireSessionOperation(operation);
+    let abort;
+    const interrupted = new Promise((_resolve, reject) => {
+        abort = () => reject(sessionInterruption(operation.signal.reason));
+        operation.signal.addEventListener('abort', abort, { once: true });
+    });
+    const execution = Promise.resolve().then(() => {
+        requireSessionOperation(operation);
+        return task(operation.signal);
+    });
+    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) {
+    if (!operation.signal.aborted)
+        return;
+    throw sessionInterruption(operation.signal.reason);
+}
+function sessionInterruption(reason) {
+    if (reason instanceof SessionError)
+        return reason;
+    if (reason instanceof DOMException && reason.name === 'TimeoutError') {
+        return new SessionError('Session operation timed out.', { cause: reason, failure: 'timeout' });
+    }
+    return new SessionError('Session operation was cancelled.', {
+        cause: reason,
+        failure: 'cancelled',
+    });
+}

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

@@ -0,0 +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 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;

package/dist/session/context/policy.js

@@ -0,0 +1,69 @@
+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) {
+    if (input === null || typeof input !== 'object') {
+        throw new TypeError('Session policy is invalid.');
+    }
+    if (input.allowEndpoint !== undefined && typeof input.allowEndpoint !== 'function') {
+        throw new TypeError('Session endpoint policy is invalid.');
+    }
+    if (input.allowInsecureHttp !== undefined && typeof input.allowInsecureHttp !== 'boolean') {
+        throw new TypeError('Session insecure-transport policy is invalid.');
+    }
+    return Object.freeze({
+        maximumRouteAgeMs: positive(input.maximumRouteAgeMs, 'maximumRouteAgeMs'),
+        ...(input.allowEndpoint === undefined ? {} : { allowEndpoint: input.allowEndpoint }),
+        ...(input.allowInsecureHttp === true ? { allowInsecureHttp: true } : {}),
+    });
+}
+export function admitKernel(input, insecure) {
+    let url;
+    let admitted;
+    try {
+        admitted = acceptIssuer(input);
+        url = new URL(admitted);
+    }
+    catch (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 Kernel issuer is invalid.');
+    }
+    return admitted;
+}
+export function kernelInvocationEndpoint(input) {
+    return `${input}/invoke`;
+}
+export function websocketEndpoint(input, insecure) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch (cause) {
+        throw new TypeError('Session WebSocket endpoint is invalid.', { cause });
+    }
+    if (url.username !== '' ||
+        url.password !== '' ||
+        url.hash !== '' ||
+        (url.protocol !== 'wss:' && !(insecure && url.protocol === 'ws:'))) {
+        throw new TypeError('Session WebSocket endpoint is invalid.');
+    }
+    return url.toString();
+}
+export function allowEndpoint(url, policy) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'wss:') {
+        if ((parsed.protocol !== 'http:' && parsed.protocol !== 'ws:') ||
+            policy.allowInsecureHttp !== true) {
+            throw new ClientError('Insecure or unsupported endpoint is not allowed.');
+        }
+    }
+    if (policy.allowEndpoint?.(parsed.toString()) === false) {
+        throw new ClientError('Endpoint is denied by Session policy.');
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { bundle } from '@astrale-os/kernel-dsl/v1';
+import type { publication } from '@astrale-os/kernel-protocol';
+import type { Fetch } from '../../transport/http/index.js';
+import type { SessionOperation, SessionPolicy } from '../context/index.js';
+export interface BundleDiscoveryOptions {
+    readonly fetch: Fetch;
+    readonly policy: Readonly<SessionPolicy>;
+    readonly maximumBytes: number;
+}
+export declare class BundleDiscovery {
+    private readonly options;
+    private readonly bundles;
+    constructor(options: BundleDiscoveryOptions);
+    get(publication: publication.Publication, operation: SessionOperation): Promise<bundle.Bundle>;
+    clear(): void;
+    private fetch;
+}

package/dist/session/discovery/bundle.js

@@ -0,0 +1,55 @@
+import { decodeBundleValue } from '@astrale-os/kernel-protocol/publication/bundle';
+import { ClientError } from '../../errors/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();
+    constructor(options) {
+        this.options = options;
+    }
+    async get(publication, operation) {
+        const key = bundleKey(publication);
+        const existing = this.bundles.get(key);
+        if (existing !== undefined)
+            return existing;
+        const discovered = await this.fetch(publication, operation);
+        const retained = this.bundles.get(key) ?? discovered;
+        this.bundles.set(key, retained);
+        return retained;
+    }
+    clear() {
+        this.bundles.clear();
+    }
+    async fetch(publication, operation) {
+        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 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.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.ref.digest}"`) {
+            throw new ClientError('Bundle response ETag differs from its descriptor.');
+        }
+        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 decodeBundleValue(publication, bytes);
+    }
+}
+function bundleKey(publication) {
+    return `${new URL(publication.schema.bundle.href).origin}\u0000${publication.etag}`;
+}

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

@@ -0,0 +1,19 @@
+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 declare class SessionDiscovery {
+    readonly kernel: IssuerId;
+    private readonly policy;
+    private readonly publications;
+    private readonly bundles;
+    private readonly requireOpen;
+    private readonly acquisitionOperation;
+    private retained?;
+    private flight?;
+    constructor(kernel: IssuerId, policy: Readonly<SessionPolicy>, publications: PublicationDiscovery, bundles: BundleDiscovery, requireOpen: () => void, acquisitionOperation: () => SessionOperation);
+    snapshot(operation: SessionOperation): Promise<SessionSnapshot>;
+    clear(): void;
+    private acquireSnapshot;
+}

package/dist/session/discovery/discovery.js

@@ -0,0 +1,55 @@
+import { runSessionOperation } from '../context/index.js';
+import { rootViewCatalog } from '../views/index.js';
+import { createSessionSnapshot } from './snapshot.js';
+export class SessionDiscovery {
+    kernel;
+    policy;
+    publications;
+    bundles;
+    requireOpen;
+    acquisitionOperation;
+    retained;
+    flight;
+    constructor(kernel, policy, publications, bundles, requireOpen, acquisitionOperation) {
+        this.kernel = kernel;
+        this.policy = policy;
+        this.publications = publications;
+        this.bundles = bundles;
+        this.requireOpen = requireOpen;
+        this.acquisitionOperation = acquisitionOperation;
+    }
+    snapshot(operation) {
+        this.requireOpen();
+        const current = this.flight;
+        if (current !== undefined)
+            return runSessionOperation(operation, () => current);
+        const flight = this.acquireSnapshot(this.acquisitionOperation());
+        this.flight = flight;
+        void flight
+            .finally(() => {
+            if (this.flight === flight)
+                this.flight = undefined;
+        })
+            .catch(() => undefined);
+        return runSessionOperation(operation, () => flight);
+    }
+    clear() {
+        this.publications.invalidate();
+        this.bundles.clear();
+        this.retained = undefined;
+    }
+    async acquireSnapshot(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);
+        this.requireOpen();
+        if (this.retained?.publication.etag === publication.etag)
+            return this.retained;
+        const views = rootViewCatalog(publication, artifact, this.policy);
+        const snapshot = createSessionSnapshot(this.kernel, publication, artifact, views);
+        this.retained = snapshot;
+        return snapshot;
+    }
+}

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

@@ -0,0 +1,20 @@
+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 { SessionSnapshot } from './snapshot.js';
+export type { SessionSnapshot } from './snapshot.js';
+export interface SessionDiscovery {
+    readonly kernel: IssuerId;
+    snapshot(operation: SessionOperation): Promise<SessionSnapshot>;
+    clear(): void;
+}
+export interface SessionDiscoveryOptions {
+    readonly kernel: IssuerId;
+    readonly fetch: Fetch;
+    readonly policy: Readonly<SessionPolicy>;
+    readonly maximumPublicationBytes: number;
+    readonly maximumBundleBytes: number;
+    readonly requireOpen: () => void;
+    readonly acquisitionOperation: () => SessionOperation;
+}
+export declare function createSessionDiscovery(options: SessionDiscoveryOptions): SessionDiscovery;

package/dist/session/discovery/index.js

@@ -0,0 +1,15 @@
+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.kernel, options.policy, new PublicationDiscovery({
+        kernel: options.kernel,
+        fetch: options.fetch,
+        policy: options.policy,
+        maximumBytes: options.maximumPublicationBytes,
+    }), new BundleDiscovery({
+        fetch: options.fetch,
+        policy: options.policy,
+        maximumBytes: options.maximumBundleBytes,
+    }), options.requireOpen, options.acquisitionOperation);
+}

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

@@ -0,0 +1,23 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth/issuer';
+import type { publication } from '@astrale-os/kernel-protocol';
+import type { Fetch } from '../../transport/http/index.js';
+import type { SessionOperation } from '../context/index.js';
+import { type SessionPolicy } from '../context/index.js';
+export interface PublicationDiscoveryOptions {
+    readonly kernel: IssuerId;
+    readonly fetch: Fetch;
+    readonly policy: Readonly<SessionPolicy>;
+    readonly maximumBytes: number;
+}
+export declare class PublicationDiscovery {
+    private readonly options;
+    private publication;
+    private revision;
+    constructor(options: PublicationDiscoveryOptions);
+    current(): publication.Publication | undefined;
+    revalidate(operation: SessionOperation): Promise<publication.Publication>;
+    invalidate(): void;
+    private fetch;
+}
+export declare function boundedResponse(response: Response, maximum: number, signal: AbortSignal): Promise<Uint8Array>;
+export declare function requireExactResponse(response: Response, expected: string, label: string): void;