@the-open-engine/zeroshot 6.29.0 → 6.30.0

package/lib/hosted-target/response-validation.cjs

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertCapsule = assertCapsule;
+exports.assertCapsuleAccess = assertCapsuleAccess;
+exports.assertCapsuleLimits = assertCapsuleLimits;
+exports.assertCapsuleListPage = assertCapsuleListPage;
+const errors_js_1 = require("./errors.cjs");
+const types_js_1 = require("./types.cjs");
+function closedObject(body, fields, context) {
+    if (body === null || typeof body !== 'object' || Array.isArray(body)) {
+        throw new errors_js_1.TargetProtocolError(`${context} response is malformed`);
+    }
+    const record = body;
+    if (Object.keys(record).length !== fields.length || fields.some((field) => !(field in record))) {
+        throw new errors_js_1.TargetProtocolError(`${context} response is malformed`);
+    }
+    return record;
+}
+function nonempty(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function decimal(value, length) {
+    if (value.length !== length)
+        return null;
+    for (const character of value) {
+        if (character < '0' || character > '9')
+            return null;
+    }
+    return Number(value);
+}
+function parseDate(value) {
+    const fields = value.split('-');
+    if (fields.length !== 3)
+        return null;
+    const year = decimal(fields[0] ?? '', 4);
+    const month = decimal(fields[1] ?? '', 2);
+    const day = decimal(fields[2] ?? '', 2);
+    if (year === null || month === null || day === null)
+        return null;
+    return { year, month, day };
+}
+function parseZone(value) {
+    if (value.endsWith('Z')) {
+        return { clock: value.slice(0, -1), offsetHour: 0, offsetMinute: 0 };
+    }
+    const marker = value.at(-6);
+    if ((marker !== '+' && marker !== '-') || value.at(-3) !== ':')
+        return null;
+    const offsetHour = decimal(value.slice(-5, -3), 2);
+    const offsetMinute = decimal(value.slice(-2), 2);
+    if (offsetHour === null || offsetMinute === null)
+        return null;
+    return { clock: value.slice(0, -6), offsetHour, offsetMinute };
+}
+function parseFractionalClock(value) {
+    const fields = value.split('.');
+    if (fields.length > 2)
+        return null;
+    const fraction = fields[1];
+    if (fraction !== undefined &&
+        (fraction.length === 0 || decimal(fraction, fraction.length) === null)) {
+        return null;
+    }
+    return fields[0] ?? null;
+}
+function parseHms(value) {
+    const fields = value.split(':');
+    if (fields.length !== 3)
+        return null;
+    const hour = decimal(fields[0] ?? '', 2);
+    const minute = decimal(fields[1] ?? '', 2);
+    const second = decimal(fields[2] ?? '', 2);
+    return hour === null || minute === null || second === null ? null : { hour, minute, second };
+}
+function parseClock(value) {
+    const zone = parseZone(value);
+    if (zone === null)
+        return null;
+    const clock = parseFractionalClock(zone.clock);
+    if (clock === null)
+        return null;
+    const parts = parseHms(clock);
+    if (parts === null)
+        return null;
+    return { ...parts, offsetHour: zone.offsetHour, offsetMinute: zone.offsetMinute };
+}
+function parseTimestamp(value) {
+    if (value.at(10) !== 'T')
+        return null;
+    const date = parseDate(value.slice(0, 10));
+    const clock = parseClock(value.slice(11));
+    return date === null || clock === null ? null : { ...date, ...clock };
+}
+function validClock(parts) {
+    return parts.hour <= 23 && parts.minute <= 59 && parts.second <= 59 &&
+        parts.offsetHour <= 23 && parts.offsetMinute <= 59;
+}
+function validCalendar(parts) {
+    if (parts.month < 1 || parts.month > 12)
+        return false;
+    const leap = parts.year % 4 === 0 && (parts.year % 100 !== 0 || parts.year % 400 === 0);
+    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return parts.day >= 1 && parts.day <= (days[parts.month - 1] ?? 0);
+}
+function timestamp(value) {
+    if (!nonempty(value))
+        return false;
+    const parts = parseTimestamp(value);
+    return parts !== null &&
+        validClock(parts) &&
+        validCalendar(parts) &&
+        Number.isFinite(Date.parse(value));
+}
+function uint(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function assertCapsule(body) {
+    const value = closedObject(body, ['capsule_id', 'state', 'label', 'created_at'], 'Capsule');
+    if (!nonempty(value.capsule_id) ||
+        typeof value.state !== 'string' ||
+        !types_js_1.KNOWN_CAPSULE_STATES.includes(value.state) ||
+        (value.label !== null && typeof value.label !== 'string') ||
+        !timestamp(value.created_at)) {
+        throw new errors_js_1.TargetProtocolError('Capsule response is malformed');
+    }
+    return Object.freeze({
+        id: value.capsule_id,
+        state: value.state,
+        label: value.label,
+        createdAt: value.created_at,
+    });
+}
+function assertCapsuleAccess(body) {
+    const value = closedObject(body, ['protocol', 'websocket_url', 'access_token', 'token_type', 'expires_at'], 'CapsuleAccess');
+    if (value.protocol !== 'openengine.cluster/v1' ||
+        !nonempty(value.websocket_url) ||
+        !nonempty(value.access_token) ||
+        value.token_type !== 'Bearer' ||
+        !timestamp(value.expires_at)) {
+        throw new errors_js_1.TargetProtocolError('CapsuleAccess response is malformed');
+    }
+    return Object.freeze({
+        protocol: 'openengine.cluster/v1',
+        websocketUrl: value.websocket_url,
+        accessToken: value.access_token,
+        tokenType: 'Bearer',
+        expiresAt: value.expires_at,
+    });
+}
+function assertCapsuleLimits(body) {
+    const value = closedObject(body, ['active_capsules', 'max_active_capsules'], 'CapsuleLimits');
+    if (!uint(value.active_capsules) || (value.max_active_capsules !== null && !uint(value.max_active_capsules))) {
+        throw new errors_js_1.TargetProtocolError('CapsuleLimits response is malformed');
+    }
+    return Object.freeze({
+        activeCapsules: value.active_capsules,
+        maxActiveCapsules: value.max_active_capsules,
+    });
+}
+function assertCapsuleListPage(body) {
+    const value = closedObject(body, ['capsules', 'next_cursor'], 'CapsulePage');
+    if (!Array.isArray(value.capsules) || (value.next_cursor !== null && typeof value.next_cursor !== 'string')) {
+        throw new errors_js_1.TargetProtocolError('CapsulePage response is malformed');
+    }
+    return Object.freeze({
+        capsules: Object.freeze(value.capsules.map((item) => assertCapsule(item))),
+        nextCursor: value.next_cursor,
+    });
+}

package/lib/hosted-target/response-validation.d.cts

@@ -0,0 +1,5 @@
+import type { Capsule, CapsuleAccess, CapsuleLimits, CapsuleListPage } from './types.js';
+export declare function assertCapsule(body: unknown): Capsule;
+export declare function assertCapsuleAccess(body: unknown): CapsuleAccess;
+export declare function assertCapsuleLimits(body: unknown): CapsuleLimits;
+export declare function assertCapsuleListPage(body: unknown): CapsuleListPage;

package/lib/hosted-target/response-validation.d.mts

@@ -0,0 +1,5 @@
+import type { Capsule, CapsuleAccess, CapsuleLimits, CapsuleListPage } from './types.js';
+export declare function assertCapsule(body: unknown): Capsule;
+export declare function assertCapsuleAccess(body: unknown): CapsuleAccess;
+export declare function assertCapsuleLimits(body: unknown): CapsuleLimits;
+export declare function assertCapsuleListPage(body: unknown): CapsuleListPage;

package/lib/hosted-target/response-validation.d.ts

@@ -0,0 +1,5 @@
+import type { Capsule, CapsuleAccess, CapsuleLimits, CapsuleListPage } from './types.js';
+export declare function assertCapsule(body: unknown): Capsule;
+export declare function assertCapsuleAccess(body: unknown): CapsuleAccess;
+export declare function assertCapsuleLimits(body: unknown): CapsuleLimits;
+export declare function assertCapsuleListPage(body: unknown): CapsuleListPage;

package/lib/hosted-target/response-validation.mjs

@@ -0,0 +1,163 @@
+import { TargetProtocolError } from './errors.mjs';
+import { KNOWN_CAPSULE_STATES } from './types.mjs';
+function closedObject(body, fields, context) {
+    if (body === null || typeof body !== 'object' || Array.isArray(body)) {
+        throw new TargetProtocolError(`${context} response is malformed`);
+    }
+    const record = body;
+    if (Object.keys(record).length !== fields.length || fields.some((field) => !(field in record))) {
+        throw new TargetProtocolError(`${context} response is malformed`);
+    }
+    return record;
+}
+function nonempty(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function decimal(value, length) {
+    if (value.length !== length)
+        return null;
+    for (const character of value) {
+        if (character < '0' || character > '9')
+            return null;
+    }
+    return Number(value);
+}
+function parseDate(value) {
+    const fields = value.split('-');
+    if (fields.length !== 3)
+        return null;
+    const year = decimal(fields[0] ?? '', 4);
+    const month = decimal(fields[1] ?? '', 2);
+    const day = decimal(fields[2] ?? '', 2);
+    if (year === null || month === null || day === null)
+        return null;
+    return { year, month, day };
+}
+function parseZone(value) {
+    if (value.endsWith('Z')) {
+        return { clock: value.slice(0, -1), offsetHour: 0, offsetMinute: 0 };
+    }
+    const marker = value.at(-6);
+    if ((marker !== '+' && marker !== '-') || value.at(-3) !== ':')
+        return null;
+    const offsetHour = decimal(value.slice(-5, -3), 2);
+    const offsetMinute = decimal(value.slice(-2), 2);
+    if (offsetHour === null || offsetMinute === null)
+        return null;
+    return { clock: value.slice(0, -6), offsetHour, offsetMinute };
+}
+function parseFractionalClock(value) {
+    const fields = value.split('.');
+    if (fields.length > 2)
+        return null;
+    const fraction = fields[1];
+    if (fraction !== undefined &&
+        (fraction.length === 0 || decimal(fraction, fraction.length) === null)) {
+        return null;
+    }
+    return fields[0] ?? null;
+}
+function parseHms(value) {
+    const fields = value.split(':');
+    if (fields.length !== 3)
+        return null;
+    const hour = decimal(fields[0] ?? '', 2);
+    const minute = decimal(fields[1] ?? '', 2);
+    const second = decimal(fields[2] ?? '', 2);
+    return hour === null || minute === null || second === null ? null : { hour, minute, second };
+}
+function parseClock(value) {
+    const zone = parseZone(value);
+    if (zone === null)
+        return null;
+    const clock = parseFractionalClock(zone.clock);
+    if (clock === null)
+        return null;
+    const parts = parseHms(clock);
+    if (parts === null)
+        return null;
+    return { ...parts, offsetHour: zone.offsetHour, offsetMinute: zone.offsetMinute };
+}
+function parseTimestamp(value) {
+    if (value.at(10) !== 'T')
+        return null;
+    const date = parseDate(value.slice(0, 10));
+    const clock = parseClock(value.slice(11));
+    return date === null || clock === null ? null : { ...date, ...clock };
+}
+function validClock(parts) {
+    return parts.hour <= 23 && parts.minute <= 59 && parts.second <= 59 &&
+        parts.offsetHour <= 23 && parts.offsetMinute <= 59;
+}
+function validCalendar(parts) {
+    if (parts.month < 1 || parts.month > 12)
+        return false;
+    const leap = parts.year % 4 === 0 && (parts.year % 100 !== 0 || parts.year % 400 === 0);
+    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return parts.day >= 1 && parts.day <= (days[parts.month - 1] ?? 0);
+}
+function timestamp(value) {
+    if (!nonempty(value))
+        return false;
+    const parts = parseTimestamp(value);
+    return parts !== null &&
+        validClock(parts) &&
+        validCalendar(parts) &&
+        Number.isFinite(Date.parse(value));
+}
+function uint(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+export function assertCapsule(body) {
+    const value = closedObject(body, ['capsule_id', 'state', 'label', 'created_at'], 'Capsule');
+    if (!nonempty(value.capsule_id) ||
+        typeof value.state !== 'string' ||
+        !KNOWN_CAPSULE_STATES.includes(value.state) ||
+        (value.label !== null && typeof value.label !== 'string') ||
+        !timestamp(value.created_at)) {
+        throw new TargetProtocolError('Capsule response is malformed');
+    }
+    return Object.freeze({
+        id: value.capsule_id,
+        state: value.state,
+        label: value.label,
+        createdAt: value.created_at,
+    });
+}
+export function assertCapsuleAccess(body) {
+    const value = closedObject(body, ['protocol', 'websocket_url', 'access_token', 'token_type', 'expires_at'], 'CapsuleAccess');
+    if (value.protocol !== 'openengine.cluster/v1' ||
+        !nonempty(value.websocket_url) ||
+        !nonempty(value.access_token) ||
+        value.token_type !== 'Bearer' ||
+        !timestamp(value.expires_at)) {
+        throw new TargetProtocolError('CapsuleAccess response is malformed');
+    }
+    return Object.freeze({
+        protocol: 'openengine.cluster/v1',
+        websocketUrl: value.websocket_url,
+        accessToken: value.access_token,
+        tokenType: 'Bearer',
+        expiresAt: value.expires_at,
+    });
+}
+export function assertCapsuleLimits(body) {
+    const value = closedObject(body, ['active_capsules', 'max_active_capsules'], 'CapsuleLimits');
+    if (!uint(value.active_capsules) || (value.max_active_capsules !== null && !uint(value.max_active_capsules))) {
+        throw new TargetProtocolError('CapsuleLimits response is malformed');
+    }
+    return Object.freeze({
+        activeCapsules: value.active_capsules,
+        maxActiveCapsules: value.max_active_capsules,
+    });
+}
+export function assertCapsuleListPage(body) {
+    const value = closedObject(body, ['capsules', 'next_cursor'], 'CapsulePage');
+    if (!Array.isArray(value.capsules) || (value.next_cursor !== null && typeof value.next_cursor !== 'string')) {
+        throw new TargetProtocolError('CapsulePage response is malformed');
+    }
+    return Object.freeze({
+        capsules: Object.freeze(value.capsules.map((item) => assertCapsule(item))),
+        nextCursor: value.next_cursor,
+    });
+}

package/lib/hosted-target/retry-executor.cjs

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTargetRetry = withTargetRetry;
+const bounds_js_1 = require("./bounds.cjs");
+const errors_js_1 = require("./errors.cjs");
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
+    }
+}
+async function wait(delayMs, signal) {
+    throwIfAborted(signal);
+    if (delayMs <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, delayMs);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError'));
+        }, { once: true });
+    });
+}
+function retryableError(value) {
+    return value instanceof errors_js_1.TargetAdapterError && value.retryable;
+}
+function validRetryDelay(retry, delayMs, remaining) {
+    return retry && Number.isFinite(delayMs) && delayMs >= 0 && delayMs < remaining;
+}
+async function withTargetRetry(operation, effect, signal, context) {
+    const retrySafe = operation !== 'access';
+    const started = context.clock.now();
+    let attempt = 0;
+    while (true) {
+        throwIfAborted(signal);
+        try {
+            return await effect();
+        }
+        catch (error) {
+            throwIfAborted(signal);
+            if (!retrySafe || !retryableError(error))
+                throw error;
+            attempt += 1;
+            const elapsed = context.clock.now() - started;
+            const decision = context.policy.shouldRetry(attempt, elapsed, error);
+            const remaining = bounds_js_1.MAX_RETRY_ELAPSED_MS - elapsed;
+            if (!validRetryDelay(decision.retry, decision.delayMs, remaining))
+                throw error;
+            await wait(decision.delayMs, signal);
+        }
+    }
+}

package/lib/hosted-target/retry-executor.d.cts

@@ -0,0 +1,8 @@
+import type { Clock, RetryPolicy } from './types.js';
+export type TargetOperation = 'allocate' | 'list' | 'inspect' | 'terminate' | 'limits' | 'access';
+type RetryContext = {
+    readonly clock: Clock;
+    readonly policy: RetryPolicy;
+};
+export declare function withTargetRetry<T>(operation: TargetOperation, effect: () => Promise<T>, signal: AbortSignal | undefined, context: RetryContext): Promise<T>;
+export {};

package/lib/hosted-target/retry-executor.d.mts

@@ -0,0 +1,8 @@
+import type { Clock, RetryPolicy } from './types.js';
+export type TargetOperation = 'allocate' | 'list' | 'inspect' | 'terminate' | 'limits' | 'access';
+type RetryContext = {
+    readonly clock: Clock;
+    readonly policy: RetryPolicy;
+};
+export declare function withTargetRetry<T>(operation: TargetOperation, effect: () => Promise<T>, signal: AbortSignal | undefined, context: RetryContext): Promise<T>;
+export {};

package/lib/hosted-target/retry-executor.d.ts

@@ -0,0 +1,8 @@
+import type { Clock, RetryPolicy } from './types.js';
+export type TargetOperation = 'allocate' | 'list' | 'inspect' | 'terminate' | 'limits' | 'access';
+type RetryContext = {
+    readonly clock: Clock;
+    readonly policy: RetryPolicy;
+};
+export declare function withTargetRetry<T>(operation: TargetOperation, effect: () => Promise<T>, signal: AbortSignal | undefined, context: RetryContext): Promise<T>;
+export {};

package/lib/hosted-target/retry-executor.mjs

@@ -0,0 +1,48 @@
+import { MAX_RETRY_ELAPSED_MS } from './bounds.mjs';
+import { TargetAdapterError } from './errors.mjs';
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        throw signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError');
+    }
+}
+async function wait(delayMs, signal) {
+    throwIfAborted(signal);
+    if (delayMs <= 0)
+        return;
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, delayMs);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(signal.reason ?? new globalThis.DOMException('The operation was aborted', 'AbortError'));
+        }, { once: true });
+    });
+}
+function retryableError(value) {
+    return value instanceof TargetAdapterError && value.retryable;
+}
+function validRetryDelay(retry, delayMs, remaining) {
+    return retry && Number.isFinite(delayMs) && delayMs >= 0 && delayMs < remaining;
+}
+export async function withTargetRetry(operation, effect, signal, context) {
+    const retrySafe = operation !== 'access';
+    const started = context.clock.now();
+    let attempt = 0;
+    while (true) {
+        throwIfAborted(signal);
+        try {
+            return await effect();
+        }
+        catch (error) {
+            throwIfAborted(signal);
+            if (!retrySafe || !retryableError(error))
+                throw error;
+            attempt += 1;
+            const elapsed = context.clock.now() - started;
+            const decision = context.policy.shouldRetry(attempt, elapsed, error);
+            const remaining = MAX_RETRY_ELAPSED_MS - elapsed;
+            if (!validRetryDelay(decision.retry, decision.delayMs, remaining))
+                throw error;
+            await wait(decision.delayMs, signal);
+        }
+    }
+}

package/lib/hosted-target/retry.cjs

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultRetryPolicy = void 0;
+exports.parseRetryAfter = parseRetryAfter;
+const bounds_js_1 = require("./bounds.cjs");
+const errors_js_1 = require("./errors.cjs");
+const IMF_WEEKDAYS = new Set(['Mon,', 'Tue,', 'Wed,', 'Thu,', 'Fri,', 'Sat,', 'Sun,']);
+const IMF_MONTHS = new Set([
+    'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec',
+]);
+function fixedDigits(value, length) {
+    if (value.length !== length)
+        return false;
+    for (const character of value) {
+        if (character < '0' || character > '9')
+            return false;
+    }
+    return true;
+}
+function validImfDate(weekday, day, month, year) {
+    return IMF_WEEKDAYS.has(weekday) &&
+        fixedDigits(day, 2) &&
+        IMF_MONTHS.has(month) &&
+        fixedDigits(year, 4);
+}
+function validImfTime(value) {
+    const parts = value.split(':');
+    return parts.length === 3 && parts.every((part) => fixedDigits(part, 2));
+}
+function isImfFixdate(value) {
+    const parts = value.split(' ');
+    if (parts.length !== 6)
+        return false;
+    const [weekday = '', day = '', month = '', year = '', time = '', zone = ''] = parts;
+    return validImfDate(weekday, day, month, year) && validImfTime(time) && zone === 'GMT';
+}
+class DefaultRetryPolicy {
+    shouldRetry(attempt, elapsed, error) {
+        if (error instanceof errors_js_1.TargetAuthError)
+            return { retry: false, delayMs: 0 };
+        if (!error.retryable)
+            return { retry: false, delayMs: 0 };
+        if (attempt >= bounds_js_1.MAX_RETRY_ATTEMPTS)
+            return { retry: false, delayMs: 0 };
+        if (elapsed >= bounds_js_1.MAX_RETRY_ELAPSED_MS)
+            return { retry: false, delayMs: 0 };
+        const requestedDelay = (error instanceof errors_js_1.TargetRateLimitError || error instanceof errors_js_1.TargetServerError) &&
+            error.retryAfterMs !== undefined
+            ? Math.max(0, error.retryAfterMs)
+            : Math.min(1000 * Math.pow(2, attempt), 10_000);
+        const remaining = bounds_js_1.MAX_RETRY_ELAPSED_MS - elapsed;
+        if (!Number.isFinite(requestedDelay) || requestedDelay >= remaining) {
+            return { retry: false, delayMs: 0 };
+        }
+        return { retry: true, delayMs: requestedDelay };
+    }
+}
+exports.DefaultRetryPolicy = DefaultRetryPolicy;
+function parseRetryAfter(header, clock) {
+    if (header === null)
+        return null;
+    const trimmed = header.trim();
+    if (trimmed.length === 0)
+        return null;
+    if (/^\d+$/.test(trimmed)) {
+        const delayMs = Number(trimmed) * 1000;
+        return Number.isSafeInteger(delayMs) ? delayMs : null;
+    }
+    if (!isImfFixdate(trimmed)) {
+        return null;
+    }
+    const date = Date.parse(trimmed);
+    if (!Number.isFinite(date) || new Date(date).toUTCString() !== trimmed)
+        return null;
+    const delayMs = date - clock.now();
+    return delayMs > 0 ? delayMs : 0;
+}

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

@@ -0,0 +1,9 @@
+import type { TargetAdapterError } from './errors.js';
+import type { Clock, RetryPolicy } from './types.js';
+export declare class DefaultRetryPolicy implements RetryPolicy {
+    shouldRetry(attempt: number, elapsed: number, error: TargetAdapterError): {
+        retry: boolean;
+        delayMs: number;
+    };
+}
+export declare function parseRetryAfter(header: string | null, clock: Clock): number | null;

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

@@ -0,0 +1,9 @@
+import type { TargetAdapterError } from './errors.js';
+import type { Clock, RetryPolicy } from './types.js';
+export declare class DefaultRetryPolicy implements RetryPolicy {
+    shouldRetry(attempt: number, elapsed: number, error: TargetAdapterError): {
+        retry: boolean;
+        delayMs: number;
+    };
+}
+export declare function parseRetryAfter(header: string | null, clock: Clock): number | null;

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

@@ -0,0 +1,9 @@
+import type { TargetAdapterError } from './errors.js';
+import type { Clock, RetryPolicy } from './types.js';
+export declare class DefaultRetryPolicy implements RetryPolicy {
+    shouldRetry(attempt: number, elapsed: number, error: TargetAdapterError): {
+        retry: boolean;
+        delayMs: number;
+    };
+}
+export declare function parseRetryAfter(header: string | null, clock: Clock): number | null;

package/lib/hosted-target/retry.mjs

@@ -0,0 +1,73 @@
+import { MAX_RETRY_ATTEMPTS, MAX_RETRY_ELAPSED_MS } from './bounds.mjs';
+import { TargetAuthError, TargetRateLimitError, TargetServerError } from './errors.mjs';
+const IMF_WEEKDAYS = new Set(['Mon,', 'Tue,', 'Wed,', 'Thu,', 'Fri,', 'Sat,', 'Sun,']);
+const IMF_MONTHS = new Set([
+    'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+    'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec',
+]);
+function fixedDigits(value, length) {
+    if (value.length !== length)
+        return false;
+    for (const character of value) {
+        if (character < '0' || character > '9')
+            return false;
+    }
+    return true;
+}
+function validImfDate(weekday, day, month, year) {
+    return IMF_WEEKDAYS.has(weekday) &&
+        fixedDigits(day, 2) &&
+        IMF_MONTHS.has(month) &&
+        fixedDigits(year, 4);
+}
+function validImfTime(value) {
+    const parts = value.split(':');
+    return parts.length === 3 && parts.every((part) => fixedDigits(part, 2));
+}
+function isImfFixdate(value) {
+    const parts = value.split(' ');
+    if (parts.length !== 6)
+        return false;
+    const [weekday = '', day = '', month = '', year = '', time = '', zone = ''] = parts;
+    return validImfDate(weekday, day, month, year) && validImfTime(time) && zone === 'GMT';
+}
+export class DefaultRetryPolicy {
+    shouldRetry(attempt, elapsed, error) {
+        if (error instanceof TargetAuthError)
+            return { retry: false, delayMs: 0 };
+        if (!error.retryable)
+            return { retry: false, delayMs: 0 };
+        if (attempt >= MAX_RETRY_ATTEMPTS)
+            return { retry: false, delayMs: 0 };
+        if (elapsed >= MAX_RETRY_ELAPSED_MS)
+            return { retry: false, delayMs: 0 };
+        const requestedDelay = (error instanceof TargetRateLimitError || error instanceof TargetServerError) &&
+            error.retryAfterMs !== undefined
+            ? Math.max(0, error.retryAfterMs)
+            : Math.min(1000 * Math.pow(2, attempt), 10_000);
+        const remaining = MAX_RETRY_ELAPSED_MS - elapsed;
+        if (!Number.isFinite(requestedDelay) || requestedDelay >= remaining) {
+            return { retry: false, delayMs: 0 };
+        }
+        return { retry: true, delayMs: requestedDelay };
+    }
+}
+export function parseRetryAfter(header, clock) {
+    if (header === null)
+        return null;
+    const trimmed = header.trim();
+    if (trimmed.length === 0)
+        return null;
+    if (/^\d+$/.test(trimmed)) {
+        const delayMs = Number(trimmed) * 1000;
+        return Number.isSafeInteger(delayMs) ? delayMs : null;
+    }
+    if (!isImfFixdate(trimmed)) {
+        return null;
+    }
+    const date = Date.parse(trimmed);
+    if (!Number.isFinite(date) || new Date(date).toUTCString() !== trimmed)
+        return null;
+    const delayMs = date - clock.now();
+    return delayMs > 0 ? delayMs : 0;
+}