@the-open-engine/zeroshot 6.29.0 → 6.30.0

package/lib/target/hosted-run/client.js

@@ -1,158 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunIntentClient = exports.HostedRunHttpError = exports.TERMINAL_STATES = exports.UUID = void 0;
-exports.context = context;
-const credential_lock_ts_1 = require("../credential-lock.js");
-const credential_store_ts_1 = require("../credential-store.js");
-const discovery_ts_1 = require("../discovery.js");
-const target_registry_ts_1 = require("../target-registry.js");
-const target_session_ts_1 = require("../target-session.js");
-const bounded_json_ts_1 = require("../bounded-json.js");
-const MAX_RESPONSE_BYTES = 1024 * 1024;
-exports.UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-exports.TERMINAL_STATES = new Set(['succeeded', 'failed', 'cancelled', 'expired']);
-const RUN_INTENT_STATES = new Set([
-    'queued',
-    'provisioning',
-    'running',
-    'cancelling',
-    ...exports.TERMINAL_STATES,
-]);
-function wait(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
-class HostedRunHttpError extends Error {
-    status;
-    code;
-    constructor(status, message, code = null) {
-        super(message);
-        this.name = 'HostedRunHttpError';
-        this.status = status;
-        this.code = code;
-    }
-}
-exports.HostedRunHttpError = HostedRunHttpError;
-function validateIntent(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('Zero Cloud returned an invalid run intent');
-    }
-    const record = value;
-    if (typeof record['intent_id'] !== 'string' ||
-        !exports.UUID.test(record['intent_id']) ||
-        typeof record['state'] !== 'string' ||
-        !RUN_INTENT_STATES.has(record['state'])) {
-        throw new Error('Zero Cloud returned an invalid run intent');
-    }
-    const result = record['result'];
-    if (result !== null && (typeof result !== 'object' || Array.isArray(result))) {
-        throw new Error('Zero Cloud returned an invalid run intent result');
-    }
-    return record;
-}
-class RunIntentClient {
-    baseUrl;
-    organization;
-    tokenProvider;
-    fetch;
-    constructor(baseUrl, organization, tokenProvider, fetchImplementation) {
-        this.baseUrl = baseUrl.replace(/\/$/, '');
-        this.organization = organization;
-        this.tokenProvider = tokenProvider;
-        this.fetch = fetchImplementation;
-    }
-    async submit(body, submissionKey) {
-        let failure;
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            try {
-                return await this.request('', {
-                    method: 'POST',
-                    body: JSON.stringify(body),
-                    headers: { 'Idempotency-Key': submissionKey },
-                });
-            }
-            catch (error) {
-                failure = error;
-                if (error instanceof HostedRunHttpError && error.status < 500)
-                    throw error;
-                if (attempt === 0)
-                    await wait(250);
-            }
-        }
-        throw failure;
-    }
-    get(intentId) {
-        return this.request(`/${encodeURIComponent(intentId)}`, { method: 'GET' });
-    }
-    cancel(intentId) {
-        return this.request(`/${encodeURIComponent(intentId)}`, { method: 'DELETE' });
-    }
-    async request(suffix, options) {
-        const token = await this.tokenProvider.getAccessToken();
-        const url = `${this.baseUrl}/orgs/${encodeURIComponent(this.organization)}/run-intents${suffix}`;
-        const init = {
-            method: options.method,
-            redirect: 'error',
-            headers: {
-                Accept: 'application/json',
-                Authorization: `Bearer ${token}`,
-                'Content-Type': 'application/json',
-                ...options.headers,
-            },
-        };
-        if (options.body !== undefined)
-            init.body = options.body;
-        let response;
-        try {
-            response = await this.fetch(url, init);
-        }
-        catch (error) {
-            throw new Error(`Zero Cloud request failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        const body = await (0, bounded_json_ts_1.readBoundedJson)(response, MAX_RESPONSE_BYTES, {
-            tooLarge: () => new Error('Zero Cloud response exceeded 1 MiB'),
-            invalid: () => new Error('Zero Cloud returned invalid JSON'),
-        });
-        if (!response.ok) {
-            const problem = body;
-            const code = typeof problem['code'] === 'string' ? problem['code'] : null;
-            const message = typeof problem['message'] === 'string' ? problem['message'] : 'request failed';
-            throw new HostedRunHttpError(response.status, `Zero Cloud ${response.status}: ${message}`, code);
-        }
-        return validateIntent(body);
-    }
-}
-exports.RunIntentClient = RunIntentClient;
-async function context(targetName, deps) {
-    const environment = deps.environment ?? process.env;
-    const target = (0, target_registry_ts_1.getTarget)(targetName, deps.settings);
-    if (!target)
-        throw new Error(`Target "${targetName}" not found.`);
-    const http = {
-        fetch: (url, init) => (deps.fetch ?? globalThis.fetch)(url, init),
-    };
-    const discovery = await (0, discovery_ts_1.discoverTargetSessionEndpoints)(target.url, http);
-    const ephemeralToken = environment['ZEROSHOT_TARGET_ACCESS_TOKEN']?.trim();
-    const ephemeralOrganization = environment['ZEROSHOT_TARGET_ORGANIZATION']?.trim();
-    if ((ephemeralToken && !ephemeralOrganization) || (!ephemeralToken && ephemeralOrganization)) {
-        throw new Error('ZEROSHOT_TARGET_ACCESS_TOKEN and ZEROSHOT_TARGET_ORGANIZATION must be provided together');
-    }
-    let organization;
-    let tokenProvider;
-    if (ephemeralToken && ephemeralOrganization) {
-        organization = ephemeralOrganization;
-        tokenProvider = { getAccessToken: async () => ephemeralToken };
-    }
-    else {
-        if (!target.organization) {
-            throw new Error(`Login required. Run: zeroshot target login ${targetName}`);
-        }
-        organization = target.organization.id;
-        const credentials = await credential_store_ts_1.KeyringCredentialStore.create();
-        tokenProvider = (0, target_session_ts_1.getAccessTokenProvider)(targetName, target, credentials, () => (0, credential_lock_ts_1.acquireTargetLock)(target.id), { http, discoveryEndpoints: discovery });
-    }
-    return {
-        targetName,
-        organization,
-        client: new RunIntentClient(discovery.capsuleApiBaseUrl, organization, tokenProvider, deps.fetch ?? globalThis.fetch),
-    };
-}

package/lib/target/hosted-run/commands.d.ts

@@ -1,4 +0,0 @@
-import type { HostedOptions, HostedRunDependencies, HostedRunIntent } from './contracts.ts';
-export declare function runHosted(input: string, options: HostedOptions, deps: HostedRunDependencies): Promise<HostedRunIntent | Record<string, unknown> | null>;
-export declare function statusHostedRun(targetName: string, intentId: string, shouldFollow: boolean, deps: HostedRunDependencies): Promise<HostedRunIntent | Record<string, unknown> | null>;
-export declare function cancelHostedRun(targetName: string, intentId: string, deps: HostedRunDependencies): Promise<HostedRunIntent>;

package/lib/target/hosted-run/commands.js

@@ -1,113 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runHosted = runHosted;
-exports.statusHostedRun = statusHostedRun;
-exports.cancelHostedRun = cancelHostedRun;
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const client_ts_1 = require("./client.js");
-const input_ts_1 = require("./input.js");
-const DEFAULT_MODEL = 'openai/gpt-5.4';
-const RUN_INTENT_VERSION = 'zeroshot.run-intent/v1';
-const MAX_RUN_INTENT_BYTES = 1024 * 1024 + 64 * 1024;
-const RUN_INTENT_POLL_MS = 500;
-function output(deps, value) {
-    (deps.stdout ?? process.stdout).write(`${value}\n`);
-}
-function wait(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
-function displayState(intent) {
-    return intent.waiting_reason ? `${intent.state} (${intent.waiting_reason})` : intent.state;
-}
-function resumeCommand(value, intentId) {
-    return `zeroshot target status ${value.targetName} ${intentId} --follow`;
-}
-async function follow(value, initial, deps) {
-    let intent = initial;
-    let displayed = null;
-    for (;;) {
-        const state = displayState(intent);
-        if (state !== displayed) {
-            output(deps, `Run ${intent.intent_id}: ${state}`);
-            displayed = state;
-        }
-        if (client_ts_1.TERMINAL_STATES.has(intent.state))
-            break;
-        await (deps.delay ?? wait)(RUN_INTENT_POLL_MS);
-        intent = await value.client.get(intent.intent_id);
-    }
-    if (intent.state === 'succeeded') {
-        const summary = intent.result?.['summary'];
-        if (typeof summary === 'string' && summary)
-            output(deps, summary);
-        return intent.result;
-    }
-    const detail = intent.error_code ? ` (${intent.error_code})` : '';
-    throw new Error(`hosted run ${intent.state}${detail}`);
-}
-async function runHosted(input, options, deps) {
-    (0, input_ts_1.validateHostedOptions)(options);
-    const environment = deps.environment ?? process.env;
-    const resolved = await (0, input_ts_1.resolveHostedInput)(input, options, environment);
-    const value = await (0, client_ts_1.context)(options.target, deps);
-    const body = {
-        label: 'zeroshot-cli',
-        size: options.size ?? 'standard',
-        intent: {
-            version: RUN_INTENT_VERSION,
-            credentials: {
-                githubToken: (0, input_ts_1.githubToken)(environment),
-                openrouterApiKey: (0, input_ts_1.providerKey)(environment),
-                repository: resolved.repository,
-                model: options.model ?? DEFAULT_MODEL,
-            },
-            request: resolved.request,
-        },
-    };
-    if (Buffer.byteLength(JSON.stringify(body)) > MAX_RUN_INTENT_BYTES) {
-        throw new Error('hosted run intent exceeds the 1088 KiB upload limit');
-    }
-    const submissionKey = options.submissionKey ?? node_crypto_1.default.randomUUID();
-    let created;
-    try {
-        created = await value.client.submit(body, submissionKey);
-    }
-    catch (error) {
-        if (error instanceof client_ts_1.HostedRunHttpError)
-            throw error;
-        throw new Error(`${error instanceof Error ? error.message : String(error)}. Recover this submission by rerunning ` +
-            `the same command with --submission-key ${submissionKey}`, { cause: error });
-    }
-    output(deps, `Run ${created.intent_id} queued`);
-    output(deps, `Resume: ${resumeCommand(value, created.intent_id)}`);
-    if (options.detach)
-        return created;
-    output(deps, 'Ctrl+C disconnects without cancelling.');
-    return follow(value, created, deps);
-}
-async function statusHostedRun(targetName, intentId, shouldFollow, deps) {
-    if (!client_ts_1.UUID.test(intentId))
-        throw new Error('run intent id must be a UUID');
-    const value = await (0, client_ts_1.context)(targetName, deps);
-    const intent = await value.client.get(intentId);
-    if (!shouldFollow) {
-        output(deps, JSON.stringify(intent, null, 2));
-        return intent;
-    }
-    if (!client_ts_1.TERMINAL_STATES.has(intent.state)) {
-        output(deps, `Following ${intentId}; Ctrl+C disconnects without cancelling.`);
-        output(deps, `Resume: ${resumeCommand(value, intentId)}`);
-    }
-    return follow(value, intent, deps);
-}
-async function cancelHostedRun(targetName, intentId, deps) {
-    if (!client_ts_1.UUID.test(intentId))
-        throw new Error('run intent id must be a UUID');
-    const value = await (0, client_ts_1.context)(targetName, deps);
-    const intent = await value.client.cancel(intentId);
-    output(deps, `Run ${intent.intent_id}: ${displayState(intent)}`);
-    return intent;
-}

package/lib/target/hosted-run/contracts.d.ts

@@ -1,49 +0,0 @@
-import type { SettingsPort } from '../target-registry.ts';
-export interface HostedOptions {
-    readonly target?: string;
-    readonly repository?: string;
-    readonly model?: string;
-    readonly size?: string;
-    readonly submissionKey?: string;
-    readonly detach?: boolean;
-    readonly pr?: boolean;
-    readonly provider?: string;
-    readonly config?: string;
-    readonly docker?: boolean;
-    readonly worktree?: boolean;
-    readonly dockerImage?: string;
-    readonly strictSchema?: boolean;
-    readonly ship?: boolean;
-    readonly prBase?: string;
-    readonly mergeQueue?: boolean;
-    readonly closeIssue?: string;
-    readonly workers?: number;
-    readonly gitlab?: boolean;
-    readonly jira?: boolean;
-    readonly devops?: boolean;
-    readonly linear?: boolean;
-    readonly mount?: readonly string[];
-    readonly noMounts?: boolean;
-    readonly containerHome?: string;
-}
-export interface HostedRunIntent {
-    readonly intent_id: string;
-    readonly state: string;
-    readonly waiting_reason: string | null;
-    readonly result: Record<string, unknown> | null;
-    readonly error_code: string | null;
-    readonly [key: string]: unknown;
-}
-export interface HostedRunDependencies {
-    readonly settings: SettingsPort;
-    readonly environment?: NodeJS.ProcessEnv;
-    readonly fetch?: typeof globalThis.fetch;
-    readonly delay?: (milliseconds: number) => Promise<void>;
-    readonly stdout?: {
-        write(value: string): void;
-    };
-}
-export interface ResolvedInput {
-    readonly repository: string;
-    readonly request: Record<string, unknown>;
-}

package/lib/target/hosted-run/input.d.ts

@@ -1,5 +0,0 @@
-import type { HostedOptions, ResolvedInput } from './contracts.ts';
-export declare function resolveHostedInput(input: string, options: HostedOptions, environment?: NodeJS.ProcessEnv): Promise<ResolvedInput>;
-export declare function githubToken(environment: NodeJS.ProcessEnv): string;
-export declare function providerKey(environment: NodeJS.ProcessEnv): string;
-export declare function validateHostedOptions(options: HostedOptions): void;

package/lib/target/hosted-run/input.js

@@ -1,200 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveHostedInput = resolveHostedInput;
-exports.githubToken = githubToken;
-exports.providerKey = providerKey;
-exports.validateHostedOptions = validateHostedOptions;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const node_child_process_1 = require("node:child_process");
-const SUBMISSION_KEY = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{12}$/i;
-const CAPSULE_SIZES = new Set(['tiny', 'small', 'standard', 'large']);
-function validRepository(value) {
-    if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(value))
-        return false;
-    return value.split('/').every((segment) => segment !== '.' && segment !== '..');
-}
-function validModel(value) {
-    return (value.length <= 256 && /^[A-Za-z0-9][A-Za-z0-9._-]*\/[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value));
-}
-function repositoryFromRemote(cwd = process.cwd()) {
-    let remote;
-    try {
-        remote = (0, node_child_process_1.execFileSync)('git', ['remote', 'get-url', 'origin'], {
-            cwd,
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim();
-    }
-    catch {
-        return null;
-    }
-    const match = remote.match(/^(?:git@github\.com:|ssh:\/\/git@github\.com\/|https?:\/\/github\.com\/)([^/]+\/[^/]+?)(?:\.git)?$/);
-    const repository = match?.[1];
-    return repository && validRepository(repository) ? repository : null;
-}
-function isolationProfile(options) {
-    return options.pr ? 'isolation.pr@1' : 'isolation.worktree@1';
-}
-function providerProfile(options) {
-    return options.pr ? 'provider.codex-openrouter-pr@1' : 'provider.codex-openrouter@1';
-}
-function promptRequest(prompt, options) {
-    return {
-        source: 'prompt',
-        prompt,
-        artifacts: [],
-        isolationProfile: isolationProfile(options),
-        providerProfile: providerProfile(options),
-    };
-}
-function issueRequest(issue, options) {
-    return {
-        source: 'issue',
-        issue,
-        artifacts: [],
-        isolationProfile: isolationProfile(options),
-        providerProfile: providerProfile(options),
-    };
-}
-function issueInput(value, options) {
-    const shorthand = value.match(/^([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+)#([1-9][0-9]*)$/);
-    if (shorthand?.[1] && shorthand[2] && validRepository(shorthand[1])) {
-        const issue = `https://github.com/${shorthand[1]}/issues/${shorthand[2]}`;
-        return { repository: shorthand[1], request: issueRequest(issue, options) };
-    }
-    let url;
-    try {
-        url = new URL(value);
-    }
-    catch {
-        return null;
-    }
-    const match = url.pathname.match(/^\/([^/]+)\/([^/]+)\/issues\/([1-9][0-9]*)\/?$/);
-    const repository = match?.[1] && match[2] ? `${match[1]}/${match[2]}` : '';
-    if (url.hostname !== 'github.com' || !match || !validRepository(repository))
-        return null;
-    return { repository, request: issueRequest(url.href, options) };
-}
-async function readStdin() {
-    if (process.stdin.isTTY)
-        throw new Error('zeroshot run - requires piped input');
-    const chunks = [];
-    let bytes = 0;
-    for await (const chunk of process.stdin) {
-        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        bytes += value.length;
-        if (bytes > 1024 * 1024)
-            throw new Error('hosted task input exceeds 1 MiB');
-        chunks.push(value);
-    }
-    const value = Buffer.concat(chunks).toString('utf8').trim();
-    if (!value)
-        throw new Error('hosted task input is empty');
-    return value;
-}
-function readTaskFile(filename) {
-    const flags = node_fs_1.default.constants.O_RDONLY | (node_fs_1.default.constants.O_NOFOLLOW ?? 0) | (node_fs_1.default.constants.O_NONBLOCK ?? 0);
-    let descriptor;
-    try {
-        descriptor = node_fs_1.default.openSync(filename, flags);
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === 'ENOENT' || code === 'ENOTDIR' || code === 'EISDIR')
-            return null;
-        if (code === 'ELOOP')
-            throw new Error(`hosted task file must not be a symlink: ${filename}`);
-        throw error;
-    }
-    try {
-        if (!node_fs_1.default.fstatSync(descriptor).isFile())
-            return null;
-        return node_fs_1.default.readFileSync(descriptor, 'utf8');
-    }
-    finally {
-        node_fs_1.default.closeSync(descriptor);
-    }
-}
-async function resolveHostedInput(input, options, environment = process.env) {
-    const explicitIssue = issueInput(input, options);
-    if (explicitIssue)
-        return explicitIssue;
-    const repository = options.repository ?? environment['ZEROSHOT_REPOSITORY'] ?? repositoryFromRemote();
-    if (!validRepository(repository ?? '')) {
-        throw new Error('hosted runs need a GitHub repository; use org/repo#123, --repository owner/name, ' +
-            'ZEROSHOT_REPOSITORY, or run inside a GitHub checkout');
-    }
-    if (/^[1-9][0-9]*$/.test(input)) {
-        return { repository: repository, request: issueRequest(input, options) };
-    }
-    const prompt = input === '-' ? await readStdin() : (readTaskFile(node_path_1.default.resolve(input)) ?? input);
-    if (!prompt.trim())
-        throw new Error('hosted task input is empty');
-    return { repository: repository, request: promptRequest(prompt.trim(), options) };
-}
-function githubToken(environment) {
-    const configured = environment['GH_TOKEN'] ?? environment['GITHUB_TOKEN'];
-    if (configured?.trim())
-        return configured.trim();
-    try {
-        const token = (0, node_child_process_1.execFileSync)('gh', ['auth', 'token'], {
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim();
-        if (token)
-            return token;
-    }
-    catch {
-        // The actionable error below covers missing and unauthenticated gh alike.
-    }
-    throw new Error('hosted runs require GH_TOKEN/GITHUB_TOKEN or an authenticated gh CLI');
-}
-function providerKey(environment) {
-    const key = environment['OPENROUTER_API_KEY'];
-    if (!key?.trim())
-        throw new Error('hosted Codex runs require OPENROUTER_API_KEY');
-    return key.trim();
-}
-function validateHostedOptions(options) {
-    const unsupported = [
-        ['config', '--config'],
-        ['docker', '--docker'],
-        ['worktree', '--worktree'],
-        ['dockerImage', '--docker-image'],
-        ['strictSchema', '--strict-schema'],
-        ['ship', '--ship'],
-        ['prBase', '--pr-base'],
-        ['mergeQueue', '--merge-queue'],
-        ['closeIssue', '--close-issue'],
-        ['workers', '--workers'],
-        ['gitlab', '--gitlab'],
-        ['jira', '--jira'],
-        ['devops', '--devops'],
-        ['linear', '--linear'],
-        ['mount', '--mount'],
-        ['noMounts', '--no-mounts'],
-        ['containerHome', '--container-home'],
-    ];
-    const selected = unsupported
-        .filter(([name]) => options[name] !== undefined && options[name] !== false)
-        .map(([, flag]) => flag);
-    if (options.provider && options.provider !== 'codex')
-        selected.push('--provider');
-    if (selected.length)
-        throw new Error(`hosted runs do not support ${selected.join(', ')}`);
-    if (!options.target)
-        throw new Error('hosted runs require --target');
-    if (options.model !== undefined && !validModel(options.model)) {
-        throw new Error('hosted runs require an exact provider/model slug');
-    }
-    if (!CAPSULE_SIZES.has(options.size ?? 'standard')) {
-        throw new Error('hosted runs require --size tiny, small, standard, or large');
-    }
-    if (options.submissionKey !== undefined && !SUBMISSION_KEY.test(options.submissionKey)) {
-        throw new Error('hosted runs require --submission-key to be a random UUID');
-    }
-}

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

@@ -1,4 +0,0 @@
-export { HostedRunHttpError } from './hosted-run/client.ts';
-export { cancelHostedRun, runHosted, statusHostedRun } from './hosted-run/commands.ts';
-export { resolveHostedInput, validateHostedOptions } from './hosted-run/input.ts';
-export type { HostedOptions, HostedRunDependencies, HostedRunIntent, } from './hosted-run/contracts.ts';

package/lib/target/hosted-run.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateHostedOptions = exports.resolveHostedInput = exports.statusHostedRun = exports.runHosted = exports.cancelHostedRun = exports.HostedRunHttpError = void 0;
-var client_ts_1 = require("./hosted-run/client.js");
-Object.defineProperty(exports, "HostedRunHttpError", { enumerable: true, get: function () { return client_ts_1.HostedRunHttpError; } });
-var commands_ts_1 = require("./hosted-run/commands.js");
-Object.defineProperty(exports, "cancelHostedRun", { enumerable: true, get: function () { return commands_ts_1.cancelHostedRun; } });
-Object.defineProperty(exports, "runHosted", { enumerable: true, get: function () { return commands_ts_1.runHosted; } });
-Object.defineProperty(exports, "statusHostedRun", { enumerable: true, get: function () { return commands_ts_1.statusHostedRun; } });
-var input_ts_1 = require("./hosted-run/input.js");
-Object.defineProperty(exports, "resolveHostedInput", { enumerable: true, get: function () { return input_ts_1.resolveHostedInput; } });
-Object.defineProperty(exports, "validateHostedOptions", { enumerable: true, get: function () { return input_ts_1.validateHostedOptions; } });

package/src/target/bounded-json.ts

@@ -1,48 +0,0 @@
-interface BoundedJsonErrors {
-  readonly tooLarge: () => Error;
-  readonly invalid: () => Error;
-}
-
-export async function readBoundedJson(
-  response: Response,
-  maxBytes: number,
-  errors: BoundedJsonErrors
-): Promise<unknown> {
-  const declared = response.headers.get('content-length');
-  if (declared !== null && Number(declared) > maxBytes) throw errors.tooLarge();
-
-  const reader = response.body?.getReader();
-  if (!reader) {
-    const bytes = new Uint8Array(await response.arrayBuffer());
-    if (bytes.byteLength > maxBytes) throw errors.tooLarge();
-    return parseJson(bytes, errors);
-  }
-
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  for (;;) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    total += value.byteLength;
-    if (total > maxBytes) {
-      await reader.cancel();
-      throw errors.tooLarge();
-    }
-    chunks.push(value);
-  }
-  const bytes = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return parseJson(bytes, errors);
-}
-
-function parseJson(bytes: Uint8Array, errors: BoundedJsonErrors): unknown {
-  try {
-    return JSON.parse(new TextDecoder().decode(bytes));
-  } catch {
-    throw errors.invalid();
-  }
-}