@the-open-engine/zeroshot 6.28.0 → 6.29.1

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

@@ -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.mjs

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

package/lib/hosted-target/bounds.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDEMPOTENCY_KEY_PATTERN = exports.MAX_ERROR_BODY_BYTES = exports.MAX_RETRY_ELAPSED_MS = exports.MAX_RETRY_ATTEMPTS = exports.MAX_PAGINATION_PAGES = exports.MAX_RESPONSE_BYTES = void 0;
+/** Shared wire limits for every hosted-target response and retry path. */
+exports.MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+exports.MAX_PAGINATION_PAGES = 100;
+exports.MAX_RETRY_ATTEMPTS = 3;
+exports.MAX_RETRY_ELAPSED_MS = 30_000;
+exports.MAX_ERROR_BODY_BYTES = 8192;
+exports.IDEMPOTENCY_KEY_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;

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

@@ -0,0 +1,7 @@
+/** Shared wire limits for every hosted-target response and retry path. */
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const MAX_PAGINATION_PAGES = 100;
+export declare const MAX_RETRY_ATTEMPTS = 3;
+export declare const MAX_RETRY_ELAPSED_MS = 30000;
+export declare const MAX_ERROR_BODY_BYTES = 8192;
+export declare const IDEMPOTENCY_KEY_PATTERN: RegExp;

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

@@ -0,0 +1,7 @@
+/** Shared wire limits for every hosted-target response and retry path. */
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const MAX_PAGINATION_PAGES = 100;
+export declare const MAX_RETRY_ATTEMPTS = 3;
+export declare const MAX_RETRY_ELAPSED_MS = 30000;
+export declare const MAX_ERROR_BODY_BYTES = 8192;
+export declare const IDEMPOTENCY_KEY_PATTERN: RegExp;

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

@@ -0,0 +1,7 @@
+/** Shared wire limits for every hosted-target response and retry path. */
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const MAX_PAGINATION_PAGES = 100;
+export declare const MAX_RETRY_ATTEMPTS = 3;
+export declare const MAX_RETRY_ELAPSED_MS = 30000;
+export declare const MAX_ERROR_BODY_BYTES = 8192;
+export declare const IDEMPOTENCY_KEY_PATTERN: RegExp;

package/lib/hosted-target/bounds.mjs

@@ -0,0 +1,7 @@
+/** Shared wire limits for every hosted-target response and retry path. */
+export const MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+export const MAX_PAGINATION_PAGES = 100;
+export const MAX_RETRY_ATTEMPTS = 3;
+export const MAX_RETRY_ELAPSED_MS = 30_000;
+export const MAX_ERROR_BODY_BYTES = 8192;
+export const IDEMPOTENCY_KEY_PATTERN = /^[a-zA-Z0-9_-]{1,128}$/;

package/lib/hosted-target/capsule-error-response.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwCapsuleServerError = throwCapsuleServerError;
+const errors_js_1 = require("./errors.cjs");
+const retry_js_1 = require("./retry.cjs");
+const ERROR_CODES = Object.freeze({
+    unauthorized: { statuses: [401], retryable: false },
+    invalid_request: { statuses: [400], retryable: false },
+    not_found: { statuses: [404], retryable: false },
+    forbidden: { statuses: [402, 403], retryable: false },
+    idempotency_conflict: { statuses: [409], retryable: false },
+    run_conflict: { statuses: [409], retryable: true },
+    rate_limited: { statuses: [429], retryable: true },
+    temporarily_unavailable: { statuses: [503], retryable: true },
+    internal_error: { statuses: [500], retryable: false },
+});
+function isErrorCode(value) {
+    return typeof value === 'string' && value in ERROR_CODES;
+}
+function isRecordBody(body) {
+    return body !== null && typeof body === 'object' && !Array.isArray(body);
+}
+function hasExactErrorFields(value) {
+    const fields = Object.keys(value);
+    const exactFields = ['code', 'message', 'capsule_id', 'retryable'];
+    return fields.length === exactFields.length &&
+        exactFields.every((field) => field in value);
+}
+function hasValidErrorValues(value) {
+    return isErrorCode(value.code) &&
+        typeof value.message === 'string' &&
+        (value.capsule_id === null || typeof value.capsule_id === 'string') &&
+        typeof value.retryable === 'boolean';
+}
+function parseErrorBody(body) {
+    if (!isRecordBody(body) || !hasExactErrorFields(body) || !hasValidErrorValues(body)) {
+        throw new errors_js_1.TargetProtocolError('Capsule error response is malformed');
+    }
+    const value = body;
+    return {
+        code: value.code,
+        capsuleId: value.capsule_id,
+        retryable: value.retryable,
+    };
+}
+function validateChallenge(response) {
+    if (response.status !== 401)
+        return;
+    if (response.headers.get('WWW-Authenticate') !== 'Bearer error="invalid_token"') {
+        throw new errors_js_1.TargetProtocolError('Capsule authentication challenge is malformed');
+    }
+}
+function validatedRetryAfter(response, retryable, clock) {
+    const header = response.headers.get('Retry-After');
+    const retryAfter = (0, retry_js_1.parseRetryAfter)(header, clock) ?? undefined;
+    if (header !== null && retryAfter === undefined) {
+        throw new errors_js_1.TargetProtocolError('Capsule Retry-After header is malformed');
+    }
+    if (retryable && retryAfter === undefined) {
+        throw new errors_js_1.TargetProtocolError('Retryable capsule error omitted Retry-After');
+    }
+    if (!retryable && retryAfter !== undefined) {
+        throw new errors_js_1.TargetProtocolError('Permanent capsule error advertised Retry-After');
+    }
+    return retryAfter;
+}
+async function throwCapsuleServerError(response, readJson, clock) {
+    const value = parseErrorBody(await readJson(response));
+    const contract = ERROR_CODES[value.code];
+    if (!contract.statuses.includes(response.status) || contract.retryable !== value.retryable) {
+        throw new errors_js_1.TargetProtocolError('Capsule error response contradicts its status contract');
+    }
+    validateChallenge(response);
+    const retryAfter = validatedRetryAfter(response, contract.retryable, clock);
+    throw new errors_js_1.TargetServerError(response.status, value.code, contract.retryable, value.capsuleId, retryAfter);
+}

package/lib/hosted-target/capsule-error-response.d.cts

@@ -0,0 +1,2 @@
+import type { Clock } from './types.js';
+export declare function throwCapsuleServerError(response: Response, readJson: (response: Response) => Promise<unknown>, clock: Clock): Promise<never>;

package/lib/hosted-target/capsule-error-response.d.mts

@@ -0,0 +1,2 @@
+import type { Clock } from './types.js';
+export declare function throwCapsuleServerError(response: Response, readJson: (response: Response) => Promise<unknown>, clock: Clock): Promise<never>;

package/lib/hosted-target/capsule-error-response.d.ts

@@ -0,0 +1,2 @@
+import type { Clock } from './types.js';
+export declare function throwCapsuleServerError(response: Response, readJson: (response: Response) => Promise<unknown>, clock: Clock): Promise<never>;

package/lib/hosted-target/capsule-error-response.mjs

@@ -0,0 +1,73 @@
+import { TargetProtocolError, TargetServerError } from './errors.mjs';
+import { parseRetryAfter } from './retry.mjs';
+const ERROR_CODES = Object.freeze({
+    unauthorized: { statuses: [401], retryable: false },
+    invalid_request: { statuses: [400], retryable: false },
+    not_found: { statuses: [404], retryable: false },
+    forbidden: { statuses: [402, 403], retryable: false },
+    idempotency_conflict: { statuses: [409], retryable: false },
+    run_conflict: { statuses: [409], retryable: true },
+    rate_limited: { statuses: [429], retryable: true },
+    temporarily_unavailable: { statuses: [503], retryable: true },
+    internal_error: { statuses: [500], retryable: false },
+});
+function isErrorCode(value) {
+    return typeof value === 'string' && value in ERROR_CODES;
+}
+function isRecordBody(body) {
+    return body !== null && typeof body === 'object' && !Array.isArray(body);
+}
+function hasExactErrorFields(value) {
+    const fields = Object.keys(value);
+    const exactFields = ['code', 'message', 'capsule_id', 'retryable'];
+    return fields.length === exactFields.length &&
+        exactFields.every((field) => field in value);
+}
+function hasValidErrorValues(value) {
+    return isErrorCode(value.code) &&
+        typeof value.message === 'string' &&
+        (value.capsule_id === null || typeof value.capsule_id === 'string') &&
+        typeof value.retryable === 'boolean';
+}
+function parseErrorBody(body) {
+    if (!isRecordBody(body) || !hasExactErrorFields(body) || !hasValidErrorValues(body)) {
+        throw new TargetProtocolError('Capsule error response is malformed');
+    }
+    const value = body;
+    return {
+        code: value.code,
+        capsuleId: value.capsule_id,
+        retryable: value.retryable,
+    };
+}
+function validateChallenge(response) {
+    if (response.status !== 401)
+        return;
+    if (response.headers.get('WWW-Authenticate') !== 'Bearer error="invalid_token"') {
+        throw new TargetProtocolError('Capsule authentication challenge is malformed');
+    }
+}
+function validatedRetryAfter(response, retryable, clock) {
+    const header = response.headers.get('Retry-After');
+    const retryAfter = parseRetryAfter(header, clock) ?? undefined;
+    if (header !== null && retryAfter === undefined) {
+        throw new TargetProtocolError('Capsule Retry-After header is malformed');
+    }
+    if (retryable && retryAfter === undefined) {
+        throw new TargetProtocolError('Retryable capsule error omitted Retry-After');
+    }
+    if (!retryable && retryAfter !== undefined) {
+        throw new TargetProtocolError('Permanent capsule error advertised Retry-After');
+    }
+    return retryAfter;
+}
+export async function throwCapsuleServerError(response, readJson, clock) {
+    const value = parseErrorBody(await readJson(response));
+    const contract = ERROR_CODES[value.code];
+    if (!contract.statuses.includes(response.status) || contract.retryable !== value.retryable) {
+        throw new TargetProtocolError('Capsule error response contradicts its status contract');
+    }
+    validateChallenge(response);
+    const retryAfter = validatedRetryAfter(response, contract.retryable, clock);
+    throw new TargetServerError(response.status, value.code, contract.retryable, value.capsuleId, retryAfter);
+}

package/lib/hosted-target/errors.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TargetNotFoundError = exports.TargetCapacityError = exports.TargetProtocolError = exports.TargetTransportError = exports.TargetRateLimitError = exports.TargetConflictError = exports.TargetAuthError = exports.TargetServerError = exports.TargetAdapterError = void 0;
+exports.isRetryable = isRetryable;
+class TargetAdapterError extends Error {
+    code;
+    retryable;
+    constructor(code, message, retryable) {
+        super(message);
+        this.name = 'TargetAdapterError';
+        this.code = code;
+        this.retryable = retryable;
+    }
+}
+exports.TargetAdapterError = TargetAdapterError;
+class TargetServerError extends TargetAdapterError {
+    status;
+    serverCode;
+    capsuleId;
+    retryAfterMs;
+    constructor(status, serverCode, retryable, capsuleId, retryAfterMs) {
+        super('SERVER_REJECTED', `Capsule request failed (${serverCode})`, retryable);
+        this.name = 'TargetServerError';
+        this.status = status;
+        this.serverCode = serverCode;
+        this.capsuleId = capsuleId;
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+exports.TargetServerError = TargetServerError;
+class TargetAuthError extends TargetAdapterError {
+    constructor(message) {
+        super('AUTH_FAILED', message, false);
+        this.name = 'TargetAuthError';
+    }
+}
+exports.TargetAuthError = TargetAuthError;
+class TargetConflictError extends TargetAdapterError {
+    idempotencyKey;
+    constructor(idempotencyKey, message) {
+        super('CONFLICT', message, true);
+        this.name = 'TargetConflictError';
+        this.idempotencyKey = idempotencyKey;
+    }
+}
+exports.TargetConflictError = TargetConflictError;
+class TargetRateLimitError extends TargetAdapterError {
+    retryAfterMs;
+    constructor(message, retryAfterMs) {
+        super('RATE_LIMITED', message, true);
+        this.name = 'TargetRateLimitError';
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+exports.TargetRateLimitError = TargetRateLimitError;
+class TargetTransportError extends TargetAdapterError {
+    constructor(message) {
+        super('TRANSPORT', message, true);
+        this.name = 'TargetTransportError';
+    }
+}
+exports.TargetTransportError = TargetTransportError;
+class TargetProtocolError extends TargetAdapterError {
+    constructor(message) {
+        super('PROTOCOL', message, false);
+        this.name = 'TargetProtocolError';
+    }
+}
+exports.TargetProtocolError = TargetProtocolError;
+class TargetCapacityError extends TargetAdapterError {
+    constructor(message) {
+        super('CAPACITY', message, false);
+        this.name = 'TargetCapacityError';
+    }
+}
+exports.TargetCapacityError = TargetCapacityError;
+class TargetNotFoundError extends TargetAdapterError {
+    constructor(message) {
+        super('NOT_FOUND', message, false);
+        this.name = 'TargetNotFoundError';
+    }
+}
+exports.TargetNotFoundError = TargetNotFoundError;
+function isRetryable(error) {
+    if (error instanceof TargetAdapterError)
+        return error.retryable;
+    return false;
+}

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

@@ -0,0 +1,36 @@
+export declare class TargetAdapterError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(code: string, message: string, retryable: boolean);
+}
+export declare class TargetServerError extends TargetAdapterError {
+    readonly status: number;
+    readonly serverCode: string;
+    readonly capsuleId: string | null;
+    readonly retryAfterMs: number | undefined;
+    constructor(status: number, serverCode: string, retryable: boolean, capsuleId: string | null, retryAfterMs?: number);
+}
+export declare class TargetAuthError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetConflictError extends TargetAdapterError {
+    readonly idempotencyKey: string;
+    constructor(idempotencyKey: string, message: string);
+}
+export declare class TargetRateLimitError extends TargetAdapterError {
+    readonly retryAfterMs: number | undefined;
+    constructor(message: string, retryAfterMs?: number);
+}
+export declare class TargetTransportError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetProtocolError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetCapacityError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetNotFoundError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare function isRetryable(error: unknown): boolean;

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

@@ -0,0 +1,36 @@
+export declare class TargetAdapterError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(code: string, message: string, retryable: boolean);
+}
+export declare class TargetServerError extends TargetAdapterError {
+    readonly status: number;
+    readonly serverCode: string;
+    readonly capsuleId: string | null;
+    readonly retryAfterMs: number | undefined;
+    constructor(status: number, serverCode: string, retryable: boolean, capsuleId: string | null, retryAfterMs?: number);
+}
+export declare class TargetAuthError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetConflictError extends TargetAdapterError {
+    readonly idempotencyKey: string;
+    constructor(idempotencyKey: string, message: string);
+}
+export declare class TargetRateLimitError extends TargetAdapterError {
+    readonly retryAfterMs: number | undefined;
+    constructor(message: string, retryAfterMs?: number);
+}
+export declare class TargetTransportError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetProtocolError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetCapacityError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetNotFoundError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare function isRetryable(error: unknown): boolean;

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

@@ -0,0 +1,36 @@
+export declare class TargetAdapterError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    constructor(code: string, message: string, retryable: boolean);
+}
+export declare class TargetServerError extends TargetAdapterError {
+    readonly status: number;
+    readonly serverCode: string;
+    readonly capsuleId: string | null;
+    readonly retryAfterMs: number | undefined;
+    constructor(status: number, serverCode: string, retryable: boolean, capsuleId: string | null, retryAfterMs?: number);
+}
+export declare class TargetAuthError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetConflictError extends TargetAdapterError {
+    readonly idempotencyKey: string;
+    constructor(idempotencyKey: string, message: string);
+}
+export declare class TargetRateLimitError extends TargetAdapterError {
+    readonly retryAfterMs: number | undefined;
+    constructor(message: string, retryAfterMs?: number);
+}
+export declare class TargetTransportError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetProtocolError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetCapacityError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare class TargetNotFoundError extends TargetAdapterError {
+    constructor(message: string);
+}
+export declare function isRetryable(error: unknown): boolean;

package/lib/hosted-target/errors.mjs

@@ -0,0 +1,75 @@
+export class TargetAdapterError extends Error {
+    code;
+    retryable;
+    constructor(code, message, retryable) {
+        super(message);
+        this.name = 'TargetAdapterError';
+        this.code = code;
+        this.retryable = retryable;
+    }
+}
+export class TargetServerError extends TargetAdapterError {
+    status;
+    serverCode;
+    capsuleId;
+    retryAfterMs;
+    constructor(status, serverCode, retryable, capsuleId, retryAfterMs) {
+        super('SERVER_REJECTED', `Capsule request failed (${serverCode})`, retryable);
+        this.name = 'TargetServerError';
+        this.status = status;
+        this.serverCode = serverCode;
+        this.capsuleId = capsuleId;
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+export class TargetAuthError extends TargetAdapterError {
+    constructor(message) {
+        super('AUTH_FAILED', message, false);
+        this.name = 'TargetAuthError';
+    }
+}
+export class TargetConflictError extends TargetAdapterError {
+    idempotencyKey;
+    constructor(idempotencyKey, message) {
+        super('CONFLICT', message, true);
+        this.name = 'TargetConflictError';
+        this.idempotencyKey = idempotencyKey;
+    }
+}
+export class TargetRateLimitError extends TargetAdapterError {
+    retryAfterMs;
+    constructor(message, retryAfterMs) {
+        super('RATE_LIMITED', message, true);
+        this.name = 'TargetRateLimitError';
+        this.retryAfterMs = retryAfterMs;
+    }
+}
+export class TargetTransportError extends TargetAdapterError {
+    constructor(message) {
+        super('TRANSPORT', message, true);
+        this.name = 'TargetTransportError';
+    }
+}
+export class TargetProtocolError extends TargetAdapterError {
+    constructor(message) {
+        super('PROTOCOL', message, false);
+        this.name = 'TargetProtocolError';
+    }
+}
+export class TargetCapacityError extends TargetAdapterError {
+    constructor(message) {
+        super('CAPACITY', message, false);
+        this.name = 'TargetCapacityError';
+    }
+}
+export class TargetNotFoundError extends TargetAdapterError {
+    constructor(message) {
+        super('NOT_FOUND', message, false);
+        this.name = 'TargetNotFoundError';
+    }
+}
+export function isRetryable(error) {
+    if (error instanceof TargetAdapterError)
+        return error.retryable;
+    return false;
+}

package/lib/hosted-target/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRetryable = exports.TargetServerError = exports.TargetNotFoundError = exports.TargetCapacityError = exports.TargetProtocolError = exports.TargetTransportError = exports.TargetRateLimitError = exports.TargetConflictError = exports.TargetAuthError = exports.TargetAdapterError = exports.createTargetAdapter = void 0;
+var target_adapter_js_1 = require("./target-adapter.cjs");
+Object.defineProperty(exports, "createTargetAdapter", { enumerable: true, get: function () { return target_adapter_js_1.createTargetAdapter; } });
+var errors_js_1 = require("./errors.cjs");
+Object.defineProperty(exports, "TargetAdapterError", { enumerable: true, get: function () { return errors_js_1.TargetAdapterError; } });
+Object.defineProperty(exports, "TargetAuthError", { enumerable: true, get: function () { return errors_js_1.TargetAuthError; } });
+Object.defineProperty(exports, "TargetConflictError", { enumerable: true, get: function () { return errors_js_1.TargetConflictError; } });
+Object.defineProperty(exports, "TargetRateLimitError", { enumerable: true, get: function () { return errors_js_1.TargetRateLimitError; } });
+Object.defineProperty(exports, "TargetTransportError", { enumerable: true, get: function () { return errors_js_1.TargetTransportError; } });
+Object.defineProperty(exports, "TargetProtocolError", { enumerable: true, get: function () { return errors_js_1.TargetProtocolError; } });
+Object.defineProperty(exports, "TargetCapacityError", { enumerable: true, get: function () { return errors_js_1.TargetCapacityError; } });
+Object.defineProperty(exports, "TargetNotFoundError", { enumerable: true, get: function () { return errors_js_1.TargetNotFoundError; } });
+Object.defineProperty(exports, "TargetServerError", { enumerable: true, get: function () { return errors_js_1.TargetServerError; } });
+Object.defineProperty(exports, "isRetryable", { enumerable: true, get: function () { return errors_js_1.isRetryable; } });

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

@@ -0,0 +1,3 @@
+export { createTargetAdapter, type TargetAdapter, type CreateTargetAdapterOptions, type CredentialInstallCapability, } from './target-adapter.js';
+export { TargetAdapterError, TargetAuthError, TargetConflictError, TargetRateLimitError, TargetTransportError, TargetProtocolError, TargetCapacityError, TargetNotFoundError, TargetServerError, isRetryable, } from './errors.js';
+export type { TargetAccessTokenProvider, CapsuleState, Capsule, CapsuleAccess, CapsuleListPage, CapsuleLimits, AllocateRequest, ListRequest, HttpTransport, Clock, RetryPolicy, } from './types.js';

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

@@ -0,0 +1,3 @@
+export { createTargetAdapter, type TargetAdapter, type CreateTargetAdapterOptions, type CredentialInstallCapability, } from './target-adapter.js';
+export { TargetAdapterError, TargetAuthError, TargetConflictError, TargetRateLimitError, TargetTransportError, TargetProtocolError, TargetCapacityError, TargetNotFoundError, TargetServerError, isRetryable, } from './errors.js';
+export type { TargetAccessTokenProvider, CapsuleState, Capsule, CapsuleAccess, CapsuleListPage, CapsuleLimits, AllocateRequest, ListRequest, HttpTransport, Clock, RetryPolicy, } from './types.js';

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

@@ -0,0 +1,3 @@
+export { createTargetAdapter, type TargetAdapter, type CreateTargetAdapterOptions, type CredentialInstallCapability, } from './target-adapter.js';
+export { TargetAdapterError, TargetAuthError, TargetConflictError, TargetRateLimitError, TargetTransportError, TargetProtocolError, TargetCapacityError, TargetNotFoundError, TargetServerError, isRetryable, } from './errors.js';
+export type { TargetAccessTokenProvider, CapsuleState, Capsule, CapsuleAccess, CapsuleListPage, CapsuleLimits, AllocateRequest, ListRequest, HttpTransport, Clock, RetryPolicy, } from './types.js';

package/lib/hosted-target/index.mjs

@@ -0,0 +1,2 @@
+export { createTargetAdapter, } from './target-adapter.mjs';
+export { TargetAdapterError, TargetAuthError, TargetConflictError, TargetRateLimitError, TargetTransportError, TargetProtocolError, TargetCapacityError, TargetNotFoundError, TargetServerError, isRetryable, } from './errors.mjs';