@oddington/sdk 0.1.3 → 0.1.5

package/dist/index.js

@@ -691,8 +691,8 @@ function __awaiter(thisArg, _arguments, P, generator) {
         reject(e);
       }
     }
-    function step(result) {
-      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    function step(result2) {
+      result2.done ? resolve(result2.value) : adopt(result2.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -1332,19 +1332,19 @@ var require_common = __commonJS((exports) => {
       }
     },
     flattenChunks: function(chunks) {
-      var i2, l, len, pos, chunk, result;
+      var i2, l, len, pos, chunk, result2;
       len = 0;
       for (i2 = 0, l = chunks.length;i2 < l; i2++) {
         len += chunks[i2].length;
       }
-      result = new Uint8Array(len);
+      result2 = new Uint8Array(len);
       pos = 0;
       for (i2 = 0, l = chunks.length;i2 < l; i2++) {
         chunk = chunks[i2];
-        result.set(chunk, pos);
+        result2.set(chunk, pos);
         pos += chunk.length;
       }
-      return result;
+      return result2;
     }
   };
   var fnUntyped = {
@@ -3130,11 +3130,11 @@ var require_strings = __commonJS((exports) => {
         return String.fromCharCode.apply(null, utils.shrinkBuf(buf, len));
       }
     }
-    var result = "";
+    var result2 = "";
     for (var i2 = 0;i2 < len; i2++) {
-      result += String.fromCharCode(buf[i2]);
+      result2 += String.fromCharCode(buf[i2]);
     }
-    return result;
+    return result2;
   }
   exports.buf2binstring = function(buf) {
     return buf2binstring(buf, buf.length);
@@ -5985,9 +5985,9 @@ var init_errors = __esm(() => {
   }(Error);
   CorruptPageTreeError = function(_super) {
     __extends(CorruptPageTreeError2, _super);
-    function CorruptPageTreeError2(targetIndex, operation) {
+    function CorruptPageTreeError2(targetIndex, operation2) {
       var _this = this;
-      var msg = "Failed to " + operation + " at targetIndex=" + targetIndex + " due to corrupt page tree: It is likely that one or more 'Count' entries are invalid";
+      var msg = "Failed to " + operation2 + " at targetIndex=" + targetIndex + " due to corrupt page tree: It is likely that one or more 'Count' entries are invalid";
       _this = _super.call(this, msg) || this;
       return _this;
     }
@@ -7323,40 +7323,40 @@ var init_PDFContext = __esm(() => {
         types[_i - 1] = arguments[_i];
       }
       var preservePDFNull = types.includes(PDFNull_default);
-      var result = ref instanceof PDFRef_default ? this.indirectObjects.get(ref) : ref;
-      if (!result || result === PDFNull_default && !preservePDFNull)
+      var result2 = ref instanceof PDFRef_default ? this.indirectObjects.get(ref) : ref;
+      if (!result2 || result2 === PDFNull_default && !preservePDFNull)
         return;
       for (var idx3 = 0, len2 = types.length;idx3 < len2; idx3++) {
         var type = types[idx3];
         if (type === PDFNull_default) {
-          if (result === PDFNull_default)
-            return result;
+          if (result2 === PDFNull_default)
+            return result2;
         } else {
-          if (result instanceof type)
-            return result;
+          if (result2 instanceof type)
+            return result2;
         }
       }
-      throw new UnexpectedObjectTypeError(types, result);
+      throw new UnexpectedObjectTypeError(types, result2);
     };
     PDFContext2.prototype.lookup = function(ref) {
       var types = [];
       for (var _i = 1;_i < arguments.length; _i++) {
         types[_i - 1] = arguments[_i];
       }
-      var result = ref instanceof PDFRef_default ? this.indirectObjects.get(ref) : ref;
+      var result2 = ref instanceof PDFRef_default ? this.indirectObjects.get(ref) : ref;
       if (types.length === 0)
-        return result;
+        return result2;
       for (var idx3 = 0, len2 = types.length;idx3 < len2; idx3++) {
         var type = types[idx3];
         if (type === PDFNull_default) {
-          if (result === PDFNull_default)
-            return result;
+          if (result2 === PDFNull_default)
+            return result2;
         } else {
-          if (result instanceof type)
-            return result;
+          if (result2 instanceof type)
+            return result2;
         }
       }
-      throw new UnexpectedObjectTypeError(types, result);
+      throw new UnexpectedObjectTypeError(types, result2);
     };
     PDFContext2.prototype.getObjectRef = function(pdfObject) {
       var entries = Array.from(this.indirectObjects.entries());
@@ -15922,13 +15922,13 @@ var cx = 0, cy = 0, px = 0, py = 0, sx = 0, sy = 0, parameters, parse = function
     thArc -= 2 * Math.PI;
   }
   var segments = Math.ceil(Math.abs(thArc / (Math.PI * 0.5 + 0.001)));
-  var result = [];
+  var result2 = [];
   for (var i3 = 0;i3 < segments; i3++) {
     var th2 = th0 + i3 * thArc / segments;
     var th3 = th0 + (i3 + 1) * thArc / segments;
-    result[i3] = [xc, yc, th2, th3, rx, ry, sinTh, cosTh];
+    result2[i3] = [xc, yc, th2, th3, rx, ry, sinTh, cosTh];
   }
-  return result;
+  return result2;
 }, segmentToBezier = function(cx1, cy1, th0, th1, rx, ry, sinTh, cosTh) {
   var a00 = cosTh * rx;
   var a01 = -sinTh * ry;
@@ -15942,7 +15942,7 @@ var cx = 0, cy = 0, px = 0, py = 0, sx = 0, sy = 0, parameters, parse = function
   var y3 = cy1 + Math.sin(th1);
   var x2 = x3 + t * Math.sin(th1);
   var y2 = y3 - t * Math.cos(th1);
-  var result = [
+  var result2 = [
     a00 * x1 + a01 * y1,
     a10 * x1 + a11 * y1,
     a00 * x2 + a01 * y2,
@@ -15950,7 +15950,7 @@ var cx = 0, cy = 0, px = 0, py = 0, sx = 0, sy = 0, parameters, parse = function
     a00 * x3 + a01 * y3,
     a10 * x3 + a11 * y3
   ];
-  return result;
+  return result2;
 }, svgPathToOperators = function(path) {
   return apply(parse(path));
 };
@@ -21329,9 +21329,22 @@ function validateRecordDelete(value) {
 }
 function validateRecordChange(value) {
   const input = serializable(value);
-  if (Array.isArray(input?.records) && input.records.length && input.records.every((record) => !!record && typeof record === "object" && !Array.isArray(record) && !("set" in record) && !("fields" in record)))
-    return validateRecordDelete(input);
-  return validateRecordWrite(input);
+  if (!input || Array.isArray(input) || typeof input !== "object" || Object.keys(input).sort().join(",") !== "records,repository" || !validRepositoryAlias(input.repository) || !Array.isArray(input.records) || !input.records.length || input.records.length > 1e4 || new Set(input.records.map((record) => record?.ref)).size !== input.records.length || new TextEncoder().encode(JSON.stringify(input)).byteLength > RECORD_WRITE_INPUT_LIMIT)
+    throw new InboxContractError("Invalid record change batch");
+  const writes = [], deletes = [];
+  for (const record of input.records) {
+    if (!record || typeof record !== "object" || Array.isArray(record))
+      throw new InboxContractError("Invalid record change");
+    if ("set" in record || "fields" in record)
+      writes.push(record);
+    else
+      deletes.push(record);
+  }
+  if (writes.length)
+    validateRecordWrite({ repository: input.repository, records: writes });
+  if (deletes.length)
+    validateRecordDelete({ repository: input.repository, records: deletes });
+  return structuredClone(input);
 }
 function validateRoutineRecordWrite(value) {
   const body = serializable(value);
@@ -21684,14 +21697,254 @@ var connections = createConnections(async (name, operation, input) => {
 class DataOperationError extends Error {
   code;
   retryable;
-  constructor(code, retryable = false) {
+  effect;
+  component;
+  constructor(code, retryable = false, effect, component) {
     super(`Data operation failed: ${code}`);
     this.code = code;
     this.retryable = retryable;
+    this.effect = effect;
+    this.component = component;
     this.name = "DataOperationError";
   }
 }
 
+// ../../shared/data-envelope.ts
+var DATA_REQUEST_LIMIT = 256 * 1024;
+var invalidChange = () => {
+  throw new DataOperationError("invalid_change", false, "unapplied");
+};
+function mapping(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    return invalidChange();
+  if (Reflect.ownKeys(value).some((key) => typeof key !== "string" || !Object.getOwnPropertyDescriptor(value, key)?.enumerable || !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), "value")))
+    return invalidChange();
+  return value;
+}
+function captureValue(value, ancestors = new Set, depth = 0) {
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (!value || typeof value !== "object" || ancestors.has(value) || depth > 32)
+    return invalidChange();
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (value.length > 1e5 || Object.keys(value).length !== value.length || Object.getOwnPropertySymbols(value).length)
+        return invalidChange();
+      return Array.from(value, (item) => captureValue(item, ancestors, depth + 1));
+    }
+    return Object.fromEntries(Object.entries(mapping(value)).map(([key, item]) => {
+      if (["__proto__", "constructor", "prototype"].includes(key))
+        return invalidChange();
+      return [key, captureValue(item, ancestors, depth + 1)];
+    }));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function captureDataDelete(record2) {
+  const identity = mapping(record2);
+  if (!validRecordRef(identity.$ref) || typeof identity.$version !== "string" || !identity.$version.length || identity.$version.length > 512)
+    return invalidChange();
+  return { ref: identity.$ref, expectedVersion: identity.$version };
+}
+function captureDataUpdate(record2, set) {
+  const identity = captureDataDelete(record2), fields3 = mapping(set);
+  if (!Object.keys(fields3).length || Object.keys(fields3).some((key) => key.startsWith("$") || ["id", "type"].includes(key)))
+    return invalidChange();
+  return { ...identity, set: captureValue(fields3) };
+}
+function captureDataUpdates(value, allowEmpty = false) {
+  if (!Array.isArray(value) || !allowEmpty && !value.length || value.length > 1e4)
+    return invalidChange();
+  const updates = value.map((item) => {
+    const row = mapping(item);
+    if (Object.keys(row).sort().join(",") !== "expectedVersion,ref,set")
+      return invalidChange();
+    return captureDataUpdate({ $ref: row.ref, $version: row.expectedVersion }, row.set);
+  });
+  if (new Set(updates.map((update) => update.ref)).size !== updates.length)
+    return invalidChange();
+  return updates;
+}
+function captureDataCreate(value) {
+  const row = mapping(value);
+  if (!validRecordRef(row.$ref) || Object.keys(row).some((key) => key.startsWith("$") && !["$ref", "$filing"].includes(key)))
+    return invalidChange();
+  const { $ref: ref, $filing, ...fields3 } = row;
+  let filing;
+  if ($filing !== undefined) {
+    const components = mapping($filing);
+    if (Object.entries(components).some(([name, value2]) => !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name) || ["constructor", "prototype"].includes(name) || typeof value2 !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value2)))
+      return invalidChange();
+    filing = { ...components };
+  }
+  return { ref, fields: captureValue(fields3), ...filing ? { filing } : {} };
+}
+function captureDataChanges(updatesValue, createsValue = [], deletesValue = []) {
+  const updates = captureDataUpdates(updatesValue, true);
+  if (!Array.isArray(createsValue) || createsValue.length > 1e4)
+    return invalidChange();
+  const creates = createsValue.map((item) => {
+    const row = mapping(item);
+    if (Object.keys(row).some((key) => !["ref", "fields", "filing"].includes(key)) || !Object.hasOwn(row, "ref") || !Object.hasOwn(row, "fields"))
+      return invalidChange();
+    const fields3 = mapping(row.fields);
+    if (Object.keys(fields3).some((key) => key.startsWith("$")))
+      return invalidChange();
+    return captureDataCreate({ ...fields3, $ref: row.ref, ...Object.hasOwn(row, "filing") ? { $filing: row.filing } : {} });
+  });
+  if (!Array.isArray(deletesValue) || deletesValue.length > 1e4)
+    return invalidChange();
+  const deletes = deletesValue.map((item) => {
+    const row = mapping(item);
+    if (Object.keys(row).sort().join(",") !== "expectedVersion,ref")
+      return invalidChange();
+    return captureDataDelete({ $ref: row.ref, $version: row.expectedVersion });
+  });
+  const refs = [...updates, ...creates, ...deletes].map((item) => item.ref);
+  if (!refs.length || refs.length > 1e4 || new Set(refs).size !== refs.length)
+    return invalidChange();
+  return { updates, creates, deletes };
+}
+function checkDataRequestSize(input) {
+  if (new TextEncoder().encode(JSON.stringify(input)).byteLength > DATA_REQUEST_LIMIT)
+    throw new DataOperationError("request_too_large", false, "unapplied");
+}
+function dataTransportError(status, value) {
+  const failures = {
+    400: ["invalid_query", "invalid_change"],
+    401: ["unauthenticated"],
+    403: ["access_denied"],
+    409: ["conflict", "publication_pending"],
+    413: ["request_too_large"],
+    429: ["capacity"],
+    503: ["unavailable", "publication_pending"]
+  };
+  const error = value && typeof value === "object" && "error" in value ? value.error : undefined;
+  const row = error && typeof error === "object" ? error : undefined;
+  const code = failures[status]?.find((allowed) => allowed === row?.code) ?? "unavailable";
+  const effect = ["unapplied", "uncertain", "applied"].includes(String(row?.effect)) ? row.effect : undefined;
+  return new DataOperationError(code, ["capacity", "unavailable", "publication_pending"].includes(code), code === "conflict" ? "unapplied" : effect, code === "invalid_change" && typeof row?.component === "string" && /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/.test(row.component) ? row.component : undefined);
+}
+
+// ../../shared/files-contract.ts
+class FileOperationError extends Error {
+  code;
+  status;
+  retryable;
+  constructor(code, status, retryable = false) {
+    super(code);
+    this.code = code;
+    this.status = status;
+    this.retryable = retryable;
+  }
+}
+var FILE_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function parseFileDescriptor(value) {
+  const invalid = () => {
+    throw new FileOperationError("unavailable", 503, true);
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return invalid();
+  const f = value;
+  if (Object.keys(f).sort().join(",") !== "details,enrichments,id,mediaType,name,path,sha256,size" || typeof f.id !== "string" || !FILE_ID_PATTERN.test(f.id) || !safeFileName(f.name) || !safeFilePath(f.path) || !Number.isSafeInteger(f.size) || f.size < 0 || f.size > 16 * 1024 * 1024 || typeof f.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(f.sha256) || !f.enrichments || typeof f.enrichments !== "object" || Array.isArray(f.enrichments) || !f.details || typeof f.details !== "object" || Array.isArray(f.details))
+    return invalid();
+  const d = f.details;
+  if (d.kind === "other") {
+    if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream")
+      return invalid();
+  } else if (d.kind === "csv") {
+    if (Object.keys(d).sort().join(",") !== "dataRows,delimiter,encoding,headerRow,kind" || f.mediaType !== "text/csv" || !["utf-8", "windows-1252"].includes(d.encoding) || ![",", ";", "\t"].includes(d.delimiter) || !Number.isSafeInteger(d.headerRow) || d.headerRow < 1 || !Number.isSafeInteger(d.dataRows) || d.dataRows < 0)
+      return invalid();
+  } else
+    return invalid();
+  for (const [name, descriptor] of Object.entries(f.enrichments)) {
+    if (!safeEnrichmentName(name))
+      return invalid();
+    parseEnrichmentDescriptor(descriptor);
+  }
+  if (new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024)
+    return invalid();
+  return f;
+}
+function parseEnrichmentDescriptor(value) {
+  const invalid = () => {
+    throw new FileOperationError("unavailable", 503, true);
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return invalid();
+  const d = value;
+  if (Object.keys(d).sort().join(",") !== "mediaType,sha256,size" || !["application/octet-stream", "text/plain", "text/markdown", "application/json"].includes(d.mediaType) || !Number.isSafeInteger(d.size) || d.size < 0 || d.size > 16 * 1024 * 1024 || typeof d.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(d.sha256))
+    return invalid();
+  return d;
+}
+function safeEnrichmentName(value) {
+  return safeFileName(value) && !/^original(?:\.|$)/i.test(value);
+}
+function parseFileEnrichMetadata(value, maxBytes) {
+  const invalid = () => {
+    throw new FileOperationError("invalid_input", 400);
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return invalid();
+  const d = value;
+  if (Object.keys(d).some((key) => !["name", "size", "mediaType", "replace"].includes(key)) || !safeEnrichmentName(d.name) || !Number.isSafeInteger(d.size) || d.size < 0 || d.mediaType !== undefined && (typeof d.mediaType !== "string" || d.mediaType.length > 255 || /[\u0000-\u001f\u007f]/.test(d.mediaType)) || d.replace !== undefined && (typeof d.replace !== "string" || !/^[0-9a-f]{64}$/.test(d.replace)))
+    return invalid();
+  if (d.size > maxBytes)
+    throw new FileOperationError("request_too_large", 413);
+  return d;
+}
+function safeFileName(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 255 && value === value.trim() && value !== "." && value !== ".." && !/[\u0000-\u001f\u007f-\u009f/\\:*?"<>|]/u.test(value) && !/[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/.test(value) && !/[. ]$/.test(value) && !/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(value);
+}
+function safeFilePath(value) {
+  return typeof value === "string" && value.length <= 1024 && value.split("/").every(safeFileName);
+}
+function parseFileCreateMetadata(value, maxBytes) {
+  const invalid = () => {
+    throw new FileOperationError("invalid_input", 400);
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return invalid();
+  const input = value;
+  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "size", "requestKey"].includes(key)))
+    return invalid();
+  const path = input.path === undefined ? "Files" : input.path;
+  if (!safeFileName(input.name) || !safeFilePath(path))
+    return invalid();
+  if (input.storage !== undefined && input.storage !== "remote" && input.storage !== "local")
+    return invalid();
+  if (!Number.isSafeInteger(input.size) || input.size < 0)
+    return invalid();
+  if (input.size > maxBytes)
+    throw new FileOperationError("request_too_large", 413);
+  if (typeof input.requestKey !== "string" || input.requestKey.length < 1 || input.requestKey.length > 256 || input.requestKey !== input.requestKey.trim() || /[\u0000-\u001f\u007f]/.test(input.requestKey))
+    return invalid();
+  let csv;
+  if (input.csv !== undefined) {
+    if (!input.csv || typeof input.csv !== "object" || Array.isArray(input.csv))
+      return invalid();
+    const hints = input.csv;
+    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key)))
+      return invalid();
+    const encoding = hints.encoding === undefined ? "utf-8" : hints.encoding;
+    const delimiter = hints.delimiter === undefined ? "," : hints.delimiter;
+    const headerRow = hints.headerRow === undefined ? 1 : hints.headerRow;
+    if (encoding !== "utf-8" && encoding !== "windows-1252" || ![",", ";", "\t"].includes(delimiter) || !Number.isSafeInteger(headerRow) || headerRow < 1 || headerRow > 1e5)
+      return invalid();
+    csv = { encoding, delimiter, headerRow };
+  }
+  return {
+    name: input.name,
+    path,
+    ...input.storage ? { storage: input.storage } : {},
+    ...csv ? { csv } : {},
+    size: input.size,
+    requestKey: input.requestKey
+  };
+}
+
 // ../../shared/os-origin.ts
 var DEFAULT_ORIGIN = "https://auth.oddington.ai";
 function oddingtonOrigin(environment = process.env) {
@@ -21703,14 +21956,21 @@ function oddingtonOrigin(environment = process.env) {
 }
 
 // src/routine-local-transport.ts
-var dataFailures = {
-  400: ["invalid_query"],
-  401: ["unauthenticated"],
-  403: ["access_denied"],
-  413: ["request_too_large"],
-  429: ["capacity"],
-  503: ["unavailable"]
-};
+function privateRoutineRequest(environment = typeof process === "undefined" ? {} : process.env) {
+  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)
+    return;
+  const socket = prepared ? environment.ODDINGTON_ROUTINE_LOCAL_SOCKET : environment.ODDINGTON_FILES_SOCKET;
+  const token = prepared ? environment.ODDINGTON_ROUTINE_LOCAL_TOKEN : environment.ODDINGTON_FILES_TOKEN;
+  const request = localRoutineRequest(prepared ? environment : {
+    ODDINGTON_ROUTINE_LOCAL: "1",
+    ODDINGTON_ROUTINE_LOCAL_SOCKET: socket,
+    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,
@@ -21720,11 +21980,11 @@ function localRoutineRequest(environment = typeof process === "undefined" ? {} :
   if (mode === undefined && socket === undefined && token === undefined)
     return;
   if (mode !== "1" || !socket || !token || !/^[0-9a-f]{64}$/.test(token))
-    throw new Error("Local preparation transport unavailable; nothing can publish");
+    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("Local preparation transport unavailable; nothing can publish");
+    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) => {
@@ -21735,7 +21995,7 @@ function localRoutineRequest(environment = typeof process === "undefined" ? {} :
         headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
         timeout: 120000
       }, (response) => {
-        const chunks = [];
+        const bytes = Buffer.alloc(33554432);
         let size = 0;
         response.on("data", (chunk) => {
           size += chunk.length;
@@ -21743,19 +22003,37 @@ function localRoutineRequest(environment = typeof process === "undefined" ? {} :
             response.destroy();
             reject(new Error("Local result exceeds supported size"));
           } else
-            chunks.push(chunk);
+            bytes.set(chunk, size - chunk.length);
         });
         response.on("error", reject);
         response.on("end", () => {
           try {
-            const result = JSON.parse(Buffer.concat(chunks).toString());
+            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") {
-                const received = result.error && typeof result.error === "object" && "code" in result.error ? result.error.code : undefined;
-                const code = dataFailures[response.statusCode ?? 0]?.find((allowed) => allowed === received) ?? "unavailable";
-                throw new DataOperationError(code, code === "capacity" || code === "unavailable");
+                throw dataTransportError(response.statusCode ?? 0, result);
               }
-              throw new Error(typeof result.error === "string" ? result.error : "Local preparation failed");
+              throw new Error(typeof result.error === "string" ? result.error : "Preparation failed");
             }
             resolve(result);
           } catch (error) {
@@ -21763,8 +22041,8 @@ function localRoutineRequest(environment = typeof process === "undefined" ? {} :
           }
         });
       });
-      call.on("error", () => reject(new Error("Local preparation transport unavailable; nothing was published")));
-      call.on("timeout", () => call.destroy(new Error("Local preparation timed out")));
+      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));
     });
   };
@@ -21784,6 +22062,9 @@ async function resolveDataContext() {
     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();
@@ -21799,6 +22080,41 @@ async function resolveDataContext() {
     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 host = memberContext;
+    if (host) {
+      const context = await host();
+      if (!Number.isFinite(context.expiresAt) || context.expiresAt <= Date.now() || typeof context.accessToken !== "string" || !/^[^\s]{1,8192}$/.test(context.accessToken))
+        throw new Error;
+      return {
+        ...filesContext(context.workspace, context.endpoint, { authorization: `Bearer ${context.accessToken}` }),
+        isCurrent: context.isCurrent,
+        local: 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 };
+  } catch {
+    throw new FileOperationError("unsupported_context", 400);
+  }
+}
+function filesContext(workspace, endpoint, headers) {
+  if (!workspace || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(workspace) || workspace.length > 63 || ["auth", "www", "api", "os"].includes(workspace) || endpoint !== `https://${workspace}.oddington.ai`)
+    throw new Error;
+  return { url: `${endpoint}/api/files`, headers: { ...headers, "x-oddington-workspace": workspace }, isCurrent: () => true };
+}
 function checked(workspace, endpoint, headers) {
   if (!workspace || !/^[a-z0-9][a-z0-9-]{0,127}$/.test(workspace))
     throw new Error;
@@ -21809,19 +22125,12 @@ function checked(workspace, endpoint, headers) {
 }
 
 // src/data.ts
-var failures = {
-  400: ["invalid_query"],
-  401: ["unauthenticated"],
-  403: ["access_denied"],
-  413: ["request_too_large"],
-  429: ["capacity"],
-  503: ["unavailable"]
-};
 var data = {
   repository(repository) {
     async function send(input) {
       const context = await resolveDataContext();
       try {
+        checkDataRequestSize({ repository, ...input });
         if ("local" in context)
           return await context.local("data/query", { repository, ...input });
         const response = await fetch(context.url, {
@@ -21833,12 +22142,7 @@ var data = {
         });
         const result = await response.json();
         if (!response.ok) {
-          const error = result && typeof result === "object" && "error" in result ? result.error : undefined;
-          const received = error && typeof error === "object" && "code" in error ? error.code : undefined;
-          const code = failures[response.status]?.find((allowed) => allowed === received);
-          if (code)
-            throw new DataOperationError(code, code === "capacity" || code === "unavailable");
-          throw new DataOperationError("unavailable", true);
+          throw dataTransportError(response.status, result);
         }
         return result;
       } catch (error) {
@@ -21852,10 +22156,425 @@ var data = {
         list: () => send({ operation: "collections.list" }),
         schema: (name) => send({ operation: "collections.schema", name })
       },
-      records: { select: (query) => send({ operation: "records.select", query }) }
+      records: { select: (query) => send({ operation: "records.select", query }) },
+      changes() {
+        let updates = [], creates = [], deletes = [], publicationId;
+        let pending, confirmed;
+        const snapshot = () => {
+          const captured = captureDataChanges(updates, creates, deletes);
+          const input = {
+            updates: captured.updates,
+            ...captured.creates.length ? { creates: captured.creates } : {},
+            ...captured.deletes.length ? { deletes: captured.deletes } : {}
+          };
+          checkDataRequestSize({
+            repository,
+            operation: "changes.publish",
+            ...input,
+            publicationId: publicationId ?? "00000000-0000-4000-8000-000000000000"
+          });
+          return input;
+        };
+        return {
+          create(record2) {
+            if (publicationId)
+              throw new DataOperationError("invalid_change", false, "unapplied");
+            const next = [...creates, captureDataCreate(record2)];
+            captureDataChanges(updates, next, deletes);
+            checkDataRequestSize({
+              repository,
+              operation: "changes.publish",
+              updates,
+              creates: next,
+              ...deletes.length ? { deletes } : {},
+              publicationId: "00000000-0000-4000-8000-000000000000"
+            });
+            creates = next;
+          },
+          update(record2, set) {
+            if (publicationId)
+              throw new DataOperationError("invalid_change", false, "unapplied");
+            const next = [...updates, captureDataUpdate(record2, set)];
+            captureDataChanges(next, creates, deletes);
+            checkDataRequestSize({
+              repository,
+              operation: "changes.publish",
+              updates: next,
+              ...creates.length ? { creates } : {},
+              ...deletes.length ? { deletes } : {},
+              publicationId: "00000000-0000-4000-8000-000000000000"
+            });
+            updates = next;
+          },
+          delete(record2) {
+            if (publicationId)
+              throw new DataOperationError("invalid_change", false, "unapplied");
+            const next = [...deletes, captureDataDelete(record2)];
+            captureDataChanges(updates, creates, next);
+            checkDataRequestSize({
+              repository,
+              operation: "changes.publish",
+              updates,
+              deletes: next,
+              ...creates.length ? { creates } : {},
+              publicationId: "00000000-0000-4000-8000-000000000000"
+            });
+            deletes = next;
+          },
+          async validate() {
+            await send({ operation: "changes.validate", ...snapshot() });
+          },
+          publish() {
+            if (confirmed)
+              return Promise.resolve(structuredClone(confirmed));
+            if (!pending) {
+              let captured;
+              try {
+                captured = snapshot();
+              } catch (error) {
+                return Promise.reject(error);
+              }
+              publicationId ??= crypto.randomUUID();
+              pending = send({ operation: "changes.publish", ...captured, publicationId }).then((result) => {
+                confirmed = structuredClone(result);
+                return result;
+              }).catch((error) => {
+                if (error instanceof DataOperationError)
+                  throw new DataOperationError(error.code, error.retryable, error.effect ?? (["unavailable", "publication_pending"].includes(error.code) ? "uncertain" : "unapplied"), error.component);
+                throw new DataOperationError("unavailable", true, "uncertain");
+              }).finally(() => {
+                pending = undefined;
+              });
+            }
+            return pending.then((result) => structuredClone(result));
+          }
+        };
+      }
     };
   }
 };
+// src/files.ts
+var MAX_BYTES = 16 * 1024 * 1024;
+var METADATA_BYTES = 4096;
+var RESULT_BYTES = 16 * 1024;
+var TIMEOUT_MS = 30000;
+var MAX_ACTIVE = 4;
+var ATTEMPTS = 2;
+var active = 0;
+var invalid = () => new FileOperationError("invalid_input", 400);
+var unavailable = () => new FileOperationError("unavailable", 503, true);
+var failures = {
+  400: ["invalid_input", "unsupported_context"],
+  401: ["unauthenticated"],
+  403: ["access_denied"],
+  405: ["method_not_allowed"],
+  409: ["conflict", "local_only"],
+  413: ["request_too_large"],
+  429: ["capacity"],
+  503: ["integrity", "unavailable"]
+};
+async function boundedBytes(stream, limit) {
+  if (!stream)
+    return new Uint8Array;
+  const reader = stream.getReader();
+  const bytes = new Uint8Array(limit);
+  let size = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (!(value instanceof Uint8Array))
+        throw invalid();
+      size += value.byteLength;
+      if (size > limit)
+        throw new FileOperationError("request_too_large", 413);
+      bytes.set(value, size - value.byteLength);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return bytes.slice(0, size);
+}
+async function timed(work, parent) {
+  const controller = new AbortController;
+  let timer;
+  let abort;
+  const expiry = new Promise((_, reject) => {
+    abort = () => {
+      controller.abort();
+      reject(unavailable());
+    };
+    timer = setTimeout(abort, TIMEOUT_MS);
+    parent?.addEventListener("abort", abort, { once: true });
+    if (parent?.aborted)
+      abort();
+  });
+  try {
+    return await Promise.race([work(controller.signal), expiry]);
+  } finally {
+    clearTimeout(timer);
+    parent?.removeEventListener("abort", abort);
+  }
+}
+async function result(response) {
+  try {
+    const bytes = await boundedBytes(response.body, RESULT_BYTES);
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw unavailable();
+  }
+}
+async function send(suffix, init, descriptor, initial, parent) {
+  const original = initial;
+  const checkCurrent = () => {
+    if (parent?.aborted)
+      throw unavailable();
+    if (!original.isCurrent())
+      throw new FileOperationError("unsupported_context", 400);
+  };
+  for (let attempt = 0;attempt < ATTEMPTS; attempt++) {
+    checkCurrent();
+    const context = await resolveFilesContext();
+    checkCurrent();
+    if (context.url !== original.url)
+      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 fetch(`${context.url}${suffix}`, {
+          ...init,
+          signal: parent,
+          headers: { ...context.headers, ...init.headers },
+          redirect: "error",
+          cache: "no-store"
+        });
+        if (!response.ok) {
+          const value2 = await result(response);
+          const error = value2 && typeof value2 === "object" && "error" in value2 ? value2.error : undefined;
+          const received = error && typeof error === "object" && "code" in error ? error.code : undefined;
+          const code = failures[response.status]?.find((code2) => code2 === received);
+          throw code ? new FileOperationError(code, response.status, code === "capacity" || code === "unavailable") : unavailable();
+        }
+        if (response.status !== 200) {
+          response.body?.cancel().catch(() => {});
+          throw unavailable();
+        }
+        try {
+          checkCurrent();
+        } catch (error) {
+          response.body?.cancel().catch(() => {});
+          throw error;
+        }
+        if (!descriptor)
+          return response;
+        const value = await result(response);
+        let parsed;
+        if (descriptor === "enrichment") {
+          if (!value || typeof value !== "object" || Array.isArray(value))
+            throw unavailable();
+          const { name, ...metadata } = value;
+          if (!safeEnrichmentName(name))
+            throw unavailable();
+          parsed = { name, ...parseEnrichmentDescriptor(metadata) };
+        } else
+          parsed = parseFileDescriptor(value);
+        checkCurrent();
+        return parsed;
+      })();
+    } catch (error) {
+      const failure = error instanceof FileOperationError ? error : unavailable();
+      if (!failure.retryable || attempt + 1 === ATTEMPTS)
+        throw failure;
+    }
+  }
+  throw unavailable();
+}
+function idPath(id2) {
+  if (typeof id2 !== "string" || !FILE_ID_PATTERN.test(id2))
+    throw invalid();
+  return `/${id2}`;
+}
+async function operation(work, initial, parent) {
+  const context = initial ?? await resolveFilesContext();
+  if (active >= MAX_ACTIVE)
+    throw new FileOperationError("capacity", 429, true);
+  active++;
+  return timed(async (signal) => {
+    try {
+      return await work(context, signal);
+    } finally {
+      active--;
+    }
+  }, parent).catch((error) => {
+    throw error instanceof FileOperationError ? error : unavailable();
+  });
+}
+function contentPath(id2, name) {
+  const path = idPath(id2);
+  if (name === undefined)
+    return `${path}/content`;
+  if (!safeEnrichmentName(name))
+    throw invalid();
+  return `${path}/enrichments/${encodeURIComponent(name)}/content`;
+}
+async function read(id2, names) {
+  const context = await resolveFilesContext();
+  idPath(id2);
+  if (names === undefined || typeof names === "string") {
+    const path = contentPath(id2, names);
+    return operation((context2, signal) => send(path, { method: "GET" }, false, context2, signal), context);
+  }
+  if (!Array.isArray(names))
+    throw invalid();
+  const distinct = [];
+  const seen = new Set;
+  for (const name of names) {
+    if (typeof name !== "string" || !safeEnrichmentName(name))
+      throw invalid();
+    if (seen.has(name))
+      continue;
+    if (seen.size === 16)
+      throw invalid();
+    seen.add(name);
+    distinct.push(name);
+  }
+  const paths = distinct.map((name) => contentPath(id2, name));
+  return timed(async (parent) => {
+    const responses = {};
+    try {
+      for (let i = 0;i < paths.length; i++) {
+        const response = await operation((context2, signal) => send(paths[i], { method: "GET" }, false, context2, signal), context, parent);
+        Object.defineProperty(responses, distinct[i], { value: response, enumerable: true });
+      }
+      if (!context.isCurrent())
+        throw new FileOperationError("unsupported_context", 400);
+      return responses;
+    } catch (error) {
+      for (const response of Object.values(responses))
+        response.body?.cancel().catch(() => {});
+      throw error;
+    }
+  });
+}
+var files = {
+  async upload(id2) {
+    return operation(async (context, signal) => {
+      const file = await send(`${idPath(id2)}/upload`, { method: "POST" }, true, context, signal);
+      if (file.id !== id2)
+        throw unavailable();
+      return file;
+    });
+  },
+  async create(input, options) {
+    const context = await resolveFilesContext();
+    if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "size", "path", "name", "storage", "csv"].includes(key)) || options !== undefined && (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some((key) => key !== "requestKey")))
+      throw invalid();
+    const blob = input.file instanceof Blob;
+    const array2 = input.file instanceof Uint8Array;
+    const stream = input.file instanceof ReadableStream;
+    if (!blob && !array2 && !stream)
+      throw invalid();
+    const intrinsic = blob ? input.file.size : array2 ? input.file.byteLength : undefined;
+    if (intrinsic !== undefined && input.size !== undefined && input.size !== intrinsic)
+      throw invalid();
+    let name = input.name;
+    if (name === undefined && blob && "name" in input.file && typeof input.file.name === "string") {
+      name = typeof globalThis.File !== "undefined" && input.file instanceof globalThis.File ? input.file.name : input.file.name.split(/[\\/]/).at(-1);
+    }
+    const metadata = parseFileCreateMetadata({
+      name,
+      size: intrinsic ?? input.size,
+      path: input.path,
+      storage: input.storage,
+      csv: input.csv,
+      requestKey: options?.requestKey === undefined ? crypto.randomUUID() : options.requestKey
+    }, MAX_BYTES);
+    if (!context.local && metadata.storage === "local")
+      throw new FileOperationError("unsupported_context", 400);
+    const header = encodeURIComponent(JSON.stringify(metadata));
+    if (new TextEncoder().encode(header).byteLength > METADATA_BYTES)
+      throw invalid();
+    if (active >= MAX_ACTIVE)
+      throw new FileOperationError("capacity", 429, true);
+    active++;
+    return timed(async (signal) => {
+      try {
+        const bytes = array2 ? input.file.slice() : await boundedBytes(blob ? input.file.stream() : input.file, metadata.size);
+        if (bytes.byteLength !== metadata.size)
+          throw invalid();
+        if (signal.aborted)
+          throw unavailable();
+        return await send("", {
+          method: "POST",
+          headers: { "content-type": "application/octet-stream", "x-oddington-file": header },
+          body: bytes.buffer
+        }, true, context, signal);
+      } finally {
+        active--;
+      }
+    }).catch((error) => {
+      throw error instanceof FileOperationError ? error : unavailable();
+    });
+  },
+  async enrich(input) {
+    const context = await resolveFilesContext();
+    if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "name", "content", "mediaType", "replace"].includes(key)) || typeof input.content !== "string" && !(input.content instanceof Uint8Array))
+      throw invalid();
+    const path = `${idPath(input.file)}/enrichments`;
+    if (typeof input.content === "string" ? input.content.length > MAX_BYTES : input.content.byteLength > MAX_BYTES)
+      throw new FileOperationError("request_too_large", 413);
+    return operation(async (context2, signal) => {
+      let bytes;
+      if (typeof input.content === "string") {
+        const buffer = new Uint8Array(Math.min(MAX_BYTES, input.content.length * 3));
+        const encoded = new TextEncoder().encodeInto(input.content, buffer);
+        if (encoded.read !== input.content.length)
+          throw new FileOperationError("request_too_large", 413);
+        bytes = buffer.slice(0, encoded.written);
+      } else
+        bytes = input.content.slice();
+      const metadata = parseFileEnrichMetadata({
+        name: input.name,
+        size: bytes.byteLength,
+        ...input.mediaType === undefined ? {} : { mediaType: input.mediaType },
+        ...input.replace === undefined ? {} : { replace: input.replace }
+      }, MAX_BYTES);
+      const header = encodeURIComponent(JSON.stringify(metadata));
+      if (new TextEncoder().encode(header).byteLength > METADATA_BYTES)
+        throw invalid();
+      const result2 = await send(path, { method: "POST", headers: {
+        "content-type": "application/octet-stream",
+        "x-oddington-enrichment": header
+      }, body: bytes.buffer }, "enrichment", context2, signal);
+      if (result2.name !== metadata.name)
+        throw unavailable();
+      return result2;
+    }, context);
+  },
+  async get(id2) {
+    return operation((context, signal) => send(idPath(id2), { method: "GET" }, true, context, signal));
+  },
+  read
+};
 // src/os.ts
 var installedDispose;
 function init({ auth }) {
@@ -21870,7 +22589,7 @@ function init({ auth }) {
       workspace = slug;
     }
   } catch {}
-  let active = true;
+  let active2 = true;
   let revision = 0;
   let person;
   const { data: { subscription } } = auth.onAuthStateChange((event, session) => {
@@ -21880,11 +22599,11 @@ function init({ auth }) {
     person = next;
   });
   const resolve = async () => {
-    if (!active || !endpoint || !workspace)
+    if (!active2 || !endpoint || !workspace)
       throw new Error("Hosted Data context unavailable.");
     const started = revision;
     const { data: { session }, error } = await auth.getSession();
-    if (!active || started !== revision || error || !session || person !== undefined && person !== session.user.id) {
+    if (!active2 || started !== revision || error || !session || person !== undefined && person !== session.user.id) {
       throw new Error("Hosted Data context unavailable.");
     }
     const expiresAt = (session.expires_at ?? 0) * 1000;
@@ -21892,13 +22611,19 @@ function init({ auth }) {
       throw new Error("Hosted Data context unavailable.");
     }
     person = session.user.id;
-    return { workspace, endpoint, accessToken: session.access_token, expiresAt };
+    return {
+      workspace,
+      endpoint,
+      accessToken: session.access_token,
+      expiresAt,
+      isCurrent: () => active2 && revision === started && person === session.user.id
+    };
   };
   const uninstall = installMemberContext(resolve);
   const dispose = () => {
-    if (!active)
+    if (!active2)
       return;
-    active = false;
+    active2 = false;
     revision++;
     subscription.unsubscribe();
     uninstall();
@@ -21932,31 +22657,31 @@ function routinePublicationClient(options = {}) {
   } : async () => {
     throw new Error("Member publication requires a host-supplied request");
   });
-  async function send(operation, body) {
+  async function send2(operation2, body) {
     if (local)
-      return await local(operation, body);
-    const response = await request(`/api/cli/workspaces/${workspace}/inbox/${operation}`, {
+      return await local(operation2, body);
+    const response = await request(`/api/cli/workspaces/${workspace}/inbox/${operation2}`, {
       method: "POST",
       headers: { "content-type": "application/json", ...headers },
       body: JSON.stringify(body)
     });
-    const result = await response.json();
-    if (!response.ok && operation === "records/update")
-      throw new RoutineRecordWriteError(result.error ?? "Could not confirm routine preparation", result.effect ?? "uncertain");
+    const result2 = await response.json();
+    if (!response.ok && operation2 === "records/update")
+      throw new RoutineRecordWriteError(result2.error ?? "Could not confirm routine preparation", result2.effect ?? "uncertain");
     if (!response.ok)
-      throw new Error(result.error ?? "Could not confirm routine publication");
-    return result;
+      throw new Error(result2.error ?? "Could not confirm routine publication");
+    return result2;
   }
   const transport = {
     async publish(body) {
-      return await send("publish", body);
+      return await send2("publish", body);
     },
     async resolve(body) {
-      await send("resolve", body);
+      await send2("resolve", body);
     }
   };
   async function readRecords(input) {
-    return await send("records/read", validateRecordRead(input));
+    return await send2("records/read", validateRecordRead(input));
   }
   return {
     ...createInboxPublisher(transport),
@@ -21966,17 +22691,17 @@ function routinePublicationClient(options = {}) {
       async writeRecords(input, options2) {
         if (!capability)
           throw new Error("A trusted routine launch is required");
-        return await send("records/update", validateRoutineRecordWrite({ input, requestKey: options2?.requestKey }));
+        return await send2("records/update", validateRoutineRecordWrite({ input, requestKey: options2?.requestKey }));
       },
       async updateRecords(input, options2) {
         if (!capability)
           throw new Error("A trusted routine launch is required");
-        return await send("records/update", validateRoutineRecordWrite({ input: validateRecordUpdate(input), requestKey: options2?.requestKey }));
+        return await send2("records/update", validateRoutineRecordWrite({ input: validateRecordUpdate(input), requestKey: options2?.requestKey }));
       },
       async deleteRecords(input, options2) {
         if (!capability)
           throw new Error("A trusted routine launch is required");
-        return await send("records/update", validateRoutineRecordWrite({ input: validateRecordDelete(input), requestKey: options2?.requestKey }));
+        return await send2("records/update", validateRoutineRecordWrite({ input: validateRecordDelete(input), requestKey: options2?.requestKey }));
       }
     },
     files: {
@@ -21998,14 +22723,14 @@ function routinePublicationClient(options = {}) {
           },
           body: Uint8Array.from(bytes).buffer
         });
-        const result = await response.json();
+        const result2 = await response.json();
         if (!response.ok)
-          throw new Error(result.error ?? "Could not retain file");
-        return await verifyInboxFile(bytes, validateInboxFile(result));
+          throw new Error(result2.error ?? "Could not retain file");
+        return await verifyInboxFile(bytes, validateInboxFile(result2));
       }
     },
     async check(body) {
-      await send("check", { requestKey: body.requestKey, item: validatePublication(body.item) });
+      await send2("check", { requestKey: body.requestKey, item: validatePublication(body.item) });
     }
   };
 }
@@ -22019,6 +22744,7 @@ export {
   recordBlock,
   question,
   os,
+  files,
   fileBlock,
   defineHandler,
   data,
@@ -22027,6 +22753,7 @@ export {
   asksBlock,
   RoutineRecordWriteError,
   InboxContractError,
+  FileOperationError,
   DataOperationError,
   AirtableOperationError
 };