@oddington/sdk 0.1.7 → 0.1.8

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) {
+      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);
@@ -23561,7 +23827,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 +23978,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 +24049,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) {