@oddington/sdk 0.1.7 → 0.1.9

package/dist/index.js

@@ -21668,7 +21668,7 @@ function managedConnections(capability) {
 }
 
 // src/connections.ts
-var connections = createConnections(async (name, operation, input) => {
+var connections = /* @__PURE__ */ createConnections(async (name, operation, input) => {
   try {
     const managed = process.env[MANAGED_CONNECTION_CAPABILITY_ENV];
     if (managed) {
@@ -22000,7 +22000,15 @@ function oddingtonOrigin(environment = process.env) {
 }
 
 // src/routine-local-transport.ts
-function privateRoutineRequest(environment = typeof process === "undefined" ? {} : process.env) {
+var nodeRequest;
+var nodeReadable;
+if (typeof __ODDINGTON_BROWSER__ === "undefined" || !__ODDINGTON_BROWSER__) {
+  ({ request: nodeRequest } = await import("node:http"));
+  ({ Readable: nodeReadable } = await import("node:stream"));
+}
+function privateRoutineRequest(environment = typeof __ODDINGTON_BROWSER__ !== "undefined" && __ODDINGTON_BROWSER__ ? {} : typeof process === "undefined" ? {} : process.env) {
+  if (typeof __ODDINGTON_BROWSER__ !== "undefined" && __ODDINGTON_BROWSER__)
+    return;
   const prepared = ["ODDINGTON_ROUTINE_LOCAL", "ODDINGTON_ROUTINE_LOCAL_SOCKET", "ODDINGTON_ROUTINE_LOCAL_TOKEN"].some((key) => environment[key] !== undefined);
   const managed = ["ODDINGTON_FILES_SOCKET", "ODDINGTON_FILES_TOKEN"].some((key) => environment[key] !== undefined);
   if (!prepared && !managed)
@@ -22013,83 +22021,302 @@ function privateRoutineRequest(environment = typeof process === "undefined" ? {}
     ODDINGTON_ROUTINE_LOCAL_TOKEN: token
   });
   const isCurrent = () => prepared ? environment.ODDINGTON_ROUTINE_LOCAL === "1" && environment.ODDINGTON_ROUTINE_LOCAL_SOCKET === socket && environment.ODDINGTON_ROUTINE_LOCAL_TOKEN === token : environment.ODDINGTON_FILES_SOCKET === socket && environment.ODDINGTON_FILES_TOKEN === token;
-  return { request, isCurrent, identity: `private:${socket}` };
-}
-function localRoutineRequest(environment = typeof process === "undefined" ? {} : process.env) {
-  const {
-    ODDINGTON_ROUTINE_LOCAL: mode,
-    ODDINGTON_ROUTINE_LOCAL_SOCKET: socket,
-    ODDINGTON_ROUTINE_LOCAL_TOKEN: token
-  } = environment;
-  if (mode === undefined && socket === undefined && token === undefined)
-    return;
-  if (mode !== "1" || !socket || !token || !/^[0-9a-f]{64}$/.test(token))
-    throw new Error("Preparation transport unavailable; nothing can publish");
-  const tcp = /^tcp:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/.exec(socket);
-  const endpoint = tcp && tcp[0] === socket && Number(tcp[1]) <= 65535 ? { hostname: "127.0.0.1", port: Number(tcp[1]) } : socket.startsWith("/") && !socket.startsWith("//") && !socket.includes("\x00") ? { socketPath: socket } : undefined;
-  if (!endpoint)
-    throw new Error("Preparation transport unavailable; nothing can publish");
-  return async (operation, input) => {
-    const { request } = await import("node:http");
-    return await new Promise((resolve, reject) => {
-      const call = request({
+  if (!nodeRequest || !nodeReadable)
+    throw new Error("Files transport unavailable");
+  const httpRequest = nodeRequest, Readable = nodeReadable;
+  const files = async (suffix, init, signal) => {
+    if (!isCurrent())
+      throw new FileOperationError("unsupported_context", 400);
+    const tcp = /^tcp:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/.exec(socket);
+    const endpoint = tcp ? { hostname: "127.0.0.1", port: Number(tcp[1]) } : { socketPath: socket };
+    const id2 = crypto.randomUUID();
+    if (init.body instanceof ReadableStream || suffix === "" && init.method === "POST") {
+      await new Promise((resolve, reject) => {
+        const admission = httpRequest({
+          ...endpoint,
+          path: "/files/admit",
+          method: "POST",
+          timeout: 30000,
+          signal,
+          agent: false,
+          headers: {
+            ...Object.fromEntries(new Headers(init.headers)),
+            authorization: `Bearer ${token}`,
+            "x-oddington-files-suffix": encodeURIComponent(suffix),
+            "x-oddington-files-method": init.method ?? "GET"
+          }
+        }, (response) => {
+          const bytes = Buffer.alloc(16384);
+          let size = 0;
+          response.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > 16384)
+              response.destroy(new Error("Files admission result exceeds supported size"));
+            else
+              bytes.set(chunk, size - chunk.length);
+          });
+          response.once("error", reject);
+          response.once("end", () => {
+            if (response.statusCode === 204) {
+              resolve();
+              return;
+            }
+            try {
+              const value = JSON.parse(bytes.subarray(0, size).toString());
+              const code = value?.error?.code;
+              const status = response.statusCode ?? 503;
+              if (["invalid_input", "request_too_large", "unsupported_context", "access_denied", "capacity", "unavailable"].includes(code))
+                reject(new FileOperationError(code, status, code === "capacity" || code === "unavailable"));
+              else
+                reject(new FileOperationError("unavailable", 503, true));
+            } catch {
+              reject(new FileOperationError("unavailable", 503, true));
+            }
+          });
+        });
+        admission.once("error", () => reject(new FileOperationError("unavailable", 503, true)));
+        admission.once("timeout", () => admission.destroy(new Error("Files admission stalled")));
+        admission.end();
+      });
+      if (!isCurrent())
+        throw new FileOperationError("unsupported_context", 400);
+    }
+    let cancellation;
+    const cancelCall = () => cancellation ??= new Promise((resolve, reject) => {
+      const cancel = httpRequest({
         ...endpoint,
-        path: `/${operation}`,
+        path: "/files/cancel",
         method: "POST",
-        headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
-        timeout: 120000
+        timeout: 30000,
+        headers: { authorization: `Bearer ${token}`, "x-oddington-files-call": id2 }
       }, (response) => {
-        const bytes = Buffer.alloc(33554432);
-        let size = 0;
-        response.on("data", (chunk) => {
-          size += chunk.length;
-          if (size > 33554432) {
+        response.resume();
+        response.once("end", resolve);
+        response.once("error", reject);
+      });
+      cancel.once("error", reject);
+      cancel.once("timeout", () => cancel.destroy(new Error("Files cancellation stalled")));
+      cancel.end();
+    });
+    let pumping = Promise.resolve();
+    let sourceReader;
+    const result = new Promise((resolve, reject) => {
+      const call = httpRequest({
+        ...endpoint,
+        path: "/files/stream",
+        method: "POST",
+        headers: {
+          ...Object.fromEntries(new Headers(init.headers)),
+          authorization: `Bearer ${token}`,
+          "x-oddington-files-call": id2,
+          "x-oddington-files-suffix": encodeURIComponent(suffix),
+          "x-oddington-files-method": init.method ?? "GET"
+        },
+        signal,
+        timeout: 30000,
+        agent: false
+      }, async (response) => {
+        try {
+          call.setTimeout(0);
+          if ((response.statusCode ?? 503) >= 400) {
+            await sourceReader?.cancel().catch(() => {});
+            call.end();
+          }
+          await pumping;
+          if (!isCurrent()) {
             response.destroy();
-            reject(new Error("Local result exceeds supported size"));
-          } else
-            bytes.set(chunk, size - chunk.length);
-        });
-        response.on("error", reject);
-        response.on("end", () => {
-          try {
-            const result = JSON.parse(bytes.subarray(0, size).toString());
-            if (response.statusCode !== 200) {
-              if (operation === "files/request") {
-                const error = result.error;
-                const status = response.statusCode ?? 503;
-                const codes = [
-                  "invalid_input",
-                  "unsupported_context",
-                  "unauthenticated",
-                  "access_denied",
-                  "request_too_large",
-                  "conflict",
-                  "local_only",
-                  "integrity",
-                  "unavailable",
-                  "capacity",
-                  "method_not_allowed"
-                ];
-                if (error?.code && codes.includes(error.code))
-                  throw new FileOperationError(error.code, status, error.code === "capacity" || error.code === "unavailable");
-                throw new FileOperationError("unavailable", 503, true);
+            reject(new FileOperationError("unsupported_context", 400));
+            return;
+          }
+          const headers = new Headers;
+          for (const [key, value] of Object.entries(response.headers))
+            if (value !== undefined)
+              headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+          const source = Readable.toWeb(response, { strategy: {
+            highWaterMark: 65536,
+            size: (chunk) => chunk.byteLength
+          } });
+          const reader = source.getReader();
+          let closed = false;
+          const body = new ReadableStream({
+            async pull(controller) {
+              let timer;
+              try {
+                if (!isCurrent())
+                  throw new FileOperationError("unsupported_context", 400);
+                timer = setTimeout(() => response.destroy(new Error("Files delivery stalled")), 30000);
+                const next = await reader.read();
+                if (closed)
+                  return;
+                if (next.done) {
+                  closed = true;
+                  reader.releaseLock();
+                  controller.close();
+                } else
+                  controller.enqueue(next.value);
+              } catch (error) {
+                closed = true;
+                controller.error(error);
+                await cancelCall().catch(() => {});
+                response.socket?.destroy();
+                response.destroy();
+                await reader.cancel(error).catch(() => {});
+                reader.releaseLock();
+              } finally {
+                clearTimeout(timer);
               }
-              if (operation === "data/query") {
-                throw dataTransportError(response.statusCode ?? 0, result);
+            },
+            async cancel(reason) {
+              closed = true;
+              await cancelCall().catch(() => {});
+              response.socket?.destroy();
+              response.destroy();
+              call.destroy();
+              await reader.cancel(reason).catch(() => {});
+              reader.releaseLock();
+            }
+          }, { highWaterMark: 0 });
+          resolve(new Response(body, { status: response.statusCode ?? 503, headers }));
+        } catch (error) {
+          response.destroy();
+          reject(error instanceof FileOperationError ? error : new FileOperationError("unavailable", 503, true));
+        }
+      });
+      call.on("error", (error) => {
+        cancelCall().catch(() => {});
+        reject(error instanceof FileOperationError ? error : new FileOperationError("unavailable", 503, true));
+      });
+      call.on("timeout", () => call.destroy(new Error("Files I/O stalled")));
+      call.on("information", () => call.setTimeout(30000));
+      if (init.body instanceof ReadableStream) {
+        call.flushHeaders();
+        const reader = sourceReader = init.body.getReader();
+        const abort = () => {
+          reader.cancel(signal.reason).catch(() => {});
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        call.once("close", abort);
+        pumping = (async () => {
+          try {
+            for (;; ) {
+              const next = await reader.read();
+              if (next.done)
+                break;
+              if (!(next.value instanceof Uint8Array))
+                throw new FileOperationError("invalid_input", 400);
+              if (!isCurrent())
+                throw new FileOperationError("unsupported_context", 400);
+              for (let offset = 0;offset < next.value.byteLength; offset += 262144) {
+                if (call.destroyed)
+                  throw new Error("Files parent disconnected");
+                await new Promise((done, fail3) => {
+                  const closed = () => fail3(new Error("Files parent disconnected"));
+                  call.once("close", closed);
+                  call.write(next.value.subarray(offset, offset + 262144), (error) => {
+                    call.removeListener("close", closed);
+                    error ? fail3(error) : done();
+                  });
+                });
               }
-              throw new Error(typeof result.error === "string" ? result.error : "Preparation failed");
             }
-            resolve(result);
+            call.end();
           } catch (error) {
-            reject(error);
+            call.destroy(error instanceof Error ? error : new Error("Files transport failed"));
+          } finally {
+            await reader.cancel().catch(() => {});
+            signal.removeEventListener("abort", abort);
+            call.removeListener("close", abort);
+            reader.releaseLock();
           }
-        });
-      });
-      call.on("error", () => reject(new Error("Preparation transport unavailable; nothing was published")));
-      call.on("timeout", () => call.destroy(new Error("Preparation timed out")));
-      call.end(JSON.stringify(input));
+        })();
+      } else
+        call.end(init.body === undefined ? undefined : Buffer.from(init.body));
     });
+    try {
+      return await result;
+    } finally {
+      await pumping;
+    }
   };
+  return { request, files, isCurrent, identity: `private:${socket}` };
+}
+function localRoutineRequest(environment = typeof __ODDINGTON_BROWSER__ !== "undefined" && __ODDINGTON_BROWSER__ ? {} : typeof process === "undefined" ? {} : process.env) {
+  if (typeof __ODDINGTON_BROWSER__ === "undefined" || !__ODDINGTON_BROWSER__) {
+    const {
+      ODDINGTON_ROUTINE_LOCAL: mode,
+      ODDINGTON_ROUTINE_LOCAL_SOCKET: socket,
+      ODDINGTON_ROUTINE_LOCAL_TOKEN: token
+    } = environment;
+    if (mode === undefined && socket === undefined && token === undefined)
+      return;
+    if (mode !== "1" || !socket || !token || !/^[0-9a-f]{64}$/.test(token))
+      throw new Error("Preparation transport unavailable; nothing can publish");
+    const tcp = /^tcp:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/.exec(socket);
+    const endpoint = tcp && tcp[0] === socket && Number(tcp[1]) <= 65535 ? { hostname: "127.0.0.1", port: Number(tcp[1]) } : socket.startsWith("/") && !socket.startsWith("//") && !socket.includes("\x00") ? { socketPath: socket } : undefined;
+    if (!endpoint)
+      throw new Error("Preparation transport unavailable; nothing can publish");
+    return async (operation, input) => {
+      const { request } = await import("node:http");
+      return await new Promise((resolve, reject) => {
+        const call = request({
+          ...endpoint,
+          path: `/${operation}`,
+          method: "POST",
+          headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+          timeout: 120000
+        }, (response) => {
+          const bytes = Buffer.alloc(33554432);
+          let size = 0;
+          response.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > 33554432) {
+              response.destroy();
+              reject(new Error("Local result exceeds supported size"));
+            } else
+              bytes.set(chunk, size - chunk.length);
+          });
+          response.on("error", reject);
+          response.on("end", () => {
+            try {
+              const result = JSON.parse(bytes.subarray(0, size).toString());
+              if (response.statusCode !== 200) {
+                if (operation === "files/request") {
+                  const error = result.error;
+                  const status = response.statusCode ?? 503;
+                  const codes = [
+                    "invalid_input",
+                    "unsupported_context",
+                    "unauthenticated",
+                    "access_denied",
+                    "request_too_large",
+                    "conflict",
+                    "local_only",
+                    "integrity",
+                    "unavailable",
+                    "capacity",
+                    "method_not_allowed"
+                  ];
+                  if (error?.code && codes.includes(error.code))
+                    throw new FileOperationError(error.code, status, error.code === "capacity" || error.code === "unavailable");
+                  throw new FileOperationError("unavailable", 503, true);
+                }
+                if (operation === "data/query") {
+                  throw dataTransportError(response.statusCode ?? 0, result);
+                }
+                throw new Error(typeof result.error === "string" ? result.error : "Preparation failed");
+              }
+              resolve(result);
+            } catch (error) {
+              reject(error);
+            }
+          });
+        });
+        call.on("error", () => reject(new Error("Preparation transport unavailable; nothing was published")));
+        call.on("timeout", () => call.destroy(new Error("Preparation timed out")));
+        call.end(JSON.stringify(input));
+      });
+    };
+  }
 }
 
 // src/data-context.ts
@@ -22116,12 +22343,14 @@ async function resolveAppContext() {
 }
 async function resolveDataContext() {
   try {
-    const local = localRoutineRequest();
-    if (local)
-      return { local };
-    const managed = privateRoutineRequest();
-    if (managed)
-      return { local: managed.request };
+    if (typeof __ODDINGTON_BROWSER__ === "undefined" || !__ODDINGTON_BROWSER__) {
+      const local = localRoutineRequest();
+      if (local)
+        return { local };
+      const managed = privateRoutineRequest();
+      if (managed)
+        return { local: managed.request };
+    }
     const host = memberContext;
     if (host !== undefined) {
       const context = await host();
@@ -22133,25 +22362,31 @@ async function resolveDataContext() {
         throw new Error;
       return checked(context.workspace, context.endpoint, { authorization: `Bearer ${context.accessToken}` });
     }
-    const environment = typeof process === "undefined" ? undefined : process.env;
-    if (!environment || !/^[0-9a-f]{64}$/.test(environment.ODDINGTON_ROUTINE_RUN ?? ""))
-      throw new Error;
-    return checked(environment.ODDINGTON_ROUTINE_WORKSPACE, oddingtonOrigin(environment), { "x-oddington-run": environment.ODDINGTON_ROUTINE_RUN });
+    if (typeof __ODDINGTON_BROWSER__ === "undefined" || !__ODDINGTON_BROWSER__) {
+      const environment = typeof process === "undefined" ? undefined : process.env;
+      if (!environment || !/^[0-9a-f]{64}$/.test(environment.ODDINGTON_ROUTINE_RUN ?? ""))
+        throw new Error;
+      return checked(environment.ODDINGTON_ROUTINE_WORKSPACE, oddingtonOrigin(environment), { "x-oddington-run": environment.ODDINGTON_ROUTINE_RUN });
+    }
+    throw new Error;
   } catch {
     throw new DataOperationError("context_unavailable");
   }
 }
 async function resolveFilesContext() {
   try {
-    const environment = typeof process === "undefined" ? {} : process.env;
-    const local = privateRoutineRequest(environment);
-    if (local)
-      return {
-        url: local.identity,
-        headers: {},
-        isCurrent: local.isCurrent,
-        local: local.request
-      };
+    const environment = typeof __ODDINGTON_BROWSER__ !== "undefined" && __ODDINGTON_BROWSER__ ? {} : typeof process === "undefined" ? {} : process.env;
+    if (typeof __ODDINGTON_BROWSER__ === "undefined" || !__ODDINGTON_BROWSER__) {
+      const local = privateRoutineRequest(environment);
+      if (local)
+        return {
+          url: local.identity,
+          headers: {},
+          isCurrent: local.isCurrent,
+          local: local.request,
+          localFiles: local.files
+        };
+    }
     const host = memberContext;
     if (host) {
       const context = await host();
@@ -22162,13 +22397,17 @@ async function resolveFilesContext() {
       return {
         ...filesContext(context.workspace, context.endpoint, { authorization: `Bearer ${context.accessToken}` }),
         isCurrent: context.isCurrent,
-        local: undefined
+        local: undefined,
+        localFiles: undefined
       };
     }
-    if (!/^[0-9a-f]{64}$/.test(environment.ODDINGTON_ROUTINE_RUN ?? ""))
-      throw new Error;
-    const workspace = environment.ODDINGTON_ROUTINE_WORKSPACE;
-    return { ...filesContext(workspace, `https://${workspace}.oddington.ai`, { "x-oddington-run": environment.ODDINGTON_ROUTINE_RUN }), local: undefined };
+    if (typeof __ODDINGTON_BROWSER__ === "undefined" || !__ODDINGTON_BROWSER__) {
+      if (!/^[0-9a-f]{64}$/.test(environment.ODDINGTON_ROUTINE_RUN ?? ""))
+        throw new Error;
+      const workspace = environment.ODDINGTON_ROUTINE_WORKSPACE;
+      return { ...filesContext(workspace, `https://${workspace}.oddington.ai`, { "x-oddington-run": environment.ODDINGTON_ROUTINE_RUN }), local: undefined, localFiles: undefined };
+    }
+    throw new Error;
   } catch {
     throw new FileOperationError("unsupported_context", 400);
   }
@@ -22330,6 +22569,7 @@ var MAX_BYTES = 16 * 1024 * 1024;
 var PART_BYTES = 8 * 1024 * 1024;
 var METADATA_BYTES = 4096;
 var RESULT_BYTES = 16 * 1024;
+var CONTROL_RESULT_BYTES = 128 * 1024;
 var TIMEOUT_MS = 30000;
 var MAX_ACTIVE = 4;
 var ATTEMPTS = 2;
@@ -22390,15 +22630,15 @@ async function timed(work, parent, timeout = TIMEOUT_MS) {
     parent?.removeEventListener("abort", abort);
   }
 }
-async function result(response) {
+async function result(response, maximum = RESULT_BYTES) {
   try {
-    const bytes = await boundedBytes(response.body, RESULT_BYTES);
+    const bytes = await boundedBytes(response.body, maximum);
     return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
   } catch {
     throw unavailable();
   }
 }
-async function hostedContent(url, init, parent) {
+async function hostedContent(url, init, parent, upstream = fetch) {
   const delivery = new AbortController;
   const abort = () => delivery.abort(parent.reason);
   parent.addEventListener("abort", abort, { once: true });
@@ -22406,7 +22646,7 @@ async function hostedContent(url, init, parent) {
     abort();
   const detach = () => parent.removeEventListener("abort", abort);
   try {
-    const response = await fetch(url, { ...init, signal: delivery.signal });
+    const response = await upstream(url, { ...init, signal: delivery.signal });
     if (delivery.signal.aborted) {
       response.body?.cancel().catch(() => {});
       throw unavailable();
@@ -22482,26 +22722,7 @@ async function send(suffix, init, descriptor, initial, parent) {
       throw new FileOperationError("unsupported_context", 400);
     try {
       return await (async () => {
-        const response = context.local ? await (async () => {
-          const body = init.body instanceof ArrayBuffer ? new Uint8Array(init.body) : undefined;
-          let binary = "";
-          if (body)
-            for (let offset = 0;offset < body.length; offset += 8192)
-              binary += String.fromCharCode(...body.subarray(offset, offset + 8192));
-          const value2 = await context.local("files/request", {
-            suffix,
-            method: init.method,
-            headers: Object.fromEntries(new Headers(init.headers)),
-            ...body ? { bytes: btoa(binary) } : {}
-          });
-          if (value2.bytes !== undefined) {
-            if (value2.bytes.length > Math.ceil(MAX_BYTES / 3) * 4)
-              throw unavailable();
-            const data2 = atob(value2.bytes);
-            return new Response(Uint8Array.from(data2, (c) => c.charCodeAt(0)), { status: value2.status, headers: value2.headers });
-          }
-          return Response.json(value2.json, { status: value2.status, headers: value2.headers });
-        })() : await (async () => {
+        const response = context.localFiles ? await context.localFiles(suffix, init, parent) : await (async () => {
           const url = `${context.url}${suffix}`;
           const request = {
             ...init,
@@ -22531,7 +22752,7 @@ async function send(suffix, init, descriptor, initial, parent) {
         }
         if (!descriptor)
           return response;
-        const value = await result(response);
+        const value = await result(response, descriptor === "control" ? CONTROL_RESULT_BYTES : RESULT_BYTES);
         if (descriptor === "control") {
           checkCurrent();
           return value;
@@ -22551,7 +22772,7 @@ async function send(suffix, init, descriptor, initial, parent) {
       })();
     } catch (error) {
       const failure = error instanceof FileOperationError ? error : unavailable();
-      if (!failure.retryable || attempt + 1 === ATTEMPTS)
+      if (init.body instanceof ReadableStream || !failure.retryable || attempt + 1 === ATTEMPTS)
         throw failure;
     }
   }
@@ -22562,7 +22783,10 @@ function idPath(id2) {
     throw invalid2();
   return `/${id2}`;
 }
-async function multipartCreate(input, metadata, context) {
+async function multipartCreate(input, metadata, exchange, release = () => {
+  active--;
+}, upload) {
+  const route = upload ? `${idPath(upload.file.id)}/upload/multipart` : "/multipart";
   let ticket;
   let reader;
   let chunk, offset = 0;
@@ -22580,11 +22804,11 @@ async function multipartCreate(input, metadata, context) {
     body: JSON.stringify(body)
   });
   try {
-    const start = await request((signal) => send("/multipart/start", control(metadata), "control", context, signal));
+    const start = await request((signal) => exchange(`${route}/start`, control(upload?.file ?? metadata), "control", signal));
     if (!start || typeof start !== "object" || Array.isArray(start))
       throw unavailable();
     const session = start;
-    if (Object.keys(session).sort().join(",") !== "partBytes,ticket" || session.partBytes !== PART_BYTES || typeof session.ticket !== "string" || !session.ticket || session.ticket.length > 8192)
+    if (Object.keys(session).sort().join(",") !== "partBytes,ticket" || session.partBytes !== PART_BYTES || typeof session.ticket !== "string" || !session.ticket || session.ticket.length > 64 * 1024)
       throw unavailable();
     ticket = session.ticket;
     if (input.file instanceof ReadableStream)
@@ -22603,7 +22827,7 @@ async function multipartCreate(input, metadata, context) {
         throw error;
       }
     };
-    for (let sent = 0, partNumber = 1;sent < metadata.size; partNumber++) {
+    for (let sent = 0, partNumber = 1;sent < metadata.size || metadata.size === 0 && partNumber === 1; partNumber++) {
       const length = Math.min(PART_BYTES, metadata.size - sent);
       let part;
       if (input.file instanceof Uint8Array)
@@ -22649,11 +22873,12 @@ async function multipartCreate(input, metadata, context) {
             throw invalid2();
         }
       }
-      const value = await request((signal) => send("/multipart/part", {
+      const value = await request((signal) => exchange(`${route}/part`, {
         method: "POST",
         headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket, "x-oddington-part": String(partNumber) },
         body: part.buffer
-      }, "control", context, signal));
+      }, "control", signal));
+      part = undefined;
       const receipt = value;
       if (!receipt || typeof receipt !== "object" || Object.keys(receipt).sort().join(",") !== "etag,partNumber" || receipt.partNumber !== partNumber || typeof receipt.etag !== "string" || !receipt.etag || receipt.etag.length > 256 || /[\u0000-\u001f\u007f]/.test(receipt.etag))
         throw unavailable();
@@ -22661,25 +22886,35 @@ async function multipartCreate(input, metadata, context) {
       sent += length;
       lastProgress = Date.now();
     }
+    if (upload)
+      for (const name of Object.keys(upload.file.enrichments)) {
+        const bytes = await request(() => upload.enrichment(name));
+        if (bytes.byteLength !== upload.file.enrichments[name].size || bytes.byteLength > MAX_BYTES)
+          throw invalid2();
+        await request((signal) => exchange(`${route}/enrichments/${encodeURIComponent(name)}`, {
+          method: "POST",
+          headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket },
+          body: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
+        }, "control", signal));
+      }
+    await upload?.beforeComplete();
     const completion = control({ parts: receipts });
     if (new TextEncoder().encode(completion.body).byteLength > 128 * 1024)
       throw unavailable();
-    return await request((signal) => send("/multipart/complete", completion, true, context, signal), TIMEOUT_MS + Math.ceil(metadata.size / (1024 * 1024)) * 1000);
+    return parseFileDescriptor(await request((signal) => exchange(`${route}/complete`, completion, true, signal), TIMEOUT_MS + Math.ceil(metadata.size / (1024 * 1024)) * 1000));
   } catch (error) {
     if (reader)
       await reader.cancel(error).catch(() => {});
     if (ticket)
-      await request((signal) => send("/multipart/abort", control({}), "control", context, signal)).catch(() => {});
+      await request((signal) => exchange(`${route}/abort`, control({}), "control", signal)).catch(() => {});
     throw error instanceof FileOperationError ? error : unavailable();
   } finally {
     chunk = undefined;
     reader?.releaseLock();
     if (pending.size)
-      Promise.allSettled([...pending]).then(() => {
-        active--;
-      });
+      Promise.allSettled([...pending]).then(release);
     else
-      active--;
+      release();
   }
 }
 async function operation(work, initial, parent) {
@@ -22687,6 +22922,13 @@ async function operation(work, initial, parent) {
   if (active >= MAX_ACTIVE)
     throw new FileOperationError("capacity", 429, true);
   active++;
+  if (context.localFiles) {
+    try {
+      return await work(context, parent ?? new AbortController().signal);
+    } finally {
+      active--;
+    }
+  }
   return timed(async (signal) => {
     try {
       return await work(context, signal);
@@ -22776,7 +23018,7 @@ var files = {
       storage: input.storage,
       csv: input.csv,
       requestKey: options?.requestKey === undefined ? crypto.randomUUID() : options.requestKey
-    }, context.local ? MAX_BYTES : FILE_ORIGINAL_MAX_BYTES);
+    }, FILE_ORIGINAL_MAX_BYTES);
     if (!context.local && metadata.storage === "local")
       throw new FileOperationError("unsupported_context", 400);
     const header = encodeURIComponent(JSON.stringify(metadata));
@@ -22785,8 +23027,32 @@ var files = {
     if (active >= MAX_ACTIVE)
       throw new FileOperationError("capacity", 429, true);
     active++;
+    if (context.localFiles && metadata.size > MAX_BYTES) {
+      const controller = new AbortController;
+      const file = input.file;
+      let offset = 0;
+      const body = file instanceof ReadableStream ? file : file instanceof Blob ? file.stream() : new ReadableStream({
+        pull(controller2) {
+          if (offset === file.byteLength) {
+            controller2.close();
+            return;
+          }
+          const end = Math.min(offset + 256 * 1024, file.byteLength);
+          controller2.enqueue(file.subarray(offset, end));
+          offset = end;
+        }
+      }, { highWaterMark: 0 });
+      try {
+        return await send("", { method: "POST", headers: {
+          "content-type": "application/octet-stream",
+          "x-oddington-file": header
+        }, body }, true, context, controller.signal);
+      } finally {
+        active--;
+      }
+    }
     if (metadata.size > MAX_BYTES)
-      return multipartCreate(input, metadata, context);
+      return multipartCreate(input, metadata, (suffix, init, kind, signal) => kind === true ? send(suffix, init, true, context, signal) : send(suffix, init, "control", context, signal));
     return timed(async (signal) => {
       try {
         const bytes = array2 ? input.file.slice() : await boundedBytes(blob ? input.file.stream() : input.file, metadata.size);
@@ -22848,9 +23114,16 @@ var files = {
 };
 // src/app-context.ts
 var sessionKey = "_os.app.session";
+var responseChecks = new WeakMap;
 
 class AppResponseReadError extends Error {
 }
+
+class AppContextDenied extends Error {
+}
+
+class AppRenewalUnavailable extends Error {
+}
 async function appResponse(response, maximum, signal) {
   if (signal.aborted || !response.body || response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json")
     throw new Error;
@@ -22871,8 +23144,13 @@ async function appResponse(response, maximum, signal) {
       }
       if (signal.aborted)
         throw new Error;
-      if (chunk.done)
-        return JSON.parse(text3 + decoder.decode());
+      if (chunk.done) {
+        const value = JSON.parse(text3 + decoder.decode());
+        await responseChecks.get(response)?.(value);
+        if (signal.aborted)
+          throw new Error;
+        return value;
+      }
       bytes += chunk.value.byteLength;
       if (bytes > maximum) {
         abort();
@@ -22899,38 +23177,239 @@ function appContext(origin, active2) {
   let denied = false;
   const controller = new AbortController;
   let expiry;
-  const invalidate = () => {
-    denied = true;
+  let startup;
+  let renewalTimer;
+  let renewal;
+  let observation;
+  let resolution2;
+  let disposed = false;
+  const stored = () => globalThis.localStorage.getItem(sessionKey);
+  const alive = () => {
+    try {
+      return !denied && !disposed && active2() && globalThis.location.origin === origin && (!binding || binding.expiresAt > Date.now());
+    } catch {
+      return false;
+    }
+  };
+  const cancel = () => {
     controller.abort();
     clearTimeout(expiry);
+    clearTimeout(startup);
+    clearTimeout(renewalTimer);
     clearInterval(monitor);
+    globalThis.removeEventListener?.("storage", storageChanged);
+  };
+  const invalidate = () => {
+    denied = true;
+    cancel();
     try {
-      if (active2() && globalThis.location.origin === origin && (!credential || globalThis.localStorage.getItem(sessionKey) === credential)) {
+      if (!disposed && active2() && globalThis.location.origin === origin && (!credential || globalThis.localStorage.getItem(sessionKey) === credential)) {
         globalThis.localStorage.removeItem(sessionKey);
       }
     } catch {}
   };
   const current = () => {
     try {
-      return !denied && active2() && globalThis.location.origin === origin && globalThis.localStorage.getItem(sessionKey) === credential && (!binding || binding.expiresAt > Date.now());
+      return alive() && stored() === credential;
     } catch {
       return false;
     }
   };
-  const monitor = setInterval(() => {
-    if (credential && !current())
+  const sameSession = (value) => !binding || value.appId === binding.appId && value.memberId === binding.memberId && value.workspace === binding.workspace && value.sessionId === binding.sessionId;
+  const bounded = (value) => validBinding(value) && value.expiresAt > Date.now() && value.expiresAt <= Date.now() + 600000 && sameSession(value);
+  async function proof(candidate, signal = controller.signal) {
+    if (!alive() || !/^[A-Za-z0-9_-]{43}$/.test(candidate))
+      throw new Error;
+    const url = `${origin}/_os/app/context`;
+    const response = await fetch(url, {
+      credentials: "omit",
+      redirect: "error",
+      cache: "no-store",
+      referrerPolicy: "no-referrer",
+      headers: { authorization: `Bearer ${candidate}` },
+      signal
+    });
+    if (response.redirected || response.url && response.url !== url)
+      throw new Error;
+    if (response.status === 401 || response.status === 403)
+      throw new AppContextDenied;
+    if (!response.ok)
+      throw new Error;
+    const value = await appResponse(response, 4096, signal);
+    if (!alive() || !bounded(value))
+      throw new Error;
+    return value;
+  }
+  function install(value, candidate) {
+    binding = { ...value };
+    credential = candidate;
+    clearTimeout(expiry);
+    clearTimeout(renewalTimer);
+    const remaining = binding.expiresAt - Date.now();
+    expiry = setTimeout(invalidate, remaining);
+    renewalTimer = setTimeout(() => {
+      renew();
+    }, remaining - Math.min(60000, remaining / 5));
+  }
+  async function synchronize() {
+    if (!alive())
+      throw new Error;
+    if (!credential)
+      return;
+    if (stored() === credential)
+      return;
+    if (!binding)
+      throw new Error;
+    if (observation)
+      return observation;
+    observation = (async () => {
+      while (alive()) {
+        const candidate = stored();
+        if (!candidate)
+          throw new Error;
+        let value;
+        try {
+          value = await proof(candidate);
+        } catch {
+          if (stored() !== candidate)
+            continue;
+          throw new Error;
+        }
+        if (stored() !== candidate)
+          continue;
+        install(value, candidate);
+        return;
+      }
+      throw new Error;
+    })();
+    try {
+      await observation;
+    } catch {
+      invalidate();
+      throw new Error("Local app context unavailable.");
+    } finally {
+      observation = undefined;
+    }
+  }
+  async function renew() {
+    if (renewal || !binding || !alive())
+      return;
+    renewal = (async () => {
+      const deadline = binding.expiresAt;
+      const requestController = new AbortController;
+      const abort = () => requestController.abort();
+      controller.signal.addEventListener("abort", abort, { once: true });
+      const timeout = setTimeout(abort, Math.min(20000, deadline - Date.now()));
+      const previous = credential;
+      try {
+        await synchronize();
+        if (credential !== previous)
+          return;
+        const url = `${origin}/_os/app/renew`;
+        let response;
+        try {
+          response = await fetch(url, {
+            method: "POST",
+            credentials: "omit",
+            redirect: "error",
+            cache: "no-store",
+            referrerPolicy: "no-referrer",
+            signal: requestController.signal,
+            headers: { authorization: `Bearer ${previous}` }
+          });
+        } catch {
+          throw new AppRenewalUnavailable;
+        }
+        if (response.redirected || response.url && response.url !== url)
+          throw new Error;
+        const value = await appResponse(response, 4096, requestController.signal);
+        if (response.status === 503 && value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).join(",") === "error" && "error" in value && value.error === "renewal_unavailable")
+          throw new AppRenewalUnavailable;
+        if (response.status === 403 && value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).join(",") === "error" && "error" in value && value.error === "renewal_conflict") {
+          while (alive() && stored() === previous && !requestController.signal.aborted) {
+            await new Promise((resolve2, reject) => {
+              const abortWait = () => {
+                clearTimeout(timer);
+                reject(new Error);
+              };
+              const timer = setTimeout(() => {
+                requestController.signal.removeEventListener("abort", abortWait);
+                resolve2();
+              }, 100);
+              requestController.signal.addEventListener("abort", abortWait, { once: true });
+            });
+          }
+          if (requestController.signal.aborted)
+            throw new Error;
+          await synchronize();
+          return;
+        }
+        if (!response.ok)
+          throw new Error;
+        if (!alive() || Date.now() >= deadline || !value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "context,credential")
+          throw new Error;
+        const result2 = value;
+        if (!bounded(result2.context) || typeof result2.credential !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(result2.credential) || result2.credential === previous)
+          throw new Error;
+        if (stored() !== previous) {
+          await synchronize();
+          return;
+        }
+        globalThis.localStorage.setItem(sessionKey, result2.credential);
+        install(result2.context, result2.credential);
+      } catch (error) {
+        try {
+          if (alive() && stored() && stored() !== previous) {
+            await synchronize();
+            return;
+          }
+        } catch {}
+        try {
+          if (alive() && stored() && stored() !== previous) {
+            await synchronize();
+            return;
+          }
+        } catch {}
+        if ((error instanceof AppRenewalUnavailable || error instanceof AppResponseReadError || requestController.signal.aborted) && current() && Date.now() < deadline) {
+          renewalTimer = setTimeout(() => {
+            renew();
+          }, Math.min(5000, (deadline - Date.now()) / 5));
+        } else
+          invalidate();
+      } finally {
+        clearTimeout(timeout);
+        controller.signal.removeEventListener("abort", abort);
+      }
+    })();
+    try {
+      await renewal;
+    } finally {
+      renewal = undefined;
+    }
+  }
+  const storageChanged = () => {
+    if (!credential)
+      return;
+    if (!alive()) {
       invalidate();
+      return;
+    }
+    synchronize().catch(invalidate);
+  };
+  const monitor = setInterval(() => {
+    storageChanged();
   }, 100);
+  globalThis.addEventListener?.("storage", storageChanged);
   const dispose = () => {
-    controller.abort();
-    clearTimeout(expiry);
-    clearInterval(monitor);
+    disposed = true;
+    cancel();
   };
   async function requestData(operation2, input) {
     try {
       if (operation2 !== "data/query" || !current())
         throw new Error;
       const url = `${origin}/_os/app/data`;
+      const admitted = credential;
       const response = await fetch(url, {
         method: "POST",
         credentials: "omit",
@@ -22941,13 +23420,20 @@ function appContext(origin, active2) {
         headers: { "content-type": "application/json", authorization: `Bearer ${credential}` },
         body: JSON.stringify(input)
       });
+      await synchronize();
+      while (alive() && stored() !== credential)
+        await synchronize();
       if (!current() || response.redirected || response.url && response.url !== url)
         throw new Error;
       if (response.status === 401 || response.status === 403) {
-        invalidate();
+        if (admitted === credential)
+          invalidate();
         throw new DataOperationError("access_denied");
       }
       const result2 = await appResponse(response, Number.MAX_SAFE_INTEGER, controller.signal);
+      await synchronize();
+      while (alive() && stored() !== credential)
+        await synchronize();
       if (!current())
         throw new Error;
       if (!response.ok)
@@ -22967,6 +23453,7 @@ function appContext(origin, active2) {
       throw new Error("Local app context unavailable.");
     }
     const url = `${origin}/_os/app/routines/${encodeURIComponent(key)}/${suffix}`;
+    const admitted = credential;
     const response = await fetch(url, {
       ...init,
       credentials: "omit",
@@ -22976,61 +23463,107 @@ function appContext(origin, active2) {
       signal: controller.signal,
       headers: { ...init.body === undefined ? {} : { "content-type": "application/json" }, authorization: `Bearer ${credential}` }
     });
+    await synchronize();
+    while (alive() && stored() !== credential)
+      await synchronize();
     if (!current() || response.redirected || response.url && response.url !== url) {
       invalidate();
       throw new Error("Local app context unavailable.");
     }
-    if (response.status === 401 || response.status === 403)
+    if ((response.status === 401 || response.status === 403) && admitted === credential)
       invalidate();
+    responseChecks.set(response, async (value) => {
+      await synchronize();
+      while (alive() && stored() !== credential)
+        await synchronize();
+      if (admitted === credential && value && typeof value === "object" && "error" in value && value.error === "authority_unavailable")
+        invalidate();
+    });
     return response;
   }
-  const resolve = async () => {
+  function context() {
+    const issued = credential;
+    return {
+      kind: "local",
+      ...binding,
+      get expiresAt() {
+        return binding.expiresAt;
+      },
+      isCurrent: current,
+      signal: controller.signal,
+      invalidate: () => {
+        if (issued === credential)
+          invalidate();
+      },
+      requestRoutine,
+      requestData,
+      requestAvailability: (key) => requestRoutine(key, "availability", { method: "GET" })
+    };
+  }
+  const resolveOnce = async () => {
+    let attempted;
     try {
       if (denied || !active2() || globalThis.location.origin !== origin)
         throw new Error;
-      const stored = globalThis.localStorage.getItem(sessionKey);
-      if (!stored || !/^[A-Za-z0-9_-]{43}$/.test(stored) || credential && stored !== credential)
+      if (credential)
+        await synchronize();
+      const candidate = stored();
+      if (!candidate || !/^[A-Za-z0-9_-]{43}$/.test(candidate))
         throw new Error;
-      credential = stored;
+      credential = candidate;
+      attempted = candidate;
       if (!current())
         throw new Error;
-      const response = await fetch(`${origin}/_os/app/context`, {
-        credentials: "omit",
-        redirect: "error",
-        referrerPolicy: "no-referrer",
-        headers: { authorization: `Bearer ${credential}` },
-        signal: controller.signal
-      });
-      if (!response.ok || response.redirected || response.url && response.url !== `${origin}/_os/app/context` || !response.headers.get("content-type")?.startsWith("application/json"))
+      const value = await proof(candidate);
+      if (stored() !== candidate || credential !== candidate) {
+        if (!binding)
+          binding = { ...value };
+        await synchronize();
+        return context();
+      }
+      if (!current())
         throw new Error;
-      const value = await appResponse(response, 4096, controller.signal);
-      if (!validBinding(value) || !current() || value.expiresAt <= Date.now() || value.expiresAt > Date.now() + 600000 || binding && (value.appId !== binding.appId || value.memberId !== binding.memberId || value.workspace !== binding.workspace || value.expiresAt > binding.expiresAt))
+      if (binding && value.expiresAt > binding.expiresAt)
         throw new Error;
-      binding = { ...value };
-      clearTimeout(expiry);
-      expiry = setTimeout(invalidate, binding.expiresAt - Date.now());
-      return {
-        kind: "local",
-        ...binding,
-        isCurrent: current,
-        signal: controller.signal,
-        invalidate,
-        requestRoutine,
-        requestData,
-        requestAvailability: (key) => requestRoutine(key, "availability", { method: "GET" })
-      };
-    } catch {
+      if (!binding || value.expiresAt !== binding.expiresAt)
+        install(value, candidate);
+      return context();
+    } catch (error) {
+      try {
+        if (binding && current() && attempted && attempted !== credential)
+          return context();
+        if (binding && alive() && stored() && stored() !== credential) {
+          await synchronize();
+          return context();
+        }
+      } catch {}
+      if (error instanceof AppContextDenied && binding && alive() && renewal)
+        throw new Error("Local app context unavailable.");
       invalidate();
       throw new Error("Local app context unavailable.");
     }
   };
-  return { resolve, invalidate, dispose };
+  const resolve = () => {
+    if (resolution2)
+      return resolution2;
+    resolution2 = resolveOnce().finally(() => {
+      resolution2 = undefined;
+    });
+    return resolution2;
+  };
+  const start = () => {
+    startup = setTimeout(() => {
+      if (alive() && !resolution2 && !binding)
+        resolve().catch(() => {});
+    }, 0);
+  };
+  return { resolve, start, invalidate, dispose };
 }
 function validBinding(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "appId,expiresAt,memberId,workspace")
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "appId,expiresAt,memberId,sessionId,workspace")
     return false;
   const binding = value;
-  return typeof binding.appId === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(binding.appId) && typeof binding.workspace === "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(binding.workspace) && typeof binding.memberId === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(binding.memberId) && typeof binding.expiresAt === "number" && Number.isFinite(binding.expiresAt);
+  return typeof binding.appId === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(binding.appId) && typeof binding.workspace === "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(binding.workspace) && typeof binding.memberId === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(binding.memberId) && typeof binding.sessionId === "string" && /^[A-Za-z0-9_-]{43}$/.test(binding.sessionId) && typeof binding.expiresAt === "number" && Number.isFinite(binding.expiresAt);
 }
 
 // src/os.ts
@@ -23098,6 +23631,7 @@ function init({ auth }) {
       installedDispose = undefined;
   };
   installedDispose = dispose;
+  local?.start();
 }
 var os = { init };
 // src/app-routine-browser.ts
@@ -23561,7 +24095,7 @@ function freeze(value) {
   }
   return value;
 }
-if (typeof process !== "undefined" && process.env.ODDINGTON_APP_RUN !== undefined) {
+if ((typeof __ODDINGTON_BROWSER__ === "undefined" || !__ODDINGTON_BROWSER__) && typeof process !== "undefined" && process.env.ODDINGTON_APP_RUN !== undefined) {
   let fail4 = function() {
     broken = true;
     pending?.reject(unavailable2());
@@ -23712,13 +24246,13 @@ init_inbox_contract();
 init_inbox_contract();
 init_inbox_files();
 function routinePublicationClient(options = {}) {
-  const environment = typeof process === "undefined" ? {} : process.env;
+  const environment = typeof __ODDINGTON_BROWSER__ !== "undefined" && __ODDINGTON_BROWSER__ ? {} : typeof process === "undefined" ? {} : process.env;
   const local = localRoutineRequest(environment);
   const workspace = options.workspace ?? environment.ODDINGTON_ROUTINE_WORKSPACE;
   const capability = options.capability ?? environment.ODDINGTON_ROUTINE_RUN;
   if (!workspace || !/^[a-z0-9][a-z0-9-]*$/.test(workspace) || capability !== undefined && !/^[0-9a-f]{64}$/.test(capability))
     throw new Error("A workspace and valid optional routine capability are required");
-  const workingRoot = options.workingRoot ?? environment.ODDINGTON_INBOX_WORKING_ROOT ?? (typeof process === "undefined" ? undefined : process.cwd());
+  const workingRoot = options.workingRoot ?? environment.ODDINGTON_INBOX_WORKING_ROOT ?? (typeof __ODDINGTON_BROWSER__ !== "undefined" && __ODDINGTON_BROWSER__ ? undefined : typeof process === "undefined" ? undefined : process.cwd());
   const headers = capability ? { "x-oddington-run": capability } : {};
   const request = options.request ?? (capability ? async (path, init2) => {
     const origin = oddingtonOrigin();
@@ -23783,22 +24317,25 @@ function routinePublicationClient(options = {}) {
           return validateInboxFile(await local("files/add", input));
         if (!workingRoot)
           throw new Error("Inbox file reads require a working root");
-        const { readInboxPublicationFile: readInboxPublicationFile2 } = await Promise.resolve().then(() => (init_inbox_publication_file(), exports_inbox_publication_file));
-        const bytes = await readInboxPublicationFile2(workingRoot, input);
-        const name = input.name ?? input.path.split("/").at(-1);
-        const response = await request(`/api/cli/workspaces/${workspace}/inbox/files/upload`, {
-          method: "POST",
-          headers: {
-            "content-type": "application/octet-stream",
-            ...headers,
-            "x-oddington-file": JSON.stringify({ name, ...input.csv ? { csv: input.csv } : {} })
-          },
-          body: Uint8Array.from(bytes).buffer
-        });
-        const result2 = await response.json();
-        if (!response.ok)
-          throw new Error(result2.error ?? "Could not retain file");
-        return await verifyInboxFile(bytes, validateInboxFile(result2));
+        if (typeof __ODDINGTON_BROWSER__ === "undefined" || !__ODDINGTON_BROWSER__) {
+          const { readInboxPublicationFile: readInboxPublicationFile2 } = await Promise.resolve().then(() => (init_inbox_publication_file(), exports_inbox_publication_file));
+          const bytes = await readInboxPublicationFile2(workingRoot, input);
+          const name = input.name ?? input.path.split("/").at(-1);
+          const response = await request(`/api/cli/workspaces/${workspace}/inbox/files/upload`, {
+            method: "POST",
+            headers: {
+              "content-type": "application/octet-stream",
+              ...headers,
+              "x-oddington-file": JSON.stringify({ name, ...input.csv ? { csv: input.csv } : {} })
+            },
+            body: Uint8Array.from(bytes).buffer
+          });
+          const result2 = await response.json();
+          if (!response.ok)
+            throw new Error(result2.error ?? "Could not retain file");
+          return await verifyInboxFile(bytes, validateInboxFile(result2));
+        }
+        throw new Error("Inbox file reads require a Node working root");
       }
     },
     async check(body2) {