@tangle-network/sandbox 0.60.31-develop.20261010074258.7991cf8 → 0.60.31-develop.20261010075509.de7486e

package/dist/agent/index.d.ts

@@ -1,7 +1,7 @@
-import { _ as SandboxSession, h as SandboxTaskSession, r as SandboxInstance } from "../sandbox-CrET4m65.js";
-import { D as CodeExecutionResult, E as CodeExecutionOptions, Ji as SessionInfo, Jr as SandboxFleetParent, O as CodeLanguage, Xi as SessionListOptions, d as BackendConfig, k as CodeResultPart, oo as BackendType } from "../types-BeWUGJ5S.js";
-import { i as Sandbox } from "../client-HewG9j9A.js";
-import { u as PreviewAuthorizer } from "../preview-DcT5Fb1W.js";
+import { _ as SandboxSession, h as SandboxTaskSession, r as SandboxInstance } from "../sandbox-WpE5rzUa.js";
+import { D as CodeExecutionResult, E as CodeExecutionOptions, Ji as SessionInfo, Jr as SandboxFleetParent, O as CodeLanguage, Xi as SessionListOptions, co as BackendType, d as BackendConfig, k as CodeResultPart } from "../types-i3Vs02b8.js";
+import { i as Sandbox } from "../client-B6JfkRhc.js";
+import { u as PreviewAuthorizer } from "../preview-B4yfnMgD.js";
 import * as _$_modelcontextprotocol_sdk_server_index_js0 from "@modelcontextprotocol/sdk/server/index.js";
 import { JSONSchema } from "zod/v4/core";
 import { ToolSet } from "ai";

package/dist/agent/index.js

@@ -1,8 +1,8 @@
-import { a as TOOL_SPECS, i as ALL_TOOL_SPECS, o as serializeToolResult, r as bindToolSpecs, t as createMcpServer } from "../mcp-local-DY1CnWBn.js";
-import { k as assertCurrentBackendType } from "../interactive-controller-CvW2-UfM.js";
+import { a as TOOL_SPECS, i as ALL_TOOL_SPECS, o as serializeToolResult, r as bindToolSpecs, t as createMcpServer } from "../mcp-local-DjryqUiY.js";
+import { E as assertCurrentBackendType } from "../interactive-controller-Dxt5sW2N.js";
 import { h as StateError, l as NotFoundError, v as ValidationError } from "../errors-Cq4hMysQ.js";
-import { n as Sandbox } from "../client-BzXVeXvo.js";
-import { t as SandboxInstance } from "../sandbox-CbuA-iZi.js";
+import { n as Sandbox } from "../client-p2d-6oAH.js";
+import { t as SandboxInstance } from "../sandbox-B6LlVm4f.js";
 import { z } from "zod";
 //#region src/agent/instances.ts
 const managers = /* @__PURE__ */ new WeakMap();

package/dist/agent/preview.d.ts

@@ -1,2 +1,2 @@
-import { _ as publishAgentPreview, a as previewOperationTool, c as AgentPreviewOptions, d as PreviewExecutionContext, f as PublishAgentPreviewOptions, g as listAgentPreviews, h as getAgentPreview, i as PreviewTool, l as PreviewAuthorizationRequest, m as ensureAgentPreview, n as PREVIEW_MCP_ALIAS, o as previewToolsForProfile, p as assertPreviewId, r as PREVIEW_TOOLS, s as AgentPreviewError, t as servePreviewMcp, u as PreviewAuthorizer, v as removeAgentPreview, y as resolveSelfSandbox } from "../preview-DcT5Fb1W.js";
+import { _ as publishAgentPreview, a as previewOperationTool, c as AgentPreviewOptions, d as PreviewExecutionContext, f as PublishAgentPreviewOptions, g as listAgentPreviews, h as getAgentPreview, i as PreviewTool, l as PreviewAuthorizationRequest, m as ensureAgentPreview, n as PREVIEW_MCP_ALIAS, o as previewToolsForProfile, p as assertPreviewId, r as PREVIEW_TOOLS, s as AgentPreviewError, t as servePreviewMcp, u as PreviewAuthorizer, v as removeAgentPreview, y as resolveSelfSandbox } from "../preview-B4yfnMgD.js";
 export { AgentPreviewError, AgentPreviewOptions, PREVIEW_MCP_ALIAS, PREVIEW_TOOLS, PreviewAuthorizationRequest, PreviewAuthorizer, PreviewExecutionContext, PreviewTool, PublishAgentPreviewOptions, assertPreviewId, ensureAgentPreview, getAgentPreview, listAgentPreviews, previewOperationTool, previewToolsForProfile, publishAgentPreview, removeAgentPreview, resolveSelfSandbox, servePreviewMcp };

package/dist/agent/preview.js

@@ -1,4 +1,4 @@
-import { a as listAgentPreviews, c as resolveSelfSandbox, i as getAgentPreview, n as assertPreviewId, o as publishAgentPreview, r as ensureAgentPreview, s as removeAgentPreview, t as AgentPreviewError } from "../preview-operations-CbTiBE-a.js";
+import { a as listAgentPreviews, c as resolveSelfSandbox, i as getAgentPreview, n as assertPreviewId, o as publishAgentPreview, r as ensureAgentPreview, s as removeAgentPreview, t as AgentPreviewError } from "../preview-operations-DqSo-IBm.js";
 import { agentProfileSchema } from "@tangle-network/agent-interface";
 //#region src/agent/preview-policy.ts
 /** Channel-neutral preview tool selection from a host-authored profile. */
@@ -66,7 +66,7 @@ async function servePreviewMcp(request, config) {
 	if (typeof config.authorize !== "function") throw new Error("Preview MCP requires a host authorization callback");
 	const tools = config.tools ?? PREVIEW_TOOLS;
 	if (!tools.length || tools.some((tool) => !PREVIEW_TOOLS.includes(tool))) throw new Error("Preview MCP requires an explicit nonempty preview-only tool grant");
-	const [{ createMcpServer }, { WebStandardStreamableHTTPServerTransport }] = await Promise.all([import("../mcp-local-DY1CnWBn.js").then((n) => n.n), import("@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js")]);
+	const [{ createMcpServer }, { WebStandardStreamableHTTPServerTransport }] = await Promise.all([import("../mcp-local-DjryqUiY.js").then((n) => n.n), import("@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js")]);
 	const handle = await createMcpServer(config.box, {
 		name: "tangle-previews",
 		sessionId: config.sessionId,

package/dist/{agent-run-outcome-C8Si8478.d.ts → agent-run-outcome-CGf6PAs8.d.ts}

@@ -1,4 +1,4 @@
-import { a as AgentQuestionRequest, ct as DurablePlanSnapshot, i as AgentApprovalRequirement, kr as SandboxEvent, o as AgentRunStatus, s as AgentToolInvocation } from "./types-BeWUGJ5S.js";
+import { a as AgentQuestionRequest, ct as DurablePlanSnapshot, i as AgentApprovalRequirement, kr as SandboxEvent, o as AgentRunStatus, s as AgentToolInvocation } from "./types-i3Vs02b8.js";
 import { InteractionRequest } from "@tangle-network/agent-interface";
 
 //#region src/agent-run-outcome.d.ts

package/dist/auth/index.d.ts

@@ -1,3 +1,3 @@
-import { i as materializeCliAuthBundle, n as assertCliAuthReferenceSupported, r as cliAuthReferenceSchema, t as CliAuthReference } from "../cli-auth-bundle-BMcIiB-I.js";
-import { _ as ReadTokenPayload, a as issueCollaborationToken, c as issueSessionScopedToken, d as AnyTokenPayload, f as BatchScopedTokenPayload, g as ProjectScopedTokenPayload, h as IssueCollaborationTokenOptions, i as issueBatchScopedToken, l as unsafeDecodeToken, m as CollaborationTokenPayload, n as getTokenTTL, o as issueProjectScopedToken, p as CollaborationAccess, r as isTokenExpiringSoon, s as issueReadToken, t as ProductTokenIssuer, u as verifyToken, v as SessionScopedTokenPayload, y as TokenScope } from "../index-BoQeoNOD.js";
+import { i as materializeCliAuthBundle, n as assertCliAuthReferenceSupported, r as cliAuthReferenceSchema, t as CliAuthReference } from "../cli-auth-bundle-ODe06Ts7.js";
+import { _ as ReadTokenPayload, a as issueCollaborationToken, c as issueSessionScopedToken, d as AnyTokenPayload, f as BatchScopedTokenPayload, g as ProjectScopedTokenPayload, h as IssueCollaborationTokenOptions, i as issueBatchScopedToken, l as unsafeDecodeToken, m as CollaborationTokenPayload, n as getTokenTTL, o as issueProjectScopedToken, p as CollaborationAccess, r as isTokenExpiringSoon, s as issueReadToken, t as ProductTokenIssuer, u as verifyToken, v as SessionScopedTokenPayload, y as TokenScope } from "../index-BgmgfYZZ.js";
 export { AnyTokenPayload, BatchScopedTokenPayload, CliAuthReference, CollaborationAccess, CollaborationTokenPayload, IssueCollaborationTokenOptions, ProductTokenIssuer, ProjectScopedTokenPayload, ReadTokenPayload, SessionScopedTokenPayload, TokenScope, assertCliAuthReferenceSupported, cliAuthReferenceSchema, getTokenTTL, isTokenExpiringSoon, issueBatchScopedToken, issueCollaborationToken, issueProjectScopedToken, issueReadToken, issueSessionScopedToken, materializeCliAuthBundle, unsafeDecodeToken, verifyToken };

package/dist/auth/index.js

@@ -1,4 +1,4 @@
-import { i as materializeCliAuthBundle, n as assertCliAuthReferenceSupported, r as cliAuthReferenceSchema } from "../cli-auth-bundle-BwIJkzAQ.js";
+import { i as materializeCliAuthBundle, n as assertCliAuthReferenceSupported, r as cliAuthReferenceSchema } from "../cli-auth-bundle-Dm8w5faq.js";
 //#region src/auth/tokens.ts
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();

package/dist/{browser-interactive-control-controller-DRCfxOQz.d.ts → browser-interactive-control-controller-JUW3gOGH.d.ts}

@@ -1,4 +1,4 @@
-import { r as TerminalStreamHandlers } from "./terminal-stream-B6bUr0hj.js";
+import { r as TerminalStreamHandlers } from "./terminal-stream-CV1pMSKC.js";
 import { AgentInteractiveSessionAttach, AgentInteractiveSessionControlClaimAcknowledgement, AgentInteractiveSessionStatus } from "@tangle-network/agent-interface";
 import { AgentInteractiveSessionControlClaim as AgentInteractiveSessionControlClaim$1, AgentInteractiveSessionControlClaimRequest as AgentInteractiveSessionControlClaimRequest$1, AgentInteractiveSessionRef as AgentInteractiveSessionRef$1 } from "@tangle-network/agent-interface/environment-interactive-control";
 

package/dist/chunked-upload-CfefWUE5.js

@@ -0,0 +1,435 @@
+import { _ as TimeoutError, c as NetworkError, d as QuotaError, m as ServerError, p as SandboxError, y as parseErrorResponse } from "./errors-Cq4hMysQ.js";
+//#region ../../../packages/runtime-contracts/dist/file-limits.js
+const MEBIBYTE$1 = 1024 * 1024;
+10 * MEBIBYTE$1;
+const FILE_DECODED_WRITE_MAX_BYTES = 5 * MEBIBYTE$1;
+5 * MEBIBYTE$1;
+10 * MEBIBYTE$1;
+5 * MEBIBYTE$1;
+//#endregion
+//#region ../../../packages/runtime-contracts/dist/request-limits.js
+/**
+* Raw WIRE/TRANSPORT caps: request-byte limits checked while the body
+* streams in (bodyLimit middleware, Content-Length, encoded proxy bodies),
+* before anything is parsed or decoded. Rejections against these carry
+* code `PAYLOAD_TOO_LARGE` (`payload-too-large.ts`) — the remedy is to
+* split the delivery. Decoded/parsed-content caps (code `FILE_TOO_LARGE`)
+* live in `file-io.ts`.
+*/
+const MEBIBYTE = 1024 * 1024;
+/**
+* Gateway (CF Worker) proxy cap on any request body it forwards — both
+* pass-through requests and route-constructed (`options.body`) proxy
+* payloads. Workers buffer forwarded bodies (streaming upstream stalls),
+* so this bounds Worker memory per request.
+*/
+const SANDBOX_PROXY_REQUEST_MAX_BYTES = MEBIBYTE;
+32 * MEBIBYTE;
+/**
+* Max assembled size of one chunked-upload session — the ceiling of the
+* sanctioned >1 MiB delivery path. Parts stage in sidecar memory until
+* commit, so this bounds per-session memory, not the destination
+* filesystem.
+*/
+const FILE_UPLOAD_SESSION_MAX_BYTES = 64 * MEBIBYTE;
+128 * MEBIBYTE;
+//#endregion
+//#region ../../../packages/runtime-contracts/dist/size-limit-errors.js
+/** Canonical error codes for wire-size and decoded-content rejections. */
+const PAYLOAD_TOO_LARGE_CODE = "PAYLOAD_TOO_LARGE";
+const FILE_TOO_LARGE_CODE = "FILE_TOO_LARGE";
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isPositiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isSizeLimitErrorBodyFor(value, code) {
+	if (!isRecord(value) || value.success !== false || !isRecord(value.error)) return false;
+	const error = value.error;
+	return error.code === code && typeof error.message === "string" && typeof error.surface === "string" && isPositiveInteger(error.limitBytes) && (error.actualBytes === void 0 || isPositiveInteger(error.actualBytes));
+}
+function isPayloadTooLargeErrorBody(value) {
+	return isSizeLimitErrorBodyFor(value, PAYLOAD_TOO_LARGE_CODE);
+}
+function isFileTooLargeErrorBody(value) {
+	return isSizeLimitErrorBodyFor(value, FILE_TOO_LARGE_CODE);
+}
+//#endregion
+//#region src/lib/chunked-upload.ts
+/**
+* Chunked upload — the sanctioned SDK path for delivering payloads larger
+* than the sandbox API's single-request body caps. Splits the payload into
+* server-sized parts against a `/fs/upload-session` session, PUTs each part
+* with transient retry, then commits with a whole-payload SHA-256 so the
+* runtime can verify nothing was dropped or reordered in transit.
+*
+* Browser/Worker-safe: no `node:` imports, no `Buffer`. Input normalizes to
+* a `Uint8Array` and hashes via Web Crypto (`crypto.subtle`), available in
+* browsers, Workers, and Node 18+ — the same environments this module must
+* run in unmodified.
+*/
+const DEFAULT_MAX_RETRIES = 4;
+const RETRY_BASE_MS = 250;
+const RETRY_MAX_MS = 2e3;
+/** Concurrent part PUTs — indexed parts + commit-time assembly make out-of-
+*  order completion safe; the cap keeps one session polite to the sidecar's
+*  staging budget. */
+const DEFAULT_UPLOAD_CONCURRENCY = 4;
+const MAX_UPLOAD_CONCURRENCY = 8;
+const delay = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(signal.reason ?? /* @__PURE__ */ new Error("aborted"));
+		return;
+	}
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	function onAbort() {
+		clearTimeout(timer);
+		reject(signal?.reason ?? /* @__PURE__ */ new Error("aborted"));
+	}
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+/** Transient part-upload failures worth retrying: rate-limit/budget (429),
+*  5xx, transport (network), and request timeouts — mirrors
+*  `isTransientWriteError` in `sandbox.ts`. A non-transient error (bad path,
+*  auth, checksum, containment) fails loud immediately. */
+function isTransientUploadError(rejection) {
+	return rejection instanceof QuotaError || rejection instanceof ServerError || rejection instanceof NetworkError || rejection instanceof TimeoutError;
+}
+function isChecksumMismatch(rejection) {
+	return rejection instanceof SandboxError && rejection.code === "CHECKSUM_MISMATCH";
+}
+/** Cheap size probe used for the pre-flight cap check, read directly off
+*  the input shape (`Blob.size` / `ArrayBuffer.byteLength` / view
+*  `byteLength`) so an oversized `Blob` never has its bytes materialized
+*  just to be rejected. Strings have no cheap length in UTF-8, so they're
+*  encoded once here (and once more in {@link normalizeToBytes} — an
+*  acceptable cost given strings are never the multi-MB case this path
+*  exists for). */
+function sizeOfInput(data) {
+	if (typeof data === "string") return new TextEncoder().encode(data).byteLength;
+	if (data instanceof ArrayBuffer) return data.byteLength;
+	if (ArrayBuffer.isView(data)) return data.byteLength;
+	return data.size;
+}
+/**
+* Normalizes to a `Uint8Array` backed by a plain (never shared)
+* `ArrayBuffer`. A caller-supplied view may be backed by a
+* `SharedArrayBuffer`, which `crypto.subtle.digest` and `fetch`'s
+* `BodyInit` both reject at the type level (and some engines reject at
+* runtime) — copying here keeps every downstream call on one concrete,
+* always-accepted buffer type.
+*/
+async function normalizeToBytes(data) {
+	if (typeof data === "string") return new Uint8Array(new TextEncoder().encode(data));
+	if (data instanceof ArrayBuffer) return new Uint8Array(data.slice(0));
+	if (ArrayBuffer.isView(data)) {
+		const copy = new Uint8Array(data.byteLength);
+		copy.set(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+		return copy;
+	}
+	return new Uint8Array(await data.arrayBuffer());
+}
+function webCryptoSubtle() {
+	const subtle = globalThis.crypto?.subtle;
+	if (!subtle) throw new Error("chunked upload requires Web Crypto (crypto.subtle) for SHA-256 hashing — available in browsers, Workers, and Node 18+");
+	return subtle;
+}
+/** Compress one part with the platform's native gzip — Web standard
+*  `CompressionStream` (browsers, Workers, Node 18+). Returns null when the
+*  runtime lacks the API: the caller degrades to an uncompressed part,
+*  which every server accepts (the encoding is optional by contract). */
+async function gzipPart(bytes) {
+	const CompressionStreamCtor = globalThis.CompressionStream;
+	if (!CompressionStreamCtor) return null;
+	try {
+		const compressed = new Blob([bytes]).stream().pipeThrough(new CompressionStreamCtor("gzip"));
+		const buffer = await new Response(compressed).arrayBuffer();
+		return new Uint8Array(buffer);
+	} catch {
+		return null;
+	}
+}
+/** Codec preference among the encodings the runtime advertised: zstd (better
+*  ratio AND speed) when the caller supplied a codec for it, then gzip. A
+*  runtime that advertises nothing predates wire compression and stores a
+*  part's bytes as sent, so it gets raw parts. Probing happens with the
+*  chosen codec — the same codec compresses every part. */
+function codecChain(accepted, codecs) {
+	const chain = [];
+	const negotiated = new Set(accepted ?? []);
+	if (codecs?.zstd && negotiated.has("zstd")) chain.push({
+		encoding: "zstd",
+		codec: codecs.zstd
+	});
+	if (negotiated.has("gzip")) chain.push({
+		encoding: "gzip",
+		codec: gzipPart
+	});
+	return chain;
+}
+/** Auto mode probes part 0 with the best available codec; if the ratio says
+*  incompressible (>= 95% of raw — model weights, JPEGs, packed archives),
+*  parts go raw and the CPU is not burned again. */
+async function planCompression(mode, firstRaw, accepted, codecs) {
+	if (mode === false) return {
+		encoding: null,
+		codec: null
+	};
+	if (firstRaw.byteLength === 0) return {
+		encoding: null,
+		codec: null
+	};
+	for (const candidate of codecChain(accepted, codecs)) {
+		const firstWire = await candidate.codec(firstRaw);
+		if (firstWire === null) continue;
+		if (mode === true || firstWire.byteLength < firstRaw.byteLength * .95) return {
+			encoding: candidate.encoding,
+			codec: candidate.codec,
+			firstPartWire: firstWire
+		};
+		return {
+			encoding: null,
+			codec: null
+		};
+	}
+	return {
+		encoding: null,
+		codec: null
+	};
+}
+function firstPart(bytes, partSize) {
+	return bytes.subarray(0, Math.min(partSize, bytes.byteLength));
+}
+async function sha256Hex(bytes) {
+	const digest = await webCryptoSubtle().digest("SHA-256", bytes);
+	return Array.from(new Uint8Array(digest)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+/**
+* Canonical size-cap bodies (413 `PAYLOAD_TOO_LARGE` / `FILE_TOO_LARGE`)
+* carry `surface`/`limitBytes`/`actualBytes` that the generic error parser
+* drops; fold them into the message before delegating to
+* `parseErrorResponse` for the rest (status→class mapping, retryAfterMs,
+* origin).
+*/
+async function parseUploadError(response) {
+	const bodyText = await response.text();
+	let parsedBody;
+	try {
+		parsedBody = JSON.parse(bodyText);
+	} catch {
+		parsedBody = void 0;
+	}
+	if (isPayloadTooLargeErrorBody(parsedBody) || isFileTooLargeErrorBody(parsedBody)) {
+		const { code, message, surface, limitBytes, actualBytes } = parsedBody.error;
+		const detail = typeof actualBytes === "number" ? `${message} (${surface}: ${actualBytes} of ${limitBytes} bytes)` : `${message} (${surface}: limit ${limitBytes} bytes)`;
+		return parseErrorResponse(response.status, JSON.stringify({
+			code,
+			message: detail
+		}), void 0, response.headers);
+	}
+	return parseErrorResponse(response.status, bodyText, void 0, response.headers);
+}
+async function initUploadSession(transport, remotePath, totalBytes, sha256, mode, signal) {
+	signal?.throwIfAborted();
+	const response = await transport.fetch("/fs/upload-session", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			path: remotePath,
+			mode,
+			totalBytes,
+			sha256
+		}),
+		signal
+	});
+	if (!response.ok) throw await parseUploadError(response);
+	return (await response.json()).data;
+}
+async function putPart(transport, uploadId, index, options, wire) {
+	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+	for (let attempt = 0;; attempt++) {
+		options.signal?.throwIfAborted();
+		try {
+			const response = await transport.fetch(`/fs/upload-session/${encodeURIComponent(uploadId)}/parts/${index}`, {
+				method: "PUT",
+				headers: {
+					"Content-Type": "application/octet-stream",
+					...wire.encoding ? { "Content-Encoding": wire.encoding } : {}
+				},
+				body: wire.body,
+				signal: options.signal
+			});
+			if (!response.ok) throw await parseUploadError(response);
+			return;
+		} catch (err) {
+			if (isTransientUploadError(err) && attempt < maxRetries) {
+				const retryAfterMs = err instanceof SandboxError ? err.retryAfterMs : void 0;
+				const backoff = Math.min(RETRY_BASE_MS * 2 ** attempt, RETRY_MAX_MS);
+				await delay(retryAfterMs ?? backoff, options.signal);
+				continue;
+			}
+			throw err;
+		}
+	}
+}
+function partCount(totalBytes, partSize) {
+	return Math.ceil(totalBytes / partSize);
+}
+/**
+* Upload every part with bounded concurrency. Parts are INDEXED and staged
+* independently server-side; assembly and the whole-payload SHA-256 happen
+* at commit — so out-of-order completion is safe by contract (the S3-
+* multipart property). Concurrency is capped (default 4, max 8) to stay a
+* polite citizen of the sidecar's per-session staging budget; `paceMs`
+* still spaces DISPATCHES for callers that need to throttle.
+*/
+async function uploadAllParts(transport, uploadId, bytes, partSize, totalParts, options, plan, skip) {
+	const totalBytes = bytes.byteLength;
+	const paceMs = options.paceMs ?? 0;
+	const concurrency = Math.min(Math.max(1, options.concurrency ?? DEFAULT_UPLOAD_CONCURRENCY), MAX_UPLOAD_CONCURRENCY);
+	let uploadedBytes = 0;
+	let wireBytes = 0;
+	let nextIndex = 0;
+	const results = /* @__PURE__ */ new Map();
+	const dispatch = async (index) => {
+		const start = index * partSize;
+		const end = Math.min(start + partSize, totalBytes);
+		const raw = bytes.subarray(start, end);
+		let wireBody = raw;
+		let encoding = null;
+		if (plan.codec && plan.encoding) if (index === 0 && plan.firstPartWire) {
+			wireBody = plan.firstPartWire;
+			encoding = plan.encoding;
+		} else {
+			const compressed = await plan.codec(raw);
+			if (compressed) {
+				wireBody = compressed;
+				encoding = plan.encoding;
+			}
+		}
+		wireBytes += wireBody.byteLength;
+		await putPart(transport, uploadId, index, options, {
+			body: wireBody,
+			encoding
+		});
+		uploadedBytes += end - start;
+		options.onProgress?.({
+			bytesUploaded: uploadedBytes,
+			totalBytes,
+			percentage: totalBytes === 0 ? 100 : Math.round(uploadedBytes / totalBytes * 100)
+		});
+	};
+	try {
+		while (nextIndex < totalParts || results.size > 0) {
+			options.signal?.throwIfAborted();
+			while (results.size < concurrency && nextIndex < totalParts) {
+				const index = nextIndex++;
+				if (skip?.has(index)) continue;
+				results.set(index, dispatch(index));
+				if (paceMs > 0) await delay(paceMs, options.signal);
+			}
+			const [headIndex, head] = results.entries().next().value;
+			results.delete(headIndex);
+			await head;
+		}
+	} catch (err) {
+		await Promise.allSettled(results.values());
+		throw err;
+	}
+	return wireBytes;
+}
+async function commitSession(transport, uploadId, totalParts, sha256, signal) {
+	signal?.throwIfAborted();
+	const response = await transport.fetch(`/fs/upload-session/${encodeURIComponent(uploadId)}/commit`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			totalParts,
+			sha256
+		}),
+		signal
+	});
+	if (!response.ok) throw await parseUploadError(response);
+	return (await response.json()).data;
+}
+/** Best-effort abort of an in-progress session — never masks the real
+*  failure that triggered it, and never itself throws. An orphaned session
+*  also self-expires server-side (`expiresAt`), so a failed DELETE here is
+*  not a leak, just deferred cleanup. */
+async function abortSession(transport, uploadId) {
+	try {
+		await transport.fetch(`/fs/upload-session/${encodeURIComponent(uploadId)}`, { method: "DELETE" });
+	} catch {}
+}
+/**
+* Upload arbitrary binary or text data to the sandbox via the chunked
+* upload-session protocol, verifying integrity with a whole-payload
+* SHA-256 at commit. Browser/Worker-safe and works identically over the
+* gateway proxy or a direct sidecar connection — see
+* {@link FileSystem.uploadData}.
+*
+* @param transport - Fetch-shaped adapter scoped to the sandbox runtime
+*   (paths are relative to it, e.g. `/fs/upload-session`).
+* @param remotePath - Destination path in the sandbox.
+* @param data - Payload to upload. Strings encode as UTF-8.
+* @param options - See {@link ChunkedUploadOptions}.
+* @throws {SandboxError} `PAYLOAD_TOO_LARGE` immediately (zero requests) if
+*   the payload exceeds {@link FILE_UPLOAD_SESSION_MAX_BYTES}; otherwise the
+*   typed error from whichever step (init/part/commit) failed after retries
+*   are exhausted.
+*/
+async function uploadChunked(transport, remotePath, data, options = {}) {
+	const estimatedSize = sizeOfInput(data);
+	if (estimatedSize > 67108864) throw new SandboxError(`Payload for ${remotePath} is ${estimatedSize} bytes, over the ${FILE_UPLOAD_SESSION_MAX_BYTES} byte chunked-upload session cap`, "PAYLOAD_TOO_LARGE", 413);
+	options.signal?.throwIfAborted();
+	const bytes = await normalizeToBytes(data);
+	options.signal?.throwIfAborted();
+	const sha256 = await sha256Hex(bytes);
+	const init = await initUploadSession(transport, remotePath, bytes.byteLength, sha256, options.mode, options.signal);
+	const totalParts = partCount(bytes.byteLength, init.partSize);
+	const plan = await planCompression(options.compression, firstPart(bytes, init.partSize), init.acceptedEncodings, options.codecs);
+	let wireBytes = 0;
+	options.onSession?.({
+		uploadId: init.uploadId,
+		partSize: init.partSize,
+		totalParts,
+		expiresAt: init.expiresAt
+	});
+	try {
+		wireBytes += await uploadAllParts(transport, init.uploadId, bytes, init.partSize, totalParts, options, plan);
+		try {
+			return {
+				...await commitSession(transport, init.uploadId, totalParts, sha256, options.signal),
+				wireBytes
+			};
+		} catch (err) {
+			if (!isChecksumMismatch(err)) throw err;
+			wireBytes += await uploadAllParts(transport, init.uploadId, bytes, init.partSize, totalParts, options, plan);
+			return {
+				...await commitSession(transport, init.uploadId, totalParts, sha256, options.signal),
+				wireBytes
+			};
+		}
+	} catch (err) {
+		if (options.keepSessionOnFailure) throw new ChunkedUploadInterruptedError(init.uploadId, err);
+		await abortSession(transport, init.uploadId);
+		throw err;
+	}
+}
+/** An upload that failed mid-flight while `keepSessionOnFailure` left the
+*  session (and its staged parts) alive. Carry `uploadId` straight into
+*  `resumeChunkedUpload` with the SAME payload to finish it. */
+var ChunkedUploadInterruptedError = class extends Error {
+	constructor(uploadId, cause) {
+		super(`Chunked upload interrupted; session ${uploadId} kept its staged parts — resume with resumeChunkedUpload and the same payload`);
+		this.uploadId = uploadId;
+		this.cause = cause;
+		this.name = "ChunkedUploadInterruptedError";
+	}
+};
+//#endregion
+export { planCompression as a, FILE_UPLOAD_SESSION_MAX_BYTES as c, partCount as i, SANDBOX_PROXY_REQUEST_MAX_BYTES as l, commitSession as n, putPart as o, initUploadSession as r, uploadChunked as s, abortSession as t, FILE_DECODED_WRITE_MAX_BYTES as u };

package/dist/chunked-upload-file-Bo2ROB52.js

@@ -0,0 +1,109 @@
+import { a as planCompression, c as FILE_UPLOAD_SESSION_MAX_BYTES, i as partCount, n as commitSession, o as putPart, r as initUploadSession, t as abortSession } from "./chunked-upload-CfefWUE5.js";
+import { createHash } from "node:crypto";
+import { open } from "node:fs/promises";
+//#region src/lib/chunked-upload-file.ts
+/**
+* Chunked upload from a LOCAL FILE (Node runtimes) — streams the payload off
+* disk: per-part reads at offsets into one reusable buffer, an incremental
+* node:crypto SHA-256, and the exact same wire protocol as
+* `lib/chunked-upload.ts` (whose session primitives this composes). The
+* whole payload never sits in RAM — the client memory ceiling is one part,
+* not the file.
+*
+* Browser/Worker callers use `uploadChunked` (Blob/ArrayBuffer inputs);
+* this module is the Node-side twin for the `fs.upload(localPath, …)` path.
+*/
+const DEFAULT_FILE_CONCURRENCY = 4;
+const MAX_FILE_CONCURRENCY = 8;
+async function uploadChunkedFromFile(transport, remotePath, localPath, options = {}) {
+	const handle = await open(localPath, "r");
+	try {
+		const { size } = await handle.stat();
+		if (size > 67108864) throw new Error(`File ${localPath} is ${size} bytes, over the ${FILE_UPLOAD_SESSION_MAX_BYTES} byte chunked-upload session cap`);
+		const hash = createHash("sha256");
+		const hashReader = handle.createReadStream({ autoClose: false });
+		for await (const chunk of hashReader) hash.update(chunk);
+		const sha256 = hash.digest("hex");
+		const init = await initUploadSession(transport, remotePath, size, sha256, options.mode, options.signal);
+		const totalParts = partCount(size, init.partSize);
+		options.onSession?.({
+			uploadId: init.uploadId,
+			partSize: init.partSize,
+			totalParts,
+			expiresAt: init.expiresAt
+		});
+		let wireBytes = 0;
+		const readPart = async (index) => {
+			const start = index * init.partSize;
+			const length = Math.min(init.partSize, size - start);
+			const buffer = Buffer.alloc(length);
+			const { bytesRead } = await handle.read(buffer, 0, length, start);
+			if (bytesRead !== length) throw new Error(`Short read for part ${index}: ${bytesRead} of ${length} bytes (file changed mid-upload?)`);
+			return buffer;
+		};
+		const part0 = await readPart(0);
+		const plan = await planCompression(options.compression, new Uint8Array(part0), init.acceptedEncodings, options.codecs);
+		const part0Wire = plan.firstPartWire ?? part0;
+		const encoding = plan.firstPartWire ? plan.encoding : null;
+		let uploadedBytes = 0;
+		const concurrency = Math.min(Math.max(1, options.concurrency ?? DEFAULT_FILE_CONCURRENCY), MAX_FILE_CONCURRENCY);
+		const report = (bytes) => {
+			uploadedBytes += bytes;
+			options.onProgress?.({
+				bytesUploaded: uploadedBytes,
+				totalBytes: size,
+				percentage: size === 0 ? 100 : Math.round(uploadedBytes / size * 100)
+			});
+		};
+		try {
+			if (totalParts > 0) {
+				wireBytes += part0Wire.length;
+				await putPart(transport, init.uploadId, 0, options, {
+					body: new Uint8Array(part0Wire),
+					encoding
+				});
+				report(part0.length);
+			}
+			let nextIndex = 1;
+			const inFlight = /* @__PURE__ */ new Set();
+			while (nextIndex < totalParts || inFlight.size > 0) {
+				options.signal?.throwIfAborted();
+				while (inFlight.size < concurrency && nextIndex < totalParts) {
+					const index = nextIndex++;
+					const task = (async () => {
+						const raw = await readPart(index);
+						let body = new Uint8Array(raw);
+						let partEncoding = null;
+						if (plan.codec && plan.encoding) {
+							const compressed = await plan.codec(body);
+							if (compressed) {
+								body = compressed;
+								partEncoding = plan.encoding;
+							}
+						}
+						wireBytes += body.byteLength;
+						await putPart(transport, init.uploadId, index, options, {
+							body,
+							encoding: partEncoding
+						});
+						report(raw.length);
+					})();
+					inFlight.add(task);
+					task.finally(() => inFlight.delete(task)).catch(() => void 0);
+				}
+				await inFlight.values().next().value;
+			}
+			return {
+				...await commitSession(transport, init.uploadId, totalParts, sha256, options.signal),
+				wireBytes
+			};
+		} catch (err) {
+			await abortSession(transport, init.uploadId);
+			throw err;
+		}
+	} finally {
+		await handle.close();
+	}
+}
+//#endregion
+export { uploadChunkedFromFile };

package/dist/{client-HewG9j9A.d.ts → client-B6JfkRhc.d.ts}

@@ -1,8 +1,8 @@
-import { l as TraceExportResult, n as HttpClient, r as SandboxInstance, u as TraceExportSink } from "./sandbox-CrET4m65.js";
-import { $r as SandboxFleetToken, Ar as SandboxFleetAgent, B as CreateSandboxOptions, Bt as FleetDispatchStreamOptions, Ca as TokenRefreshHandler, En as ListSandboxOptions, F as CreateIntelligenceReportOptions, Ft as FleetAgentResult, G as DeleteMatchingSandboxesFilter, Gr as SandboxFleetManifest, Gt as FleetMachineId, Ht as FleetDriveTurnRequest, I as CreateRequestOptions, Ir as SandboxFleetDispatchResponse, Jn as PromptResult, Jr as SandboxFleetParent, Jt as FleetRunEvent, K as DeleteMatchingSandboxesOptions, Kn as PromptInputPart, Kt as FleetPromptDispatchOptions, L as CreateSandboxFleetOptions, Lr as SandboxFleetDriverCapability, Lt as FleetDispatchCancelResult, M as ConversationTurnOptions, Mr as SandboxFleetArtifact, N as ConversationTurnResult, Nr as SandboxFleetArtifactSpec, Nt as FleetAgentId, Or as SandboxEnvironment, Pr as SandboxFleetCostEstimate, Qr as SandboxFleetSpend, R as CreateSandboxFleetTokenOptions, Ri as SecretsManager, Rt as FleetDispatchResultBuffer, Si as SandboxShapesInfo, Tn as ListSandboxFleetOptions, Ur as SandboxFleetMachineRecord, Ut as FleetExecDispatchOptions, Vt as FleetDriveTurnOutcome, Wr as SandboxFleetMachineSpec, Wt as FleetExecDispatchResult, Xr as SandboxFleetPolicy, Yt as FleetRunOptions, _i as SandboxRunGeneration, _n as IntelligenceReport, ar as ReapExpiredSandboxFleetsResult, b as BatchRunRequest, br as SandboxConfig, ca as SshKeysManager, ci as SandboxFleetWorkspaceSnapshotResult, d as BackendConfig, ei as SandboxFleetTraceBundle, er as PublicTemplateInfo, fa as SubscriptionInfo, ii as SandboxFleetUsage, ir as ReapExpiredSandboxFleetsOptions, ka as UsageInfo, l as AttachSandboxFleetMachineOptions, li as SandboxIdentity, nr as PublishPublicTemplateOptions, oi as SandboxFleetWorkspaceReconcileResult, or as ReconcileSandboxFleetsOptions, q as DeleteMatchingSandboxesResult, qn as PromptOptions, qr as SandboxFleetOperationsSummary, qt as FleetPromptDispatchResult, ri as SandboxFleetTraceOptions, rr as PublishPublicTemplateVersionOptions, si as SandboxFleetWorkspaceRestoreResult, sr as ReconcileSandboxFleetsResult, to as BatchEvent, tr as PublicTemplateVersionInfo, ui as SandboxInfo, v as BatchResult, vn as IntelligenceReportBudget, vt as ExecOptions, xn as IntelligenceReportWindow, y as BatchRunOptions, yn as IntelligenceReportCompareTo, yt as ExecResult, z as CreateSandboxFleetWithCoordinatorOptions, zr as SandboxFleetInfo, zt as FleetDispatchResultBufferOptions } from "./types-BeWUGJ5S.js";
-import { l as ScopedToken, s as MintInteractiveSessionTokenOptions } from "./terminal-stream-B6bUr0hj.js";
-import { I as LinesClient } from "./lines-DCxU0xIV.js";
-import { f as SandboxError } from "./errors-D7RVedpR.js";
+import { l as TraceExportResult, n as HttpClient, r as SandboxInstance, u as TraceExportSink } from "./sandbox-WpE5rzUa.js";
+import { $r as SandboxFleetToken, Ar as SandboxFleetAgent, B as CreateSandboxOptions, Bt as FleetDispatchStreamOptions, Ca as TokenRefreshHandler, En as ListSandboxOptions, F as CreateIntelligenceReportOptions, Ft as FleetAgentResult, G as DeleteMatchingSandboxesFilter, Gr as SandboxFleetManifest, Gt as FleetMachineId, Ht as FleetDriveTurnRequest, I as CreateRequestOptions, Ir as SandboxFleetDispatchResponse, Jn as PromptResult, Jr as SandboxFleetParent, Jt as FleetRunEvent, K as DeleteMatchingSandboxesOptions, Kn as PromptInputPart, Kt as FleetPromptDispatchOptions, L as CreateSandboxFleetOptions, Lr as SandboxFleetDriverCapability, Lt as FleetDispatchCancelResult, M as ConversationTurnOptions, Mr as SandboxFleetArtifact, N as ConversationTurnResult, Nr as SandboxFleetArtifactSpec, Nt as FleetAgentId, Or as SandboxEnvironment, Pr as SandboxFleetCostEstimate, Qr as SandboxFleetSpend, R as CreateSandboxFleetTokenOptions, Ri as SecretsManager, Rt as FleetDispatchResultBuffer, Si as SandboxShapesInfo, Tn as ListSandboxFleetOptions, Ur as SandboxFleetMachineRecord, Ut as FleetExecDispatchOptions, Vt as FleetDriveTurnOutcome, Wr as SandboxFleetMachineSpec, Wt as FleetExecDispatchResult, Xr as SandboxFleetPolicy, Yt as FleetRunOptions, _i as SandboxRunGeneration, _n as IntelligenceReport, ar as ReapExpiredSandboxFleetsResult, b as BatchRunRequest, br as SandboxConfig, ca as SshKeysManager, ci as SandboxFleetWorkspaceSnapshotResult, d as BackendConfig, ei as SandboxFleetTraceBundle, er as PublicTemplateInfo, fa as SubscriptionInfo, ii as SandboxFleetUsage, ir as ReapExpiredSandboxFleetsOptions, ka as UsageInfo, l as AttachSandboxFleetMachineOptions, li as SandboxIdentity, nr as PublishPublicTemplateOptions, oi as SandboxFleetWorkspaceReconcileResult, or as ReconcileSandboxFleetsOptions, q as DeleteMatchingSandboxesResult, qn as PromptOptions, qr as SandboxFleetOperationsSummary, qt as FleetPromptDispatchResult, ri as SandboxFleetTraceOptions, ro as BatchEvent, rr as PublishPublicTemplateVersionOptions, si as SandboxFleetWorkspaceRestoreResult, sr as ReconcileSandboxFleetsResult, tr as PublicTemplateVersionInfo, ui as SandboxInfo, v as BatchResult, vn as IntelligenceReportBudget, vt as ExecOptions, xn as IntelligenceReportWindow, y as BatchRunOptions, yn as IntelligenceReportCompareTo, yt as ExecResult, z as CreateSandboxFleetWithCoordinatorOptions, zr as SandboxFleetInfo, zt as FleetDispatchResultBufferOptions } from "./types-i3Vs02b8.js";
+import { l as ScopedToken, s as MintInteractiveSessionTokenOptions } from "./terminal-stream-CV1pMSKC.js";
+import { I as LinesClient } from "./lines-BOWMNDp5.js";
+import { f as SandboxError } from "./errors-CRssX9qs.js";
 import { AgentInteractiveSessionRef, AgentProfile } from "@tangle-network/agent-interface";
 import { z } from "zod";