@oddington/sdk 0.1.4 → 0.1.6

package/dist/index.js

@@ -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;
     }
@@ -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);
@@ -21685,15 +21698,60 @@ class DataOperationError extends Error {
   code;
   retryable;
   effect;
-  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-search-input.ts
+var invalid = () => {
+  throw new DataOperationError("invalid_query");
+};
+var scalarText = (value) => typeof value === "string" && !/[\u0000\uD800-\uDFFF]/u.test(value);
+function captureRecordsSearchInput(query, options) {
+  if (!scalarText(query))
+    return invalid();
+  const length = [...query.trim()].length;
+  if (length < 1 || length > 256)
+    return invalid();
+  if (options === undefined)
+    return { query };
+  if (!options || typeof options !== "object" || Array.isArray(options) || ![Object.prototype, null].includes(Object.getPrototypeOf(options)))
+    return invalid();
+  const descriptors = Object.getOwnPropertyDescriptors(options);
+  if (Reflect.ownKeys(options).some((key) => typeof key !== "string" || !["collections", "limit"].includes(key) || !descriptors[key]?.enumerable || !Object.hasOwn(descriptors[key], "value")))
+    return invalid();
+  const captured = {};
+  if (Object.hasOwn(descriptors, "collections")) {
+    const supplied = descriptors.collections.value;
+    if (!Array.isArray(supplied) || supplied.length < 1 || supplied.length > 16 || Reflect.ownKeys(supplied).length !== supplied.length + 1)
+      return invalid();
+    const collections = [];
+    for (let index = 0;index < supplied.length; index++) {
+      const descriptor = Object.getOwnPropertyDescriptor(supplied, String(index));
+      if (!descriptor?.enumerable || !Object.hasOwn(descriptor, "value") || !scalarText(descriptor.value))
+        return invalid();
+      collections.push(descriptor.value);
+    }
+    if (new Set(collections).size !== collections.length)
+      return invalid();
+    captured.collections = collections;
+  }
+  if (Object.hasOwn(descriptors, "limit")) {
+    const supplied = descriptors.limit.value;
+    if (!Number.isInteger(supplied) || supplied < 1 || supplied > 100)
+      return invalid();
+    captured.limit = supplied;
+  }
+  return { query, options: captured };
+}
+
 // ../../shared/data-envelope.ts
 var DATA_REQUEST_LIMIT = 256 * 1024;
 var invalidChange = () => {
@@ -21727,14 +21785,20 @@ function captureValue(value, ancestors = new Set, depth = 0) {
     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 = mapping(record2), fields3 = mapping(set);
-  if (!validRecordRef(identity.$ref) || typeof identity.$version !== "string" || !identity.$version.length || identity.$version.length > 512 || !Object.keys(fields3).length || Object.keys(fields3).some((key) => key.startsWith("$") || ["id", "type"].includes(key)))
+  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 { ref: identity.$ref, expectedVersion: identity.$version, set: captureValue(fields3) };
+  return { ...identity, set: captureValue(fields3) };
 }
-function captureDataUpdates(value) {
-  if (!Array.isArray(value) || !value.length || value.length > 1e4)
+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);
@@ -21746,6 +21810,46 @@ function captureDataUpdates(value) {
     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");
@@ -21764,7 +21868,7 @@ function dataTransportError(status, value) {
   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);
+  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
@@ -21781,25 +21885,59 @@ class FileOperationError extends Error {
 }
 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 = () => {
+  const invalid2 = () => {
     throw new FileOperationError("unavailable", 503, true);
   };
   if (!value || typeof value !== "object" || Array.isArray(value))
-    return invalid();
+    return invalid2();
   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 || typeof f.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(f.sha256) || !f.enrichments || typeof f.enrichments !== "object" || Array.isArray(f.enrichments) || Object.keys(f.enrichments).length !== 0 || !f.details || typeof f.details !== "object" || Array.isArray(f.details))
-    return invalid();
+  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 invalid2();
   const d = f.details;
   if (d.kind === "other") {
     if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream")
-      return invalid();
+      return invalid2();
   } 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();
+      return invalid2();
   } else
-    return invalid();
+    return invalid2();
+  for (const [name, descriptor] of Object.entries(f.enrichments)) {
+    if (!safeEnrichmentName(name))
+      return invalid2();
+    parseEnrichmentDescriptor(descriptor);
+  }
+  if (new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024)
+    return invalid2();
   return f;
 }
+function parseEnrichmentDescriptor(value) {
+  const invalid2 = () => {
+    throw new FileOperationError("unavailable", 503, true);
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return invalid2();
+  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 invalid2();
+  return d;
+}
+function safeEnrichmentName(value) {
+  return safeFileName(value) && !/^original(?:\.|$)/i.test(value);
+}
+function parseFileEnrichMetadata(value, maxBytes) {
+  const invalid2 = () => {
+    throw new FileOperationError("invalid_input", 400);
+  };
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return invalid2();
+  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 invalid2();
+  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);
 }
@@ -21807,42 +21945,47 @@ function safeFilePath(value) {
   return typeof value === "string" && value.length <= 1024 && value.split("/").every(safeFileName);
 }
 function parseFileCreateMetadata(value, maxBytes) {
-  const invalid = () => {
+  const invalid2 = () => {
     throw new FileOperationError("invalid_input", 400);
   };
   if (!value || typeof value !== "object" || Array.isArray(value))
-    return invalid();
+    return invalid2();
   const input = value;
   if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "size", "requestKey"].includes(key)))
-    return invalid();
+    return invalid2();
   const path = input.path === undefined ? "Files" : input.path;
   if (!safeFileName(input.name) || !safeFilePath(path))
-    return invalid();
-  if (input.storage === "local" || input.storage === "both")
-    throw new FileOperationError("unsupported_context", 400);
-  if (input.storage !== undefined && input.storage !== "remote")
-    return invalid();
+    return invalid2();
+  if (input.storage !== undefined && input.storage !== "remote" && input.storage !== "local")
+    return invalid2();
   if (!Number.isSafeInteger(input.size) || input.size < 0)
-    return invalid();
+    return invalid2();
   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();
+    return invalid2();
   let csv;
   if (input.csv !== undefined) {
     if (!input.csv || typeof input.csv !== "object" || Array.isArray(input.csv))
-      return invalid();
+      return invalid2();
     const hints = input.csv;
     if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key)))
-      return invalid();
+      return invalid2();
     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();
+      return invalid2();
     csv = { encoding, delimiter, headerRow };
   }
-  return { name: input.name, path, storage: "remote", ...csv ? { csv } : {}, size: input.size, requestKey: input.requestKey };
+  return {
+    name: input.name,
+    path,
+    ...input.storage ? { storage: input.storage } : {},
+    ...csv ? { csv } : {},
+    size: input.size,
+    requestKey: input.requestKey
+  };
 }
 
 // ../../shared/os-origin.ts
@@ -21856,6 +21999,21 @@ function oddingtonOrigin(environment = process.env) {
 }
 
 // src/routine-local-transport.ts
+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,
@@ -21865,11 +22023,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) => {
@@ -21880,7 +22038,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;
@@ -21888,17 +22046,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") {
                 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) {
@@ -21906,8 +22084,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));
     });
   };
@@ -21927,6 +22105,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();
@@ -21945,8 +22126,14 @@ async function resolveDataContext() {
 async function resolveFilesContext() {
   try {
     const environment = typeof process === "undefined" ? {} : process.env;
-    if (["ODDINGTON_ROUTINE_LOCAL", "ODDINGTON_ROUTINE_LOCAL_SOCKET", "ODDINGTON_ROUTINE_LOCAL_TOKEN"].some((key) => environment[key] !== undefined))
-      throw new Error;
+    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();
@@ -21954,13 +22141,14 @@ async function resolveFilesContext() {
         throw new Error;
       return {
         ...filesContext(context.workspace, context.endpoint, { authorization: `Bearer ${context.accessToken}` }),
-        isCurrent: context.isCurrent
+        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 });
+    return { ...filesContext(workspace, `https://${workspace}.oddington.ai`, { "x-oddington-run": environment.ODDINGTON_ROUTINE_RUN }), local: undefined };
   } catch {
     throw new FileOperationError("unsupported_context", 400);
   }
@@ -22011,36 +22199,82 @@ 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 }),
+        search: (query, options) => {
+          try {
+            return send({ operation: "records.search", ...captureRecordsSearchInput(query, options) });
+          } catch (error) {
+            return Promise.reject(error);
+          }
+        }
+      },
       changes() {
-        let updates = [], publicationId;
+        let updates = [], creates = [], deletes = [], publicationId;
         let pending, confirmed;
         const snapshot = () => {
-          const captured = captureDataUpdates(updates);
+          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",
-            updates: captured,
+            ...input,
             publicationId: publicationId ?? "00000000-0000-4000-8000-000000000000"
           });
-          return captured;
+          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)];
-            captureDataUpdates(next);
+            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", updates: snapshot() });
+            await send({ operation: "changes.validate", ...snapshot() });
           },
           publish() {
             if (confirmed)
@@ -22053,12 +22287,12 @@ var data = {
                 return Promise.reject(error);
               }
               publicationId ??= crypto.randomUUID();
-              pending = send({ operation: "changes.publish", updates: captured, publicationId }).then((result) => {
+              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"));
+                  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;
@@ -22079,14 +22313,14 @@ var TIMEOUT_MS = 30000;
 var MAX_ACTIVE = 4;
 var ATTEMPTS = 2;
 var active = 0;
-var invalid = () => new FileOperationError("invalid_input", 400);
+var invalid2 = () => 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"],
+  409: ["conflict", "local_only"],
   413: ["request_too_large"],
   429: ["capacity"],
   503: ["integrity", "unavailable"]
@@ -22103,7 +22337,7 @@ async function boundedBytes(stream, limit) {
       if (done)
         break;
       if (!(value instanceof Uint8Array))
-        throw invalid();
+        throw invalid2();
       size += value.byteLength;
       if (size > limit)
         throw new FileOperationError("request_too_large", 413);
@@ -22143,8 +22377,76 @@ async function result(response) {
     throw unavailable();
   }
 }
+async function hostedContent(url, init, parent) {
+  const delivery = new AbortController;
+  const abort = () => delivery.abort(parent.reason);
+  parent.addEventListener("abort", abort, { once: true });
+  if (parent.aborted)
+    abort();
+  const detach = () => parent.removeEventListener("abort", abort);
+  try {
+    const response = await fetch(url, { ...init, signal: delivery.signal });
+    if (delivery.signal.aborted) {
+      response.body?.cancel().catch(() => {});
+      throw unavailable();
+    }
+    if (!response.body) {
+      detach();
+      return response;
+    }
+    const source = response.body;
+    let reader;
+    let settled = false;
+    const cancel = async (reason) => {
+      if (settled)
+        return;
+      settled = true;
+      detach();
+      delivery.abort(reason);
+      try {
+        await (reader ? reader.cancel(reason) : source.cancel(reason));
+      } catch (error) {
+        if (error !== delivery.signal.reason && !(error instanceof Error && error.name === "AbortError"))
+          throw error;
+      } finally {
+        reader?.releaseLock();
+      }
+    };
+    const body = new ReadableStream({
+      async pull(controller) {
+        try {
+          reader ??= source.getReader();
+          const { done, value } = await reader.read();
+          if (settled)
+            return;
+          if (done) {
+            settled = true;
+            detach();
+            reader.releaseLock();
+            controller.close();
+          } else
+            controller.enqueue(value);
+        } catch (error) {
+          if (settled)
+            return;
+          controller.error(error);
+          await cancel(error).catch(() => {});
+        }
+      },
+      cancel
+    }, { highWaterMark: 0 });
+    const wrapped = new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+    for (const key of ["url", "redirected", "type"])
+      Object.defineProperty(wrapped, key, { value: response[key] });
+    return wrapped;
+  } catch (error) {
+    detach();
+    delivery.abort(error);
+    throw error;
+  }
+}
 async function send(suffix, init, descriptor, initial, parent) {
-  const original = initial ?? await resolveFilesContext();
+  const original = initial;
   const checkCurrent = () => {
     if (parent?.aborted)
       throw unavailable();
@@ -22153,37 +22455,75 @@ async function send(suffix, init, descriptor, initial, parent) {
   };
   for (let attempt = 0;attempt < ATTEMPTS; attempt++) {
     checkCurrent();
-    const context = attempt === 0 && !initial ? original : await resolveFilesContext();
+    const context = await resolveFilesContext();
     checkCurrent();
     if (context.url !== original.url)
       throw new FileOperationError("unsupported_context", 400);
     try {
-      return await timed(async (signal) => {
-        const response = await fetch(`${context.url}${suffix}`, {
-          ...init,
-          signal,
-          headers: { ...context.headers, ...init.headers },
-          redirect: "error",
-          cache: "no-store"
-        });
+      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 url = `${context.url}${suffix}`;
+          const request = {
+            ...init,
+            signal: parent,
+            headers: { ...context.headers, ...init.headers },
+            redirect: "error",
+            cache: "no-store"
+          };
+          return descriptor ? fetch(url, request) : hostedContent(url, request, parent);
+        })();
         if (!response.ok) {
-          const value = await result(response);
-          const error = value && typeof value === "object" && "error" in value ? value.error : undefined;
+          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)
+        if (response.status !== 200) {
+          response.body?.cancel().catch(() => {});
           throw unavailable();
-        checkCurrent();
+        }
+        try {
+          checkCurrent();
+        } catch (error) {
+          response.body?.cancel().catch(() => {});
+          throw error;
+        }
         if (!descriptor)
           return response;
-        const file = parseFileDescriptor(await result(response));
-        if (file.size > MAX_BYTES)
-          throw unavailable();
+        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 file;
-      }, parent);
+        return parsed;
+      })();
     } catch (error) {
       const failure = error instanceof FileOperationError ? error : unavailable();
       if (!failure.retryable || attempt + 1 === ATTEMPTS)
@@ -22194,22 +22534,92 @@ async function send(suffix, init, descriptor, initial, parent) {
 }
 function idPath(id2) {
   if (typeof id2 !== "string" || !FILE_ID_PATTERN.test(id2))
-    throw invalid();
+    throw invalid2();
   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 invalid2();
+  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 invalid2();
+  const distinct = [];
+  const seen = new Set;
+  for (const name of names) {
+    if (typeof name !== "string" || !safeEnrichmentName(name))
+      throw invalid2();
+    if (seen.has(name))
+      continue;
+    if (seen.size === 16)
+      throw invalid2();
+    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();
+      throw invalid2();
     const blob = input.file instanceof Blob;
     const array2 = input.file instanceof Uint8Array;
     const stream = input.file instanceof ReadableStream;
     if (!blob && !array2 && !stream)
-      throw invalid();
+      throw invalid2();
     const intrinsic = blob ? input.file.size : array2 ? input.file.byteLength : undefined;
     if (intrinsic !== undefined && input.size !== undefined && input.size !== intrinsic)
-      throw invalid();
+      throw invalid2();
     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);
@@ -22222,9 +22632,11 @@ var files = {
       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();
+      throw invalid2();
     if (active >= MAX_ACTIVE)
       throw new FileOperationError("capacity", 429, true);
     active++;
@@ -22232,7 +22644,7 @@ var files = {
       try {
         const bytes = array2 ? input.file.slice() : await boundedBytes(blob ? input.file.stream() : input.file, metadata.size);
         if (bytes.byteLength !== metadata.size)
-          throw invalid();
+          throw invalid2();
         if (signal.aborted)
           throw unavailable();
         return await send("", {
@@ -22247,12 +22659,45 @@ var files = {
       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 invalid2();
+    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 invalid2();
+      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 send(idPath(id2), { method: "GET" }, true);
+    return operation((context, signal) => send(idPath(id2), { method: "GET" }, true, context, signal));
   },
-  async read(id2) {
-    return send(`${idPath(id2)}/content`, { method: "GET" }, false);
-  }
+  read
 };
 // src/os.ts
 var installedDispose;
@@ -22336,16 +22781,16 @@ function routinePublicationClient(options = {}) {
   } : async () => {
     throw new Error("Member publication requires a host-supplied request");
   });
-  async function send2(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 result2 = await response.json();
-    if (!response.ok && operation === "records/update")
+    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(result2.error ?? "Could not confirm routine publication");