@the-open-engine/zeroshot 6.28.0 → 6.29.1

package/lib/hosted-session/reconnecting-watch.cjs

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReconnectingHostedWatch = void 0;
+const errors_js_1 = require("./errors.cjs");
+class ReconnectingHostedWatch {
+    #replace;
+    #ownedController = new AbortController();
+    #signal;
+    #session;
+    #subscription;
+    #tail = Promise.resolve();
+    #replacementPromise;
+    #cancelPromise;
+    #reconnected = false;
+    #cancelled = false;
+    constructor(replace, session, subscription, signal) {
+        this.#replace = replace;
+        this.#session = session;
+        this.#subscription = subscription;
+        this.#signal = signal === undefined
+            ? this.#ownedController.signal
+            : AbortSignal.any([signal, this.#ownedController.signal]);
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    next() {
+        const result = this.#tail.then(() => this.#readNext());
+        this.#tail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async #readNext() {
+        while (!this.#cancelled) {
+            const item = await this.#subscription.stream.next();
+            if (this.#cancelled)
+                return { done: true, value: undefined };
+            if (!item.done)
+                return item;
+            return this.#handleClosed(item);
+        }
+        return { done: true, value: undefined };
+    }
+    async #handleClosed(item) {
+        if (this.#session.connection.state === 'OPEN') {
+            await this.#session.connection.close();
+            return item;
+        }
+        const { code } = await this.#session.connection.closed;
+        if (code === 4401)
+            return this.#reconnect();
+        if (code === 4403)
+            throw new errors_js_1.HostedAuthorizationError();
+        if (code === 1000)
+            return item;
+        throw new errors_js_1.HostedTransportUncertainError();
+    }
+    async #reconnect() {
+        if (this.#reconnected)
+            throw new errors_js_1.HostedTransportUncertainError();
+        this.#reconnected = true;
+        const replacementPromise = this.#replace(this.#signal);
+        this.#replacementPromise = replacementPromise;
+        let replacement;
+        try {
+            replacement = await replacementPromise;
+        }
+        catch (error) {
+            if (this.#cancelled)
+                return { done: true, value: undefined };
+            throw error;
+        }
+        finally {
+            if (this.#replacementPromise === replacementPromise) {
+                this.#replacementPromise = undefined;
+            }
+        }
+        return this.#installReplacement(replacement);
+    }
+    async #installReplacement(replacement) {
+        if (this.#cancelled) {
+            await replacement.connection.close();
+            return { done: true, value: undefined };
+        }
+        try {
+            const subscription = await this.#subscription.stream.reconnect(replacement.connection);
+            if (this.#cancelled) {
+                await subscription.stream.cancel();
+                await replacement.connection.close();
+                return { done: true, value: undefined };
+            }
+            this.#subscription = subscription;
+            this.#session = replacement;
+            return this.#readNext();
+        }
+        catch (error) {
+            await replacement.connection.close();
+            if (this.#cancelled)
+                return { done: true, value: undefined };
+            throw error;
+        }
+    }
+    async return() {
+        await this.cancel();
+        return { done: true, value: undefined };
+    }
+    async throw(error) {
+        await this.cancel();
+        throw error;
+    }
+    cancel() {
+        this.#cancelPromise ??= this.#cancelOwned();
+        return this.#cancelPromise;
+    }
+    async #cancelOwned() {
+        this.#cancelled = true;
+        this.#ownedController.abort(new DOMException('hosted watch cancelled', 'AbortError'));
+        const replacement = this.#replacementPromise;
+        const outcomes = await Promise.allSettled([
+            this.#subscription.stream.cancel(),
+            this.#session.connection.close(),
+            ...(replacement === undefined
+                ? []
+                : [replacement.then(() => undefined, () => undefined)]),
+        ]);
+        await this.#tail;
+        const failure = outcomes.find((outcome) => outcome.status === 'rejected');
+        if (failure !== undefined)
+            throw failure.reason;
+    }
+}
+exports.ReconnectingHostedWatch = ReconnectingHostedWatch;

package/lib/hosted-session/reconnecting-watch.d.cts

@@ -0,0 +1,13 @@
+import type { WatchSubscription, WatchSubscriptionItem } from '../cluster/index.js';
+import type { HostedWatch, InitializedSession } from './types.js';
+type ReplaceSession = (signal: AbortSignal) => Promise<InitializedSession>;
+export declare class ReconnectingHostedWatch implements HostedWatch {
+    #private;
+    constructor(replace: ReplaceSession, session: InitializedSession, subscription: WatchSubscription, signal?: AbortSignal);
+    [Symbol.asyncIterator](): this;
+    next(): Promise<IteratorResult<WatchSubscriptionItem>>;
+    return(): Promise<IteratorResult<WatchSubscriptionItem>>;
+    throw(error?: unknown): Promise<IteratorResult<WatchSubscriptionItem>>;
+    cancel(): Promise<void>;
+}
+export {};

package/lib/hosted-session/reconnecting-watch.d.mts

@@ -0,0 +1,13 @@
+import type { WatchSubscription, WatchSubscriptionItem } from '../cluster/index.js';
+import type { HostedWatch, InitializedSession } from './types.js';
+type ReplaceSession = (signal: AbortSignal) => Promise<InitializedSession>;
+export declare class ReconnectingHostedWatch implements HostedWatch {
+    #private;
+    constructor(replace: ReplaceSession, session: InitializedSession, subscription: WatchSubscription, signal?: AbortSignal);
+    [Symbol.asyncIterator](): this;
+    next(): Promise<IteratorResult<WatchSubscriptionItem>>;
+    return(): Promise<IteratorResult<WatchSubscriptionItem>>;
+    throw(error?: unknown): Promise<IteratorResult<WatchSubscriptionItem>>;
+    cancel(): Promise<void>;
+}
+export {};

package/lib/hosted-session/reconnecting-watch.d.ts

@@ -0,0 +1,13 @@
+import type { WatchSubscription, WatchSubscriptionItem } from '../cluster/index.js';
+import type { HostedWatch, InitializedSession } from './types.js';
+type ReplaceSession = (signal: AbortSignal) => Promise<InitializedSession>;
+export declare class ReconnectingHostedWatch implements HostedWatch {
+    #private;
+    constructor(replace: ReplaceSession, session: InitializedSession, subscription: WatchSubscription, signal?: AbortSignal);
+    [Symbol.asyncIterator](): this;
+    next(): Promise<IteratorResult<WatchSubscriptionItem>>;
+    return(): Promise<IteratorResult<WatchSubscriptionItem>>;
+    throw(error?: unknown): Promise<IteratorResult<WatchSubscriptionItem>>;
+    cancel(): Promise<void>;
+}
+export {};

package/lib/hosted-session/reconnecting-watch.mjs

@@ -0,0 +1,127 @@
+import { HostedAuthorizationError, HostedTransportUncertainError, } from './errors.mjs';
+export class ReconnectingHostedWatch {
+    #replace;
+    #ownedController = new AbortController();
+    #signal;
+    #session;
+    #subscription;
+    #tail = Promise.resolve();
+    #replacementPromise;
+    #cancelPromise;
+    #reconnected = false;
+    #cancelled = false;
+    constructor(replace, session, subscription, signal) {
+        this.#replace = replace;
+        this.#session = session;
+        this.#subscription = subscription;
+        this.#signal = signal === undefined
+            ? this.#ownedController.signal
+            : AbortSignal.any([signal, this.#ownedController.signal]);
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    next() {
+        const result = this.#tail.then(() => this.#readNext());
+        this.#tail = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async #readNext() {
+        while (!this.#cancelled) {
+            const item = await this.#subscription.stream.next();
+            if (this.#cancelled)
+                return { done: true, value: undefined };
+            if (!item.done)
+                return item;
+            return this.#handleClosed(item);
+        }
+        return { done: true, value: undefined };
+    }
+    async #handleClosed(item) {
+        if (this.#session.connection.state === 'OPEN') {
+            await this.#session.connection.close();
+            return item;
+        }
+        const { code } = await this.#session.connection.closed;
+        if (code === 4401)
+            return this.#reconnect();
+        if (code === 4403)
+            throw new HostedAuthorizationError();
+        if (code === 1000)
+            return item;
+        throw new HostedTransportUncertainError();
+    }
+    async #reconnect() {
+        if (this.#reconnected)
+            throw new HostedTransportUncertainError();
+        this.#reconnected = true;
+        const replacementPromise = this.#replace(this.#signal);
+        this.#replacementPromise = replacementPromise;
+        let replacement;
+        try {
+            replacement = await replacementPromise;
+        }
+        catch (error) {
+            if (this.#cancelled)
+                return { done: true, value: undefined };
+            throw error;
+        }
+        finally {
+            if (this.#replacementPromise === replacementPromise) {
+                this.#replacementPromise = undefined;
+            }
+        }
+        return this.#installReplacement(replacement);
+    }
+    async #installReplacement(replacement) {
+        if (this.#cancelled) {
+            await replacement.connection.close();
+            return { done: true, value: undefined };
+        }
+        try {
+            const subscription = await this.#subscription.stream.reconnect(replacement.connection);
+            if (this.#cancelled) {
+                await subscription.stream.cancel();
+                await replacement.connection.close();
+                return { done: true, value: undefined };
+            }
+            this.#subscription = subscription;
+            this.#session = replacement;
+            return this.#readNext();
+        }
+        catch (error) {
+            await replacement.connection.close();
+            if (this.#cancelled)
+                return { done: true, value: undefined };
+            throw error;
+        }
+    }
+    async return() {
+        await this.cancel();
+        return { done: true, value: undefined };
+    }
+    async throw(error) {
+        await this.cancel();
+        throw error;
+    }
+    cancel() {
+        this.#cancelPromise ??= this.#cancelOwned();
+        return this.#cancelPromise;
+    }
+    async #cancelOwned() {
+        this.#cancelled = true;
+        this.#ownedController.abort(new DOMException('hosted watch cancelled', 'AbortError'));
+        const replacement = this.#replacementPromise;
+        const outcomes = await Promise.allSettled([
+            this.#subscription.stream.cancel(),
+            this.#session.connection.close(),
+            ...(replacement === undefined
+                ? []
+                : [replacement.then(() => undefined, () => undefined)]),
+        ]);
+        await this.#tail;
+        const failure = outcomes.find((outcome) => outcome.status === 'rejected');
+        if (failure !== undefined)
+            throw failure.reason;
+    }
+}

package/lib/hosted-session/types.d.cts

@@ -0,0 +1,32 @@
+import type { Connection, ClusterClient, ConnectOptions, InitializeResult, WatchParams, WatchSubscriptionItem } from '../cluster/index.js';
+export interface HostedAccess {
+    readonly protocol: 'openengine.cluster/v1';
+    readonly websocketUrl: string;
+    readonly accessToken: string;
+    readonly tokenType: 'Bearer';
+    readonly expiresAt: string;
+}
+export interface HostedAccessAdapter {
+    access(capsuleId: string, signal?: AbortSignal): Promise<HostedAccess>;
+}
+export interface HostedSessionInit {
+    readonly adapter: HostedAccessAdapter;
+    readonly capsuleId: string;
+    readonly targetAuthority: string;
+    readonly connectOptions?: Omit<ConnectOptions, 'headers' | 'signal'>;
+    readonly clock?: {
+        now(): number;
+    };
+}
+export interface InitializedSession {
+    readonly connection: Connection;
+    readonly client: ClusterClient;
+    readonly initializeResult: InitializeResult;
+}
+export interface HostedWatch extends AsyncIterator<WatchSubscriptionItem>, AsyncIterable<WatchSubscriptionItem> {
+    cancel(): Promise<void>;
+}
+export interface HostedWatchOptions {
+    readonly params: WatchParams;
+    readonly signal?: AbortSignal;
+}

package/lib/hosted-session/types.d.mts

@@ -0,0 +1,32 @@
+import type { Connection, ClusterClient, ConnectOptions, InitializeResult, WatchParams, WatchSubscriptionItem } from '../cluster/index.js';
+export interface HostedAccess {
+    readonly protocol: 'openengine.cluster/v1';
+    readonly websocketUrl: string;
+    readonly accessToken: string;
+    readonly tokenType: 'Bearer';
+    readonly expiresAt: string;
+}
+export interface HostedAccessAdapter {
+    access(capsuleId: string, signal?: AbortSignal): Promise<HostedAccess>;
+}
+export interface HostedSessionInit {
+    readonly adapter: HostedAccessAdapter;
+    readonly capsuleId: string;
+    readonly targetAuthority: string;
+    readonly connectOptions?: Omit<ConnectOptions, 'headers' | 'signal'>;
+    readonly clock?: {
+        now(): number;
+    };
+}
+export interface InitializedSession {
+    readonly connection: Connection;
+    readonly client: ClusterClient;
+    readonly initializeResult: InitializeResult;
+}
+export interface HostedWatch extends AsyncIterator<WatchSubscriptionItem>, AsyncIterable<WatchSubscriptionItem> {
+    cancel(): Promise<void>;
+}
+export interface HostedWatchOptions {
+    readonly params: WatchParams;
+    readonly signal?: AbortSignal;
+}

package/lib/hosted-session/types.d.ts

@@ -1,13 +1,18 @@
-import type { Connection } from '../cluster/index.js';
-import type { ClusterClient, ConnectOptions } from '../cluster/index.js';
-import type { InitializeResult } from '../cluster/index.js';
-export interface AccessResponse {
-    readonly endpoint: string;
-    readonly token: string;
+import type { Connection, ClusterClient, ConnectOptions, InitializeResult, WatchParams, WatchSubscriptionItem } from '../cluster/index.js';
+export interface HostedAccess {
+    readonly protocol: 'openengine.cluster/v1';
+    readonly websocketUrl: string;
+    readonly accessToken: string;
+    readonly tokenType: 'Bearer';
     readonly expiresAt: string;
 }
+export interface HostedAccessAdapter {
+    access(capsuleId: string, signal?: AbortSignal): Promise<HostedAccess>;
+}
 export interface HostedSessionInit {
-    readonly getAccess: (signal?: AbortSignal) => Promise<AccessResponse>;
+    readonly adapter: HostedAccessAdapter;
+    readonly capsuleId: string;
+    readonly targetAuthority: string;
     readonly connectOptions?: Omit<ConnectOptions, 'headers' | 'signal'>;
     readonly clock?: {
         now(): number;
@@ -18,3 +23,10 @@ export interface InitializedSession {
     readonly client: ClusterClient;
     readonly initializeResult: InitializeResult;
 }
+export interface HostedWatch extends AsyncIterator<WatchSubscriptionItem>, AsyncIterable<WatchSubscriptionItem> {
+    cancel(): Promise<void>;
+}
+export interface HostedWatchOptions {
+    readonly params: WatchParams;
+    readonly signal?: AbortSignal;
+}

package/lib/hosted-target/access-url.cjs

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAccessUrl = validateAccessUrl;
+const errors_js_1 = require("./errors.cjs");
+function hasForbiddenCodePoint(value) {
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint <= 0x20 || codePoint === 0x7f)
+            return true;
+    }
+    return false;
+}
+function parseAccessUrl(value) {
+    try {
+        if (hasForbiddenCodePoint(value))
+            throw new TypeError('unsafe URL code point');
+        const url = new globalThis.URL(value);
+        if (url.href !== value)
+            throw new TypeError('non-canonical URL');
+        return url;
+    }
+    catch {
+        throw new errors_js_1.TargetProtocolError('Capsule access WebSocket URL is invalid');
+    }
+}
+function matchesAccessRoute(url, target, expectedPath) {
+    const expectedProtocol = target.protocol === 'http:' ? 'ws:' : 'wss:';
+    return url.protocol === expectedProtocol &&
+        url.host === target.host &&
+        !url.username &&
+        !url.password &&
+        !url.search &&
+        !url.hash &&
+        url.pathname === expectedPath;
+}
+function validateAccessUrl(value, capsuleId, descriptor) {
+    const url = parseAccessUrl(value);
+    const expectedPath = descriptor.transport.websocketRouteTemplate.expand({
+        capsule_id: capsuleId,
+    });
+    if (!matchesAccessRoute(url, new globalThis.URL(descriptor.origin), expectedPath)) {
+        throw new errors_js_1.TargetProtocolError('Capsule access WebSocket URL does not match discovery');
+    }
+}

package/lib/hosted-target/access-url.d.cts

@@ -0,0 +1,2 @@
+import type { TargetDiscoveryDescriptor } from '../target/discovery.js';
+export declare function validateAccessUrl(value: string, capsuleId: string, descriptor: TargetDiscoveryDescriptor): void;

package/lib/hosted-target/access-url.d.mts

@@ -0,0 +1,2 @@
+import type { TargetDiscoveryDescriptor } from '../target/discovery.js';
+export declare function validateAccessUrl(value: string, capsuleId: string, descriptor: TargetDiscoveryDescriptor): void;

package/lib/hosted-target/access-url.d.ts

@@ -0,0 +1,2 @@
+import type { TargetDiscoveryDescriptor } from '../target/discovery.js';
+export declare function validateAccessUrl(value: string, capsuleId: string, descriptor: TargetDiscoveryDescriptor): void;

package/lib/hosted-target/access-url.mjs

@@ -0,0 +1,41 @@
+import { TargetProtocolError } from './errors.mjs';
+function hasForbiddenCodePoint(value) {
+    for (const character of value) {
+        const codePoint = character.codePointAt(0);
+        if (codePoint <= 0x20 || codePoint === 0x7f)
+            return true;
+    }
+    return false;
+}
+function parseAccessUrl(value) {
+    try {
+        if (hasForbiddenCodePoint(value))
+            throw new TypeError('unsafe URL code point');
+        const url = new globalThis.URL(value);
+        if (url.href !== value)
+            throw new TypeError('non-canonical URL');
+        return url;
+    }
+    catch {
+        throw new TargetProtocolError('Capsule access WebSocket URL is invalid');
+    }
+}
+function matchesAccessRoute(url, target, expectedPath) {
+    const expectedProtocol = target.protocol === 'http:' ? 'ws:' : 'wss:';
+    return url.protocol === expectedProtocol &&
+        url.host === target.host &&
+        !url.username &&
+        !url.password &&
+        !url.search &&
+        !url.hash &&
+        url.pathname === expectedPath;
+}
+export function validateAccessUrl(value, capsuleId, descriptor) {
+    const url = parseAccessUrl(value);
+    const expectedPath = descriptor.transport.websocketRouteTemplate.expand({
+        capsule_id: capsuleId,
+    });
+    if (!matchesAccessRoute(url, new globalThis.URL(descriptor.origin), expectedPath)) {
+        throw new TargetProtocolError('Capsule access WebSocket URL does not match discovery');
+    }
+}

package/lib/hosted-target/adapter-request.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestUrl = requestUrl;
+const errors_js_1 = require("./errors.cjs");
+function requestUrl(path, descriptor) {
+    const url = new globalThis.URL(path, descriptor.capsule.baseUrl);
+    if (url.origin !== descriptor.origin || url.hash ||
+        `${url.pathname}${url.search}` !== path) {
+        throw new errors_js_1.TargetProtocolError('Capsule route changed during URL canonicalization');
+    }
+    return url;
+}

package/lib/hosted-target/adapter-request.d.cts

@@ -0,0 +1,17 @@
+import type { RouteTemplate, TargetDiscoveryDescriptor } from '../target/discovery.js';
+import type { TargetOperation } from './retry-executor.js';
+export type AdapterRequest = {
+    readonly body?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+};
+export type ExecuteArguments<T> = [
+    operation: TargetOperation,
+    method: string,
+    template: RouteTemplate,
+    values: Readonly<Record<string, string | number | undefined>>,
+    expectedStatus: number,
+    validate: (body: unknown) => T,
+    signal?: AbortSignal,
+    request?: AdapterRequest
+];
+export declare function requestUrl(path: string, descriptor: TargetDiscoveryDescriptor): URL;

package/lib/hosted-target/adapter-request.d.mts

@@ -0,0 +1,17 @@
+import type { RouteTemplate, TargetDiscoveryDescriptor } from '../target/discovery.js';
+import type { TargetOperation } from './retry-executor.js';
+export type AdapterRequest = {
+    readonly body?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+};
+export type ExecuteArguments<T> = [
+    operation: TargetOperation,
+    method: string,
+    template: RouteTemplate,
+    values: Readonly<Record<string, string | number | undefined>>,
+    expectedStatus: number,
+    validate: (body: unknown) => T,
+    signal?: AbortSignal,
+    request?: AdapterRequest
+];
+export declare function requestUrl(path: string, descriptor: TargetDiscoveryDescriptor): URL;

package/lib/hosted-target/adapter-request.d.ts

@@ -0,0 +1,17 @@
+import type { RouteTemplate, TargetDiscoveryDescriptor } from '../target/discovery.js';
+import type { TargetOperation } from './retry-executor.js';
+export type AdapterRequest = {
+    readonly body?: string;
+    readonly headers?: Readonly<Record<string, string>>;
+};
+export type ExecuteArguments<T> = [
+    operation: TargetOperation,
+    method: string,
+    template: RouteTemplate,
+    values: Readonly<Record<string, string | number | undefined>>,
+    expectedStatus: number,
+    validate: (body: unknown) => T,
+    signal?: AbortSignal,
+    request?: AdapterRequest
+];
+export declare function requestUrl(path: string, descriptor: TargetDiscoveryDescriptor): URL;

package/lib/hosted-target/adapter-request.mjs

@@ -0,0 +1,9 @@
+import { TargetProtocolError } from './errors.mjs';
+export function requestUrl(path, descriptor) {
+    const url = new globalThis.URL(path, descriptor.capsule.baseUrl);
+    if (url.origin !== descriptor.origin || url.hash ||
+        `${url.pathname}${url.search}` !== path) {
+        throw new TargetProtocolError('Capsule route changed during URL canonicalization');
+    }
+    return url;
+}

package/lib/hosted-target/adapter-types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/hosted-target/adapter-types.d.cts

@@ -0,0 +1,27 @@
+import type { TargetDiscoveryDescriptor } from '../target/discovery.js';
+import type { AllocateRequest, Capsule, CapsuleAccess, CapsuleLimits, CapsuleListPage, Clock, HttpTransport, ListRequest, RetryPolicy, TargetAccessTokenProvider } from './types.js';
+export type CredentialInstallCapability = {
+    readonly supported: false;
+} | {
+    readonly supported: true;
+    readonly descriptor: NonNullable<TargetDiscoveryDescriptor['credentialInstall']>;
+};
+export interface TargetAdapter {
+    allocate(req: AllocateRequest, signal?: AbortSignal): Promise<Capsule>;
+    list(req?: ListRequest, signal?: AbortSignal): Promise<CapsuleListPage>;
+    inspect(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
+    terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
+    limits(signal?: AbortSignal): Promise<CapsuleLimits>;
+    access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+    readonly credentialInstall: CredentialInstallCapability;
+}
+export interface CreateTargetAdapterOptions {
+    readonly descriptor: TargetDiscoveryDescriptor;
+    readonly organization: {
+        readonly id: string;
+    };
+    readonly tokenProvider: TargetAccessTokenProvider;
+    readonly transport?: HttpTransport;
+    readonly clock?: Clock;
+    readonly retryPolicy?: RetryPolicy;
+}

package/lib/hosted-target/adapter-types.d.mts

@@ -0,0 +1,27 @@
+import type { TargetDiscoveryDescriptor } from '../target/discovery.js';
+import type { AllocateRequest, Capsule, CapsuleAccess, CapsuleLimits, CapsuleListPage, Clock, HttpTransport, ListRequest, RetryPolicy, TargetAccessTokenProvider } from './types.js';
+export type CredentialInstallCapability = {
+    readonly supported: false;
+} | {
+    readonly supported: true;
+    readonly descriptor: NonNullable<TargetDiscoveryDescriptor['credentialInstall']>;
+};
+export interface TargetAdapter {
+    allocate(req: AllocateRequest, signal?: AbortSignal): Promise<Capsule>;
+    list(req?: ListRequest, signal?: AbortSignal): Promise<CapsuleListPage>;
+    inspect(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
+    terminate(capsuleId: string, signal?: AbortSignal): Promise<Capsule>;
+    limits(signal?: AbortSignal): Promise<CapsuleLimits>;
+    access(capsuleId: string, signal?: AbortSignal): Promise<CapsuleAccess>;
+    readonly credentialInstall: CredentialInstallCapability;
+}
+export interface CreateTargetAdapterOptions {
+    readonly descriptor: TargetDiscoveryDescriptor;
+    readonly organization: {
+        readonly id: string;
+    };
+    readonly tokenProvider: TargetAccessTokenProvider;
+    readonly transport?: HttpTransport;
+    readonly clock?: Clock;
+    readonly retryPolicy?: RetryPolicy;
+}