@tangle-network/sandbox 0.10.4 → 0.10.5-develop.20260715115519.fee3d86

package/dist/{runtime-api-CYA2DUQw.js → runtime-api-BWq4XSrb.js}

@@ -1,4 +1,5 @@
-import { f as ValidationError, l as ServerError, p as parseErrorResponse } from "./errors-DSz87Rkk.js";
+import { c as SandboxError, d as TimeoutError, f as ValidationError, i as NetworkError, l as ServerError, p as parseErrorResponse, s as QuotaError } from "./errors-wd266B9Q.js";
+import { FILE_UPLOAD_SESSION_MAX_BYTES, isFileTooLargeErrorBody, isPayloadTooLargeErrorBody } from "@tangle-network/runtime-contracts";
 //#region src/backend-config.ts
 const LEGACY_QUESTION_ALIAS_KEY = ["question", "Channel"].join("");
 function parseModelString(model) {
@@ -153,6 +154,238 @@ function serializeForSidecar(profile) {
 	return toBackendProfile(profile);
 }
 //#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;
+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(err) {
+	return err instanceof QuotaError || err instanceof ServerError || err instanceof NetworkError || err instanceof TimeoutError;
+}
+function isChecksumMismatch(err) {
+	return err instanceof SandboxError && err.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 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;
+}
+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, chunk, options) {
+	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" },
+				body: chunk,
+				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);
+}
+async function uploadAllParts(transport, uploadId, bytes, partSize, totalParts, options) {
+	const totalBytes = bytes.byteLength;
+	const paceMs = options.paceMs ?? 0;
+	let uploadedBytes = 0;
+	let started = false;
+	for (let index = 0; index < totalParts; index++) {
+		if (started && paceMs > 0) await delay(paceMs, options.signal);
+		started = true;
+		const start = index * partSize;
+		const end = Math.min(start + partSize, totalBytes);
+		await putPart(transport, uploadId, index, bytes.subarray(start, end), options);
+		uploadedBytes += end - start;
+		options.onProgress?.({
+			bytesUploaded: uploadedBytes,
+			totalBytes,
+			percentage: totalBytes === 0 ? 100 : Math.round(uploadedBytes / totalBytes * 100)
+		});
+	}
+}
+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 > FILE_UPLOAD_SESSION_MAX_BYTES) 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);
+	try {
+		await uploadAllParts(transport, init.uploadId, bytes, init.partSize, totalParts, options);
+		try {
+			return await commitSession(transport, init.uploadId, totalParts, sha256, options.signal);
+		} catch (err) {
+			if (!isChecksumMismatch(err)) throw err;
+			await uploadAllParts(transport, init.uploadId, bytes, init.partSize, totalParts, options);
+			return await commitSession(transport, init.uploadId, totalParts, sha256, options.signal);
+		}
+	} catch (err) {
+		await abortSession(transport, init.uploadId);
+		throw err;
+	}
+}
+//#endregion
 //#region src/runtime-api.ts
 /** Internal typed client for routes served by a sandbox runtime. */
 var SandboxRuntimeApi = class {
@@ -203,7 +436,7 @@ var SandboxRuntimeApi = class {
 				method: "POST",
 				body: JSON.stringify({
 					paths: chunk,
-					...options.encoding ? { encoding: options.encoding } : {}
+					encoding: options.encoding ?? "utf8"
 				})
 			});
 			for (const [path, result] of Object.entries(payload.data.files)) if (result.success) files.push({
@@ -249,6 +482,25 @@ var SandboxRuntimeApi = class {
 			})
 		})).data;
 	}
+	/**
+	* Upload in-memory binary or text data to the sandbox over the chunked
+	* upload-session protocol — the browser/Worker-safe sanctioned path for
+	* payloads over ~1 MiB, sized to clear the gateway proxy's per-request cap
+	* (parts stay under {@link FILE_UPLOAD_PART_MAX_BYTES}). Binary-safe:
+	* accepts a `Blob`, `ArrayBuffer`, `ArrayBufferView`, or UTF-8 `string`.
+	* Delegates to the shared `uploadChunked` engine in `lib/chunked-upload.js`,
+	* wired to this client's `transport.fetch` so requests carry the same
+	* scoped-token `Authorization` header and base URL as every other method
+	* on this class (e.g. {@link SandboxRuntimeApi.writeFile}) — works
+	* identically over the gateway proxy or a direct sidecar connection.
+	*
+	* @throws {SandboxError} `PAYLOAD_TOO_LARGE` immediately, before any
+	*   request, if the payload exceeds the chunked-upload session cap.
+	*/
+	async uploadData(remotePath, data, options) {
+		await this.transport.ensureRunning();
+		return uploadChunked({ fetch: (path, init) => this.transport.fetch(path, init) }, remotePath, data, options);
+	}
 	async deleteFile(path, options = {}) {
 		await this.transport.ensureRunning();
 		const params = new URLSearchParams();
@@ -259,6 +511,19 @@ var SandboxRuntimeApi = class {
 			body: JSON.stringify({ path })
 		});
 	}
+	async renameFile(sourcePath, destinationPath, options = {}) {
+		await this.transport.ensureRunning();
+		const params = new URLSearchParams();
+		if (options.sessionId) params.set("sessionId", options.sessionId);
+		const query = params.toString();
+		return (await this.json(`/files/rename${query ? `?${query}` : ""}`, {
+			method: "POST",
+			body: JSON.stringify({
+				sourcePath,
+				destinationPath
+			})
+		})).data;
+	}
 	async fileTree(path, options = {}) {
 		if (options.maxDepth !== void 0 && (!Number.isInteger(options.maxDepth) || options.maxDepth < 1 || options.maxDepth > 20)) throw new ValidationError("maxDepth must be an integer between 1 and 20");
 		await this.transport.ensureRunning();
@@ -272,6 +537,7 @@ var SandboxRuntimeApi = class {
 		const info = normalizeSessionInfo(await this.json("/agents/sessions", {
 			method: "POST",
 			body: JSON.stringify({
+				...options.sessionId !== void 0 ? { sessionId: options.sessionId } : {},
 				...options.title !== void 0 ? { title: options.title } : {},
 				...options.parentId !== void 0 ? { parentID: options.parentId } : {},
 				backend: normalizeRuntimeBackendConfig(options.backend)
@@ -431,4 +697,4 @@ function normalizeSessionInfo(raw) {
 	};
 }
 //#endregion
-export { serializeForSidecar as i, normalizeSessionInfo as n, normalizeRuntimeBackendConfig as r, SandboxRuntimeApi as t };
+export { serializeForSidecar as a, normalizeRuntimeBackendConfig as i, normalizeSessionInfo as n, uploadChunked as r, SandboxRuntimeApi as t };

package/dist/runtime.d.ts

@@ -1,6 +1,31 @@
-import { A as CommitTaskSessionOptions, Ai as WriteFileOptions, Ar as SandboxTerminalInfo, B as CreateTaskSessionOptions, Dr as SandboxRuntimeProfileList, Gr as SendSessionMessageRequest, Kr as SentSessionMessage, Kt as ListMessagesOptions, Mr as SandboxTerminalRequestOptions, Qr as SessionMessage, Tr as SandboxRuntimeHealth, Wr as SendSessionMessageOptions, Xr as SessionInfo, br as SandboxPortBinding, di as TaskSessionChanges, dt as FileWriteResult, fi as TaskSessionCommitResult, it as FileReadBatchResult, jr as SandboxTerminalManager, kr as SandboxTerminalCreateOptions, lt as FileTreeOptions, mi as TaskSessionInfo, rt as FileReadBatchOptions, ut as FileTreeResult, z as CreateSessionOptions } from "./types-BvSoEHz8.js";
-import { a as NotFoundError, c as SandboxError, d as ServerError, f as StateError, i as NetworkError, l as SandboxErrorJson, m as ValidationError, n as CapabilityError, o as PartialFailureError, p as TimeoutError, s as QuotaError, t as AuthError, u as SandboxFailureDetail } from "./errors--P_nbLzM.js";
+import { Ai as UploadProgress, E as ChunkedUploadResult, Fr as SandboxTerminalManager, H as CreateTaskSessionOptions, Ir as SandboxTerminalRequestOptions, Jr as SendSessionMessageOptions, M as CommitTaskSessionOptions, Nr as SandboxTerminalCreateOptions, Pi as WriteFileOptions, Pr as SandboxTerminalInfo, T as ChunkedUploadOptions, V as CreateSessionOptions, Xr as SentSessionMessage, Yr as SendSessionMessageRequest, Yt as ListMessagesOptions, at as FileReadBatchOptions, ei as SessionInfo, ft as FileTreeOptions, gi as TaskSessionCommitResult, hi as TaskSessionChanges, jn as RenameOptions, jr as SandboxRuntimeProfileList, kr as SandboxRuntimeHealth, lt as FileRenameResult, mt as FileWriteResult, ni as SessionMessage, ot as FileReadBatchResult, pt as FileTreeResult, vi as TaskSessionInfo, wr as SandboxPortBinding } from "./types-LNLeU9Ub.js";
+import { a as NotFoundError, c as SandboxError, d as ServerError, f as StateError, i as NetworkError, l as SandboxErrorJson, m as ValidationError, n as CapabilityError, o as PartialFailureError, p as TimeoutError, s as QuotaError, t as AuthError, u as SandboxFailureDetail } from "./errors-CNCz3Ms9.js";
 
+//#region src/lib/chunked-upload.d.ts
+/** The transport a caller wires this module to — {@link SandboxInstance.runtimeFetch}
+ *  in the SDK, or any fetch-shaped adapter in a standalone consumer. */
+interface ChunkedUploadTransport {
+  fetch(path: string, init?: RequestInit): Promise<Response>;
+}
+/**
+ * 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.
+ */
+declare function uploadChunked(transport: ChunkedUploadTransport, remotePath: string, data: Blob | ArrayBuffer | ArrayBufferView | string, options?: ChunkedUploadOptions): Promise<ChunkedUploadResult>;
+//#endregion
 //#region src/runtime-api.d.ts
 interface RuntimeTransport {
   ensureRunning(): Promise<void>;
@@ -16,7 +41,24 @@ declare class SandboxRuntimeApi {
   profiles(): Promise<SandboxRuntimeProfileList>;
   readFiles(paths: string[], options?: FileReadBatchOptions): Promise<FileReadBatchResult>;
   writeFile(path: string, content: string, options?: WriteFileOptions): Promise<FileWriteResult>;
+  /**
+   * Upload in-memory binary or text data to the sandbox over the chunked
+   * upload-session protocol — the browser/Worker-safe sanctioned path for
+   * payloads over ~1 MiB, sized to clear the gateway proxy's per-request cap
+   * (parts stay under {@link FILE_UPLOAD_PART_MAX_BYTES}). Binary-safe:
+   * accepts a `Blob`, `ArrayBuffer`, `ArrayBufferView`, or UTF-8 `string`.
+   * Delegates to the shared `uploadChunked` engine in `lib/chunked-upload.js`,
+   * wired to this client's `transport.fetch` so requests carry the same
+   * scoped-token `Authorization` header and base URL as every other method
+   * on this class (e.g. {@link SandboxRuntimeApi.writeFile}) — works
+   * identically over the gateway proxy or a direct sidecar connection.
+   *
+   * @throws {SandboxError} `PAYLOAD_TOO_LARGE` immediately, before any
+   *   request, if the payload exceeds the chunked-upload session cap.
+   */
+  uploadData(remotePath: string, data: Blob | ArrayBuffer | ArrayBufferView | string, options?: ChunkedUploadOptions): Promise<ChunkedUploadResult>;
   deleteFile(path: string, options?: Pick<WriteFileOptions, "sessionId">): Promise<void>;
+  renameFile(sourcePath: string, destinationPath: string, options?: RenameOptions): Promise<FileRenameResult>;
   fileTree(path: string, options?: FileTreeOptions): Promise<FileTreeResult>;
   createSession(options: CreateSessionOptions): Promise<SessionInfo>;
   messages(id: string, options?: Omit<ListMessagesOptions, "sessionId">): Promise<SessionMessage[]>;
@@ -36,9 +78,9 @@ declare class SandboxRuntimeApi {
 //#endregion
 //#region src/runtime-client.d.ts
 interface SandboxRuntimeClientConfig {
-  /** Browser-safe proxy base returned by `box.mintScopedToken()`. */
+  /** Browser-safe proxy base returned by a runtime-scoped token mint. */
   baseUrl: string;
-  /** Short-lived scoped token returned by `box.mintScopedToken()`. */
+  /** Short-lived `session-runtime` or `read-only` token. */
   token: string;
   /** Request timeout in milliseconds. Defaults to 30 seconds. */
   timeoutMs?: number;
@@ -49,7 +91,9 @@ interface SandboxRuntimeClientConfig {
  * Browser- and Worker-safe client for one sandbox runtime.
  *
  * Construct it from the scoped token response returned by
- * `box.mintScopedToken()`. The full Sandbox API key remains server-side.
+ * `box.mintScopedToken({ scope: "session-runtime", sessionId })` or
+ * `box.mintScopedToken({ scope: "read-only" })`. The full Sandbox API key
+ * remains server-side.
  */
 declare class SandboxRuntimeClient extends SandboxRuntimeApi {
   private readonly auth;
@@ -59,4 +103,4 @@ declare class SandboxRuntimeClient extends SandboxRuntimeApi {
 }
 declare function createSandboxRuntimeClient(config: SandboxRuntimeClientConfig): SandboxRuntimeClient;
 //#endregion
-export { AuthError, CapabilityError, type FileReadBatchOptions, type FileReadBatchResult, type FileTreeOptions, type FileTreeResult, type FileWriteResult, type ListMessagesOptions, NetworkError, NotFoundError, PartialFailureError, QuotaError, SandboxError, type SandboxErrorJson, type SandboxFailureDetail, SandboxRuntimeClient, type SandboxRuntimeClientConfig, type SandboxRuntimeHealth, type SandboxTerminalCreateOptions, type SandboxTerminalInfo, type SandboxTerminalManager, type SandboxTerminalRequestOptions, ServerError, type SessionMessage, StateError, TimeoutError, ValidationError, type WriteFileOptions, createSandboxRuntimeClient };
+export { AuthError, CapabilityError, type ChunkedUploadOptions, type ChunkedUploadResult, type ChunkedUploadTransport, type FileReadBatchOptions, type FileReadBatchResult, type FileRenameResult, type FileTreeOptions, type FileTreeResult, type FileWriteResult, type ListMessagesOptions, NetworkError, NotFoundError, PartialFailureError, QuotaError, type RenameOptions, SandboxError, type SandboxErrorJson, type SandboxFailureDetail, SandboxRuntimeClient, type SandboxRuntimeClientConfig, type SandboxRuntimeHealth, type SandboxTerminalCreateOptions, type SandboxTerminalInfo, type SandboxTerminalManager, type SandboxTerminalRequestOptions, ServerError, type SessionMessage, StateError, TimeoutError, type UploadProgress, ValidationError, type WriteFileOptions, createSandboxRuntimeClient, uploadChunked };

package/dist/runtime.js

@@ -1,5 +1,5 @@
-import { t as SandboxRuntimeApi } from "./runtime-api-CYA2DUQw.js";
-import { a as NotFoundError, c as SandboxError, d as TimeoutError, f as ValidationError, i as NetworkError, l as ServerError, n as CapabilityError, o as PartialFailureError, s as QuotaError, t as AuthError, u as StateError } from "./errors-DSz87Rkk.js";
+import { r as uploadChunked, t as SandboxRuntimeApi } from "./runtime-api-BWq4XSrb.js";
+import { a as NotFoundError, c as SandboxError, d as TimeoutError, f as ValidationError, i as NetworkError, l as ServerError, n as CapabilityError, o as PartialFailureError, s as QuotaError, t as AuthError, u as StateError } from "./errors-wd266B9Q.js";
 //#region src/runtime-client.ts
 const DEFAULT_RUNTIME_TIMEOUT_MS = 3e4;
 function requireToken(token) {
@@ -28,7 +28,9 @@ function requireTimeout(timeoutMs) {
 * Browser- and Worker-safe client for one sandbox runtime.
 *
 * Construct it from the scoped token response returned by
-* `box.mintScopedToken()`. The full Sandbox API key remains server-side.
+* `box.mintScopedToken({ scope: "session-runtime", sessionId })` or
+* `box.mintScopedToken({ scope: "read-only" })`. The full Sandbox API key
+* remains server-side.
 */
 var SandboxRuntimeClient = class extends SandboxRuntimeApi {
 	auth;
@@ -78,4 +80,4 @@ function createSandboxRuntimeClient(config) {
 	return new SandboxRuntimeClient(config);
 }
 //#endregion
-export { AuthError, CapabilityError, NetworkError, NotFoundError, PartialFailureError, QuotaError, SandboxError, SandboxRuntimeClient, ServerError, StateError, TimeoutError, ValidationError, createSandboxRuntimeClient };
+export { AuthError, CapabilityError, NetworkError, NotFoundError, PartialFailureError, QuotaError, SandboxError, SandboxRuntimeClient, ServerError, StateError, TimeoutError, ValidationError, createSandboxRuntimeClient, uploadChunked };

package/dist/{sandbox-BtNWbfd3.d.ts → sandbox-B9P4tyt4.d.ts}

@@ -1,4 +1,4 @@
-import { $ as EventStreamOptions, A as CommitTaskSessionOptions, Ai as WriteFileOptions, An as Rollout, B as CreateTaskSessionOptions, Br as SearchMatch, Bt as IntelligenceReport, Ci as TurnDriveResult, Cr as SandboxResourceUsage, Ct as GitBranch, D as CodeLanguage, Dr as SandboxRuntimeProfileList, Dt as GitStatus, E as CodeExecutionResult, Et as GitDiff, Gr as SendSessionMessageRequest, Gt as JsonValue, Ht as IntelligenceReportCompareTo, Ir as SandboxTraceOptions, Jr as SessionEventStreamOptions, Kr as SentSessionMessage, Kt as ListMessagesOptions, Mi as WriteManyOptions, Mn as RolloutOptions, Nr as SandboxTraceBundle, Nt as GpuLeaseManager, Oi as WaitForOptions, On as RestoreSnapshotOptions, Or as SandboxStatus, Ot as GpuLease, Pn as RolloutStartResult, Qr as SessionMessage, Rn as SSHCommandDescriptor, Rr as ScopedToken, T as CodeExecutionOptions, Tr as SandboxRuntimeHealth, U as DispatchPromptOptions, Un as SandboxEvent, Vn as SandboxConnection, Vr as SearchOptions, Vt as IntelligenceReportBudget, W as DispatchedSession, Wr as SendSessionMessageOptions, Wt as IntelligenceReportWindow, Xr as SessionInfo, Y as DriverInfo, Yr as SessionForkOptions, Z as EgressManager, Zr as SessionListOptions, Zt as MintScopedTokenOptions, _n as ProvisionResult, _r as SandboxInfo, ai as StartupDiagnostics, an as PreviewLinkManager, bi as TeePublicKeyResponse, br as SandboxPortBinding, cr as SandboxFleetTraceBundle, di as TaskSessionChanges, dt as FileWriteResult, en as NetworkManager, et as ExecOptions, fi as TaskSessionCommitResult, gi as TeeAttestationOptions, gn as ProvisionEvent, hn as PromptResult, j as CompletedTurnResult, ji as WriteManyFile, jr as SandboxTerminalManager, ki as WaitForRolloutOptions, kn as ResumeOptions, l as BackendManager, li as TaskOptions, ln as ProcessManager, mi as TaskSessionInfo, mn as PromptOptions, ni as SnapshotOptions, pn as PromptInputPart, q as DriveTurnOptions, ri as SnapshotResult, rn as PermissionsManager, s as BackendConfig, st as FileSystem, ti as SnapshotInfo, tt as ExecResult, ui as TaskResult, vi as TeeAttestationResponse, w as BranchOptions, wt as GitCommit, z as CreateSessionOptions, zn as SSHCredentials, zt as InstalledTool } from "./types-BvSoEHz8.js";
+import { $ as EgressManager, $r as SessionForkOptions, At as GitStatus, Br as SandboxTraceOptions, D as CodeExecutionOptions, Di as TurnDriveResult, Dr as SandboxResourceUsage, Dt as GitCommit, Et as GitBranch, Fi as WriteManyFile, Fr as SandboxTerminalManager, G as DispatchPromptOptions, Gn as SandboxConnection, Gr as SearchOptions, Gt as IntelligenceReportCompareTo, H as CreateTaskSessionOptions, Hn as SSHCommandDescriptor, Hr as ScopedToken, Ht as InstalledTool, Ii as WriteManyOptions, In as RolloutOptions, It as GpuLeaseManager, Jr as SendSessionMessageOptions, Jt as JsonValue, K as DispatchedSession, Lr as SandboxTraceBundle, M as CommitTaskSessionOptions, Mi as WaitForOptions, Mn as RestoreSnapshotOptions, Mr as SandboxStatus, N as CompletedTurnResult, Ni as WaitForRolloutOptions, Nn as ResumeOptions, O as CodeExecutionResult, Pi as WriteFileOptions, Pn as Rollout, Qr as SessionEventStreamOptions, Rn as RolloutStartResult, Si as TeeAttestationResponse, Un as SSHCredentials, Ut as IntelligenceReport, V as CreateSessionOptions, Wr as SearchMatch, Wt as IntelligenceReportBudget, Xr as SentSessionMessage, Y as DriveTurnOptions, Yr as SendSessionMessageRequest, Yt as ListMessagesOptions, Z as DriverInfo, _n as PromptOptions, ai as SnapshotInfo, bi as TeeAttestationOptions, bn as ProvisionResult, cn as PreviewLinkManager, ei as SessionInfo, en as MintScopedTokenOptions, fn as ProcessManager, fr as SandboxFleetTraceBundle, gi as TaskSessionCommitResult, gn as PromptInputPart, hi as TaskSessionChanges, jr as SandboxRuntimeProfileList, jt as GpuLease, k as CodeLanguage, kr as SandboxRuntimeHealth, kt as GitDiff, l as BackendManager, li as StartupDiagnostics, mi as TaskResult, mt as FileWriteResult, ni as SessionMessage, nt as ExecOptions, oi as SnapshotOptions, on as PermissionsManager, pi as TaskOptions, qn as SandboxEvent, qt as IntelligenceReportWindow, rn as NetworkManager, rt as ExecResult, s as BackendConfig, si as SnapshotResult, ti as SessionListOptions, tt as EventStreamOptions, ut as FileSystem, vi as TaskSessionInfo, vn as PromptResult, w as BranchOptions, wi as TeePublicKeyResponse, wr as SandboxPortBinding, xr as SandboxInfo, yn as ProvisionEvent } from "./types-LNLeU9Ub.js";
 
 //#region src/mcp.d.ts
 /**
@@ -894,12 +894,18 @@ declare class SandboxInstance {
   private fsReadBatch;
   private fsTree;
   private fsUpload;
+  /** See {@link FileSystem.uploadData}. Delegates to the shared, browser-safe
+   *  chunked-upload flow in `lib/chunked-upload.ts`, wired to this sandbox's
+   *  runtime endpoint (works over the gateway proxy or a direct connection —
+   *  both are transparent through `runtimeFetch`). */
+  private fsUploadData;
   private fsDownload;
   private fsUploadDir;
   private fsDownloadDir;
   private fsList;
   private fsStat;
   private fsDelete;
+  private fsRename;
   private fsMkdir;
   private fsExists;
   /**
@@ -1498,15 +1504,10 @@ declare class SandboxInstance {
    */
   driveTurn(message: string | PromptInputPart[], opts: DriveTurnOptions): Promise<TurnDriveResult>;
   /**
-   * Mint a scoped, time-bounded JWT for direct browser access to this
-   * sandbox (Issue #913 Gap 1). Authority is the caller's
-   * `TANGLE_API_KEY` (sk-tan-*) — the Sandbox API mints the token;
-   * signing secrets stay server-side.
-   *
-   * Use this to give a browser direct read access to the sandbox without
-   * leaking the full bearer (`box.connection.authToken`). The returned
-   * token verifies against the same sidecar middleware that already
-   * gates ProductTokenIssuer-issued JWTs — no new sidecar surface.
+   * Mint a scoped, time-bounded JWT for browser access (Issue #913 Gap 1).
+   * Authority is the caller's `TANGLE_API_KEY` (sk-tan-*); signing secrets
+   * stay server-side. Session/project scopes work with SessionGatewayClient,
+   * while session-runtime/read-only scopes work with SandboxRuntimeClient.
    */
   mintScopedToken(opts: MintScopedTokenOptions): Promise<ScopedToken>;
   /** @internal — invoked by SandboxSession.status(). */