@the-open-engine/zeroshot 6.28.0 → 6.29.1

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTargetAdapter = createTargetAdapter;
+const zero_cloud_v1_adapter_js_1 = require("./zero-cloud-v1-adapter.cjs");
+function createTargetAdapter(options) {
+    if (options.descriptor.adapter.majorVersion !== 1) {
+        throw new Error('Unsupported hosted target adapter version');
+    }
+    return new zero_cloud_v1_adapter_js_1.ZeroCloudV1TargetAdapter(options);
+}

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

@@ -0,0 +1,3 @@
+import type { CreateTargetAdapterOptions, TargetAdapter } from './adapter-types.js';
+export type { CreateTargetAdapterOptions, CredentialInstallCapability, TargetAdapter, } from './adapter-types.js';
+export declare function createTargetAdapter(options: CreateTargetAdapterOptions): TargetAdapter;

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

@@ -0,0 +1,3 @@
+import type { CreateTargetAdapterOptions, TargetAdapter } from './adapter-types.js';
+export type { CreateTargetAdapterOptions, CredentialInstallCapability, TargetAdapter, } from './adapter-types.js';
+export declare function createTargetAdapter(options: CreateTargetAdapterOptions): TargetAdapter;

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

@@ -0,0 +1,3 @@
+import type { CreateTargetAdapterOptions, TargetAdapter } from './adapter-types.js';
+export type { CreateTargetAdapterOptions, CredentialInstallCapability, TargetAdapter, } from './adapter-types.js';
+export declare function createTargetAdapter(options: CreateTargetAdapterOptions): TargetAdapter;

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

@@ -0,0 +1,7 @@
+import { ZeroCloudV1TargetAdapter } from './zero-cloud-v1-adapter.mjs';
+export function createTargetAdapter(options) {
+    if (options.descriptor.adapter.majorVersion !== 1) {
+        throw new Error('Unsupported hosted target adapter version');
+    }
+    return new ZeroCloudV1TargetAdapter(options);
+}

package/lib/hosted-target/types.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_CAPSULE_STATES = void 0;
+exports.KNOWN_CAPSULE_STATES = ['provisioning', 'ready', 'terminating', 'terminated', 'failed'];

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

@@ -0,0 +1,50 @@
+import type { TargetAdapterError } from './errors.js';
+export interface TargetAccessTokenProvider {
+    getAccessToken(signal?: AbortSignal): Promise<string>;
+}
+export type CapsuleState = 'provisioning' | 'ready' | 'terminating' | 'terminated' | 'failed';
+export declare const KNOWN_CAPSULE_STATES: readonly ["provisioning", "ready", "terminating", "terminated", "failed"];
+export interface Capsule {
+    readonly id: string;
+    readonly state: CapsuleState;
+    readonly label: string | null;
+    readonly createdAt: string;
+}
+export interface CapsuleAccess {
+    readonly protocol: 'openengine.cluster/v1';
+    readonly websocketUrl: string;
+    readonly accessToken: string;
+    readonly tokenType: 'Bearer';
+    readonly expiresAt: string;
+}
+export interface CapsuleListPage {
+    readonly capsules: readonly Capsule[];
+    readonly nextCursor: string | null;
+}
+export interface CapsuleLimits {
+    readonly activeCapsules: number;
+    readonly maxActiveCapsules: number | null;
+}
+export interface AllocateRequest {
+    readonly idempotencyKey: string;
+    readonly label?: string;
+    readonly size?: 'tiny' | 'small' | 'standard' | 'large';
+}
+export interface ListRequest {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface HttpTransport {
+    fetch(url: string, init: RequestInit & {
+        redirect: 'manual';
+    }): Promise<Response>;
+}
+export interface Clock {
+    now(): number;
+}
+export interface RetryPolicy {
+    shouldRetry(attempt: number, elapsed: number, error: TargetAdapterError): {
+        retry: boolean;
+        delayMs: number;
+    };
+}

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

@@ -0,0 +1,50 @@
+import type { TargetAdapterError } from './errors.js';
+export interface TargetAccessTokenProvider {
+    getAccessToken(signal?: AbortSignal): Promise<string>;
+}
+export type CapsuleState = 'provisioning' | 'ready' | 'terminating' | 'terminated' | 'failed';
+export declare const KNOWN_CAPSULE_STATES: readonly ["provisioning", "ready", "terminating", "terminated", "failed"];
+export interface Capsule {
+    readonly id: string;
+    readonly state: CapsuleState;
+    readonly label: string | null;
+    readonly createdAt: string;
+}
+export interface CapsuleAccess {
+    readonly protocol: 'openengine.cluster/v1';
+    readonly websocketUrl: string;
+    readonly accessToken: string;
+    readonly tokenType: 'Bearer';
+    readonly expiresAt: string;
+}
+export interface CapsuleListPage {
+    readonly capsules: readonly Capsule[];
+    readonly nextCursor: string | null;
+}
+export interface CapsuleLimits {
+    readonly activeCapsules: number;
+    readonly maxActiveCapsules: number | null;
+}
+export interface AllocateRequest {
+    readonly idempotencyKey: string;
+    readonly label?: string;
+    readonly size?: 'tiny' | 'small' | 'standard' | 'large';
+}
+export interface ListRequest {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface HttpTransport {
+    fetch(url: string, init: RequestInit & {
+        redirect: 'manual';
+    }): Promise<Response>;
+}
+export interface Clock {
+    now(): number;
+}
+export interface RetryPolicy {
+    shouldRetry(attempt: number, elapsed: number, error: TargetAdapterError): {
+        retry: boolean;
+        delayMs: number;
+    };
+}

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

@@ -0,0 +1,50 @@
+import type { TargetAdapterError } from './errors.js';
+export interface TargetAccessTokenProvider {
+    getAccessToken(signal?: AbortSignal): Promise<string>;
+}
+export type CapsuleState = 'provisioning' | 'ready' | 'terminating' | 'terminated' | 'failed';
+export declare const KNOWN_CAPSULE_STATES: readonly ["provisioning", "ready", "terminating", "terminated", "failed"];
+export interface Capsule {
+    readonly id: string;
+    readonly state: CapsuleState;
+    readonly label: string | null;
+    readonly createdAt: string;
+}
+export interface CapsuleAccess {
+    readonly protocol: 'openengine.cluster/v1';
+    readonly websocketUrl: string;
+    readonly accessToken: string;
+    readonly tokenType: 'Bearer';
+    readonly expiresAt: string;
+}
+export interface CapsuleListPage {
+    readonly capsules: readonly Capsule[];
+    readonly nextCursor: string | null;
+}
+export interface CapsuleLimits {
+    readonly activeCapsules: number;
+    readonly maxActiveCapsules: number | null;
+}
+export interface AllocateRequest {
+    readonly idempotencyKey: string;
+    readonly label?: string;
+    readonly size?: 'tiny' | 'small' | 'standard' | 'large';
+}
+export interface ListRequest {
+    readonly cursor?: string;
+    readonly limit?: number;
+}
+export interface HttpTransport {
+    fetch(url: string, init: RequestInit & {
+        redirect: 'manual';
+    }): Promise<Response>;
+}
+export interface Clock {
+    now(): number;
+}
+export interface RetryPolicy {
+    shouldRetry(attempt: number, elapsed: number, error: TargetAdapterError): {
+        retry: boolean;
+        delayMs: number;
+    };
+}

package/lib/hosted-target/types.mjs

@@ -0,0 +1 @@
+export const KNOWN_CAPSULE_STATES = ['provisioning', 'ready', 'terminating', 'terminated', 'failed'];

package/lib/hosted-target/zero-cloud-v1-adapter.cjs

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZeroCloudV1TargetAdapter = void 0;
+const bounds_js_1 = require("./bounds.cjs");
+const errors_js_1 = require("./errors.cjs");
+const retry_js_1 = require("./retry.cjs");
+const response_validation_js_1 = require("./response-validation.cjs");
+const bounded_response_js_1 = require("../target/bounded-response.cjs");
+const capsule_error_response_js_1 = require("./capsule-error-response.cjs");
+const access_url_js_1 = require("./access-url.cjs");
+const retry_executor_js_1 = require("./retry-executor.cjs");
+const adapter_request_js_1 = require("./adapter-request.cjs");
+const DEFAULT_TRANSPORT = {
+    fetch(url, init) {
+        return globalThis.fetch(url, init);
+    },
+};
+const DEFAULT_CLOCK = { now: () => Date.now() };
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
+}
+function validOpaque(value, field) {
+    if (value.length === 0 || value.length > 1024)
+        throw new errors_js_1.TargetProtocolError(`${field} is invalid`);
+}
+function jsonRequest(body) {
+    return JSON.stringify(body);
+}
+class ZeroCloudV1TargetAdapter {
+    #descriptor;
+    #organizationId;
+    #tokenProvider;
+    #transport;
+    #clock;
+    #retryPolicy;
+    constructor(options) {
+        this.#descriptor = options.descriptor;
+        this.#organizationId = options.organization.id;
+        validOpaque(this.#organizationId, 'organization id');
+        this.#tokenProvider = options.tokenProvider;
+        this.#transport = options.transport ?? DEFAULT_TRANSPORT;
+        this.#clock = options.clock ?? DEFAULT_CLOCK;
+        this.#retryPolicy = options.retryPolicy ?? new retry_js_1.DefaultRetryPolicy();
+    }
+    get credentialInstall() {
+        const descriptor = this.#descriptor.credentialInstall;
+        return descriptor === null
+            ? Object.freeze({ supported: false })
+            : Object.freeze({ supported: true, descriptor });
+    }
+    allocate(request, signal) {
+        try {
+            if (!bounds_js_1.IDEMPOTENCY_KEY_PATTERN.test(request.idempotencyKey))
+                throw new errors_js_1.TargetProtocolError('Idempotency key is invalid');
+            if (request.label !== undefined && (request.label.length < 1 || request.label.length > 100)) {
+                throw new errors_js_1.TargetProtocolError('Capsule label is outside the supported bounds');
+            }
+            if (request.size !== undefined && !this.#descriptor.sizes.catalog.includes(request.size)) {
+                throw new errors_js_1.TargetProtocolError('Capsule size is not advertised by the target');
+            }
+            const body = {
+                ...(request.label === undefined ? {} : { label: request.label }),
+                ...(request.size === undefined ? {} : { size: request.size }),
+            };
+            return this.#execute('allocate', 'POST', this.#descriptor.capsule.routes.allocate, { org_id: this.#organizationId }, 201, response_validation_js_1.assertCapsule, signal, {
+                body: jsonRequest(body),
+                headers: { 'Idempotency-Key': request.idempotencyKey },
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    async list(request = {}, signal) {
+        if (request.cursor !== undefined)
+            validOpaque(request.cursor, 'cursor');
+        if (request.limit !== undefined &&
+            (!Number.isSafeInteger(request.limit) ||
+                request.limit < 1 ||
+                request.limit > this.#descriptor.pagination.maxPageSize)) {
+            throw new errors_js_1.TargetProtocolError('Pagination limit is outside the advertised bounds');
+        }
+        const page = await this.#execute('list', 'GET', this.#descriptor.capsule.routes.list, {
+            org_id: this.#organizationId,
+            cursor: request.cursor,
+            limit: request.limit,
+        }, 200, response_validation_js_1.assertCapsuleListPage, signal);
+        if (request.cursor !== undefined && page.nextCursor === request.cursor)
+            throw new errors_js_1.TargetProtocolError('Target returned a pagination loop');
+        return page;
+    }
+    inspect(capsuleId, signal) {
+        validOpaque(capsuleId, 'capsule id');
+        return this.#execute('inspect', 'GET', this.#descriptor.capsule.routes.inspect, { org_id: this.#organizationId, capsule_id: capsuleId }, 200, response_validation_js_1.assertCapsule, signal);
+    }
+    terminate(capsuleId, signal) {
+        validOpaque(capsuleId, 'capsule id');
+        return this.#execute('terminate', 'DELETE', this.#descriptor.capsule.routes.terminate, { org_id: this.#organizationId, capsule_id: capsuleId }, 202, response_validation_js_1.assertCapsule, signal);
+    }
+    limits(signal) {
+        return this.#execute('limits', 'GET', this.#descriptor.capsule.routes.limits, { org_id: this.#organizationId }, 200, response_validation_js_1.assertCapsuleLimits, signal);
+    }
+    async access(capsuleId, signal) {
+        validOpaque(capsuleId, 'capsule id');
+        const result = await this.#execute('access', 'POST', this.#descriptor.capsule.routes.access, { capsule_id: capsuleId }, 200, response_validation_js_1.assertCapsuleAccess, signal, {
+            body: jsonRequest({ protocol: 'openengine.cluster/v1' }),
+        });
+        (0, access_url_js_1.validateAccessUrl)(result.websocketUrl, capsuleId, this.#descriptor);
+        return result;
+    }
+    #execute(...args) {
+        return Promise.resolve().then(() => this.#executeExpanded(args));
+    }
+    #executeExpanded(args) {
+        const [operation, method, template, values, expectedStatus, validate, signal, request = {},] = args;
+        let path;
+        try {
+            path = template.expand(values);
+        }
+        catch {
+            throw new errors_js_1.TargetProtocolError('Capsule route expansion is unsafe');
+        }
+        return (0, retry_executor_js_1.withTargetRetry)(operation, async () => {
+            const response = await this.#request(method, path, signal, request);
+            if (response.status >= 300 && response.status < 400) {
+                await response.body?.cancel().catch(() => undefined);
+                throw new errors_js_1.TargetProtocolError('Capsule redirects are forbidden');
+            }
+            if (response.status !== expectedStatus) {
+                if (response.status >= 200 && response.status < 300) {
+                    await response.body?.cancel().catch(() => undefined);
+                    throw new errors_js_1.TargetProtocolError('Target returned an unexpected success status');
+                }
+                await (0, capsule_error_response_js_1.throwCapsuleServerError)(response, (errorResponse) => this.#readJson(errorResponse), this.#clock);
+            }
+            return validate(await this.#readJson(response));
+        }, signal, { clock: this.#clock, policy: this.#retryPolicy });
+    }
+    async #request(method, path, signal, request) {
+        throwIfAborted(signal);
+        const url = (0, adapter_request_js_1.requestUrl)(path, this.#descriptor);
+        let token;
+        try {
+            token = await this.#tokenProvider.getAccessToken(signal);
+        }
+        catch {
+            throw new errors_js_1.TargetAuthError('Target access authorization failed');
+        }
+        const init = {
+            method,
+            headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${token}`,
+                ...(request.body === undefined ? {} : { 'Content-Type': 'application/json' }),
+                ...request.headers,
+            },
+            redirect: 'manual',
+        };
+        if (request.body !== undefined)
+            init.body = request.body;
+        if (signal !== undefined)
+            init.signal = signal;
+        try {
+            const response = await this.#transport.fetch(url.href, init);
+            if (response.url && new globalThis.URL(response.url).href !== url.href) {
+                await response.body?.cancel().catch(() => undefined);
+                throw new errors_js_1.TargetProtocolError('Capsule response changed target route');
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.TargetAdapterError)
+                throw error;
+            throwIfAborted(signal);
+            throw new errors_js_1.TargetTransportError('Capsule transport failed');
+        }
+    }
+    #readJson(response) {
+        return (0, bounded_response_js_1.readBoundedResponseJson)(response, bounds_js_1.MAX_RESPONSE_BYTES, (kind) => new errors_js_1.TargetProtocolError(kind === 'size'
+            ? 'Capsule response exceeds the size limit'
+            : 'Capsule response is not valid UTF-8 JSON'));
+    }
+}
+exports.ZeroCloudV1TargetAdapter = ZeroCloudV1TargetAdapter;

package/lib/hosted-target/zero-cloud-v1-adapter.d.cts

@@ -0,0 +1,13 @@
+import type { TargetAdapter, CreateTargetAdapterOptions } from './adapter-types.js';
+import type { AllocateRequest, Capsule, CapsuleAccess, CapsuleLimits, CapsuleListPage, ListRequest } from './types.js';
+export declare class ZeroCloudV1TargetAdapter implements TargetAdapter {
+    #private;
+    constructor(options: CreateTargetAdapterOptions);
+    get credentialInstall(): TargetAdapter['credentialInstall'];
+    allocate(request: AllocateRequest, signal?: AbortSignal): Promise<Capsule>;
+    list(request?: 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>;
+}

package/lib/hosted-target/zero-cloud-v1-adapter.d.mts

@@ -0,0 +1,13 @@
+import type { TargetAdapter, CreateTargetAdapterOptions } from './adapter-types.js';
+import type { AllocateRequest, Capsule, CapsuleAccess, CapsuleLimits, CapsuleListPage, ListRequest } from './types.js';
+export declare class ZeroCloudV1TargetAdapter implements TargetAdapter {
+    #private;
+    constructor(options: CreateTargetAdapterOptions);
+    get credentialInstall(): TargetAdapter['credentialInstall'];
+    allocate(request: AllocateRequest, signal?: AbortSignal): Promise<Capsule>;
+    list(request?: 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>;
+}

package/lib/hosted-target/zero-cloud-v1-adapter.d.ts

@@ -0,0 +1,13 @@
+import type { TargetAdapter, CreateTargetAdapterOptions } from './adapter-types.js';
+import type { AllocateRequest, Capsule, CapsuleAccess, CapsuleLimits, CapsuleListPage, ListRequest } from './types.js';
+export declare class ZeroCloudV1TargetAdapter implements TargetAdapter {
+    #private;
+    constructor(options: CreateTargetAdapterOptions);
+    get credentialInstall(): TargetAdapter['credentialInstall'];
+    allocate(request: AllocateRequest, signal?: AbortSignal): Promise<Capsule>;
+    list(request?: 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>;
+}

package/lib/hosted-target/zero-cloud-v1-adapter.mjs

@@ -0,0 +1,181 @@
+import { IDEMPOTENCY_KEY_PATTERN, MAX_RESPONSE_BYTES } from './bounds.mjs';
+import { TargetAdapterError, TargetAuthError, TargetProtocolError, TargetTransportError, } from './errors.mjs';
+import { DefaultRetryPolicy } from './retry.mjs';
+import { assertCapsule, assertCapsuleAccess, assertCapsuleLimits, assertCapsuleListPage, } from './response-validation.mjs';
+import { readBoundedResponseJson } from '../target/bounded-response.mjs';
+import { throwCapsuleServerError } from './capsule-error-response.mjs';
+import { validateAccessUrl } from './access-url.mjs';
+import { withTargetRetry } from './retry-executor.mjs';
+import { requestUrl, } from './adapter-request.mjs';
+const DEFAULT_TRANSPORT = {
+    fetch(url, init) {
+        return globalThis.fetch(url, init);
+    },
+};
+const DEFAULT_CLOCK = { now: () => Date.now() };
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
+}
+function validOpaque(value, field) {
+    if (value.length === 0 || value.length > 1024)
+        throw new TargetProtocolError(`${field} is invalid`);
+}
+function jsonRequest(body) {
+    return JSON.stringify(body);
+}
+export class ZeroCloudV1TargetAdapter {
+    #descriptor;
+    #organizationId;
+    #tokenProvider;
+    #transport;
+    #clock;
+    #retryPolicy;
+    constructor(options) {
+        this.#descriptor = options.descriptor;
+        this.#organizationId = options.organization.id;
+        validOpaque(this.#organizationId, 'organization id');
+        this.#tokenProvider = options.tokenProvider;
+        this.#transport = options.transport ?? DEFAULT_TRANSPORT;
+        this.#clock = options.clock ?? DEFAULT_CLOCK;
+        this.#retryPolicy = options.retryPolicy ?? new DefaultRetryPolicy();
+    }
+    get credentialInstall() {
+        const descriptor = this.#descriptor.credentialInstall;
+        return descriptor === null
+            ? Object.freeze({ supported: false })
+            : Object.freeze({ supported: true, descriptor });
+    }
+    allocate(request, signal) {
+        try {
+            if (!IDEMPOTENCY_KEY_PATTERN.test(request.idempotencyKey))
+                throw new TargetProtocolError('Idempotency key is invalid');
+            if (request.label !== undefined && (request.label.length < 1 || request.label.length > 100)) {
+                throw new TargetProtocolError('Capsule label is outside the supported bounds');
+            }
+            if (request.size !== undefined && !this.#descriptor.sizes.catalog.includes(request.size)) {
+                throw new TargetProtocolError('Capsule size is not advertised by the target');
+            }
+            const body = {
+                ...(request.label === undefined ? {} : { label: request.label }),
+                ...(request.size === undefined ? {} : { size: request.size }),
+            };
+            return this.#execute('allocate', 'POST', this.#descriptor.capsule.routes.allocate, { org_id: this.#organizationId }, 201, assertCapsule, signal, {
+                body: jsonRequest(body),
+                headers: { 'Idempotency-Key': request.idempotencyKey },
+            });
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    }
+    async list(request = {}, signal) {
+        if (request.cursor !== undefined)
+            validOpaque(request.cursor, 'cursor');
+        if (request.limit !== undefined &&
+            (!Number.isSafeInteger(request.limit) ||
+                request.limit < 1 ||
+                request.limit > this.#descriptor.pagination.maxPageSize)) {
+            throw new TargetProtocolError('Pagination limit is outside the advertised bounds');
+        }
+        const page = await this.#execute('list', 'GET', this.#descriptor.capsule.routes.list, {
+            org_id: this.#organizationId,
+            cursor: request.cursor,
+            limit: request.limit,
+        }, 200, assertCapsuleListPage, signal);
+        if (request.cursor !== undefined && page.nextCursor === request.cursor)
+            throw new TargetProtocolError('Target returned a pagination loop');
+        return page;
+    }
+    inspect(capsuleId, signal) {
+        validOpaque(capsuleId, 'capsule id');
+        return this.#execute('inspect', 'GET', this.#descriptor.capsule.routes.inspect, { org_id: this.#organizationId, capsule_id: capsuleId }, 200, assertCapsule, signal);
+    }
+    terminate(capsuleId, signal) {
+        validOpaque(capsuleId, 'capsule id');
+        return this.#execute('terminate', 'DELETE', this.#descriptor.capsule.routes.terminate, { org_id: this.#organizationId, capsule_id: capsuleId }, 202, assertCapsule, signal);
+    }
+    limits(signal) {
+        return this.#execute('limits', 'GET', this.#descriptor.capsule.routes.limits, { org_id: this.#organizationId }, 200, assertCapsuleLimits, signal);
+    }
+    async access(capsuleId, signal) {
+        validOpaque(capsuleId, 'capsule id');
+        const result = await this.#execute('access', 'POST', this.#descriptor.capsule.routes.access, { capsule_id: capsuleId }, 200, assertCapsuleAccess, signal, {
+            body: jsonRequest({ protocol: 'openengine.cluster/v1' }),
+        });
+        validateAccessUrl(result.websocketUrl, capsuleId, this.#descriptor);
+        return result;
+    }
+    #execute(...args) {
+        return Promise.resolve().then(() => this.#executeExpanded(args));
+    }
+    #executeExpanded(args) {
+        const [operation, method, template, values, expectedStatus, validate, signal, request = {},] = args;
+        let path;
+        try {
+            path = template.expand(values);
+        }
+        catch {
+            throw new TargetProtocolError('Capsule route expansion is unsafe');
+        }
+        return withTargetRetry(operation, async () => {
+            const response = await this.#request(method, path, signal, request);
+            if (response.status >= 300 && response.status < 400) {
+                await response.body?.cancel().catch(() => undefined);
+                throw new TargetProtocolError('Capsule redirects are forbidden');
+            }
+            if (response.status !== expectedStatus) {
+                if (response.status >= 200 && response.status < 300) {
+                    await response.body?.cancel().catch(() => undefined);
+                    throw new TargetProtocolError('Target returned an unexpected success status');
+                }
+                await throwCapsuleServerError(response, (errorResponse) => this.#readJson(errorResponse), this.#clock);
+            }
+            return validate(await this.#readJson(response));
+        }, signal, { clock: this.#clock, policy: this.#retryPolicy });
+    }
+    async #request(method, path, signal, request) {
+        throwIfAborted(signal);
+        const url = requestUrl(path, this.#descriptor);
+        let token;
+        try {
+            token = await this.#tokenProvider.getAccessToken(signal);
+        }
+        catch {
+            throw new TargetAuthError('Target access authorization failed');
+        }
+        const init = {
+            method,
+            headers: {
+                Accept: 'application/json',
+                Authorization: `Bearer ${token}`,
+                ...(request.body === undefined ? {} : { 'Content-Type': 'application/json' }),
+                ...request.headers,
+            },
+            redirect: 'manual',
+        };
+        if (request.body !== undefined)
+            init.body = request.body;
+        if (signal !== undefined)
+            init.signal = signal;
+        try {
+            const response = await this.#transport.fetch(url.href, init);
+            if (response.url && new globalThis.URL(response.url).href !== url.href) {
+                await response.body?.cancel().catch(() => undefined);
+                throw new TargetProtocolError('Capsule response changed target route');
+            }
+            return response;
+        }
+        catch (error) {
+            if (error instanceof TargetAdapterError)
+                throw error;
+            throwIfAborted(signal);
+            throw new TargetTransportError('Capsule transport failed');
+        }
+    }
+    #readJson(response) {
+        return readBoundedResponseJson(response, MAX_RESPONSE_BYTES, (kind) => new TargetProtocolError(kind === 'size'
+            ? 'Capsule response exceeds the size limit'
+            : 'Capsule response is not valid UTF-8 JSON'));
+    }
+}

package/lib/target/bounded-response.cjs

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readBoundedResponseJson = readBoundedResponseJson;
+async function declaredResponseBytes(response, maxBytes, error) {
+    const declared = response.headers.get('content-length');
+    if (declared === null)
+        return 0;
+    if (!/^\d+$/.test(declared) || Number(declared) > maxBytes) {
+        await response.body?.cancel().catch(() => undefined);
+        throw error('size');
+    }
+    return Number(declared);
+}
+function growBuffer(bytes, required, used, maxBytes) {
+    const capacity = Math.min(maxBytes, Math.max(required, Math.max(bytes.byteLength * 2, 8 * 1024)));
+    const grown = new Uint8Array(capacity);
+    grown.set(bytes.subarray(0, used));
+    return grown;
+}
+function decodeJson(bytes, error) {
+    try {
+        return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+    }
+    catch {
+        throw error('json');
+    }
+}
+async function readBoundedResponseJson(response, maxBytes, error) {
+    const declaredBytes = await declaredResponseBytes(response, maxBytes, error);
+    const reader = response.body?.getReader();
+    if (reader === undefined)
+        return decodeJson(new Uint8Array(), error);
+    let bytes = new Uint8Array(Math.min(maxBytes, Math.max(declaredBytes, 8 * 1024)));
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        const nextTotal = total + value.byteLength;
+        if (nextTotal > maxBytes) {
+            await reader.cancel().catch(() => undefined);
+            throw error('size');
+        }
+        if (nextTotal > bytes.byteLength) {
+            bytes = growBuffer(bytes, nextTotal, total, maxBytes);
+        }
+        bytes.set(value, total);
+        total = nextTotal;
+    }
+    return decodeJson(bytes.subarray(0, total), error);
+}

package/lib/target/bounded-response.d.cts

@@ -0,0 +1 @@
+export declare function readBoundedResponseJson(response: Response, maxBytes: number, error: (kind: 'size' | 'json') => Error): Promise<unknown>;

package/lib/target/bounded-response.d.mts

@@ -0,0 +1 @@
+export declare function readBoundedResponseJson(response: Response, maxBytes: number, error: (kind: 'size' | 'json') => Error): Promise<unknown>;