@oddington/sdk 0.1.37 → 0.1.39

package/dist/browser.js

@@ -8,7 +8,8 @@ var fileValidationReasons = {
   invalid_request_key: "File request key must contain 1\u2013256 characters, with no surrounding whitespace or control characters.",
   invalid_enrichment_name: "Enrichment name must be a safe filename and cannot be original or original.*.",
   invalid_replacement: "Enrichment replacement must be a SHA-256 hash of 64 lowercase hexadecimal characters.",
-  invalid_bytes: "File content must contain byte chunks."
+  invalid_bytes: "File content must contain byte chunks.",
+  original_changed: "The selected file changed while OS was reading it. Wait for it to finish saving, then try again."
 };
 function parseFileErrorDetail(value) {
   if (!value || typeof value != "object" || Array.isArray(value)) return;
@@ -29,10 +30,10 @@ function parseFileErrorDetail(value) {
 function fileErrorExplanation(detail) {
   return detail.reason === "size_mismatch" ? `File byte count mismatch: expected ${detail.expectedBytes} bytes; received ${detail.receivedAtLeast ? "at least " : ""}${detail.receivedBytes} bytes.` : detail.reason === "size_limit" ? `File size exceeds the ${detail.limitBytes}-byte limit; received ${detail.receivedAtLeast ? "at least " : ""}${detail.receivedBytes} bytes.` : fileValidationReasons[detail.reason];
 }
-var FileOperationError = class extends Error {
+var FILE_CAPACITY_MESSAGE = "OS reached its file-processing limit. Try again in a moment. If this keeps happening with a large batch, split the files into smaller groups.", FILE_INTEGRITY_MESSAGE = "OS could not verify this File against its saved record. Try again. If the problem continues, add the original file again.", FileOperationError = class extends Error {
   constructor(code, status, retryable = !1, detail) {
     let safe = ["invalid_input", "request_too_large"].includes(code) ? parseFileErrorDetail(detail) : void 0;
-    super(safe ? `${code}: ${fileErrorExplanation(safe)}` : code);
+    super(safe ? `${code}: ${fileErrorExplanation(safe)}` : code === "capacity" ? FILE_CAPACITY_MESSAGE : code === "integrity" ? FILE_INTEGRITY_MESSAGE : code);
     this.code = code;
     this.status = status;
     this.retryable = retryable;
@@ -185,7 +186,11 @@ function parseAppRoutineContract(value) {
         };
       }
       case "array":
-        return !fields(value2, ["type", "items", "maxItems"]) || !Number.isSafeInteger(value2.maxItems) || value2.maxItems < 1 || value2.maxItems > 64 ? invalidContract() : { type: "array", items: schema2(value2.items, depth + 1), maxItems: value2.maxItems };
+        return !fields(value2, ["type", "items"], ["maxItems"]) || owns(value2, "maxItems") && (!Number.isSafeInteger(value2.maxItems) || value2.maxItems < 1) ? invalidContract() : {
+          type: "array",
+          items: schema2(value2.items, depth + 1),
+          ...owns(value2, "maxItems") ? { maxItems: value2.maxItems } : {}
+        };
       case "boolean":
         return fields(value2, ["type"]) ? { type: value2.type } : invalidContract();
       case "file":
@@ -238,7 +243,8 @@ function validateRoutineSchemaValue(schema2, value, rejected) {
         return;
       case "array":
         if (!denseArray(value2)) return fail4("wrong_type");
-        if (value2.length > schema3.maxItems) return fail4("out_of_bounds", { constraint: "maxItems", limit: schema3.maxItems });
+        if (schema3.maxItems !== void 0 && value2.length > schema3.maxItems)
+          return fail4("out_of_bounds", { constraint: "maxItems", limit: schema3.maxItems });
         value2.forEach((child, index) => check(schema3.items, child, `${path}[${index}]`));
         return;
       case "boolean":
@@ -266,7 +272,22 @@ var InboxContractError = class extends Error {
   constructor(message2) {
     super(message2), this.name = "InboxContractError";
   }
+}, INBOX_PUBLICATION_ITEM_BYTES = 1024 * 1024, INBOX_PUBLICATION_REQUEST_BYTES = INBOX_PUBLICATION_ITEM_BYTES + 4096, publicationAdvice = "Trim the content, or attach long reports, data, and supporting materials as files instead. Then try again.", INBOX_PUBLICATION_TOO_LARGE = `Your Inbox item failed to publish. Its content exceeds the 1 MB limit. ${publicationAdvice}`, InboxPublicationSizeError = class extends InboxContractError {
+  constructor(kind, bytes) {
+    let label = kind === "ask" ? "Ask" : "Digest", size = Math.ceil(bytes / INBOX_PUBLICATION_ITEM_BYTES * 100) / 100;
+    super(`Your ${label} failed to publish. Its content is ${size} MB, which exceeds the 1 MB limit. ${publicationAdvice}`);
+    this.kind = kind;
+    this.bytes = bytes;
+    this.name = "InboxPublicationSizeError";
+  }
+  kind;
+  bytes;
 };
+function enforcePublicationSize(value) {
+  let bytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  if (bytes > INBOX_PUBLICATION_ITEM_BYTES) throw new InboxPublicationSizeError(value.kind, bytes);
+  return value;
+}
 function fail(message2) {
   throw new InboxContractError(message2);
 }
@@ -607,7 +628,7 @@ function createInboxPublisher(transport) {
       keys(source2, ["title", "description", "recipients", "views", "body", "questions", "notifyImmediately", "tags", "recordRefs"], "ask");
       let result2 = await transport.publish({
         requestKey: publicationRequestKey(options),
-        item: validatePublication({ ...source2, kind: "ask" })
+        item: enforcePublicationSize(validatePublication({ ...source2, kind: "ask" }))
       });
       return id(result2.id, "published ask ID"), (!("revision" in result2) || !Number.isSafeInteger(result2.revision) || result2.revision !== 1) && fail("Initial ask publication must return revision 1"), { id: result2.id, revision: result2.revision };
     },
@@ -616,7 +637,7 @@ function createInboxPublisher(transport) {
       keys(source2, ["title", "description", "recipients", "views", "body", "notifyImmediately"], "digest");
       let result2 = await transport.publish({
         requestKey: publicationRequestKey(options),
-        item: validatePublication({ ...source2, kind: "digest" })
+        item: enforcePublicationSize(validatePublication({ ...source2, kind: "digest" }))
       });
       return { id: id(result2.id, "published digest ID") };
     },
@@ -769,12 +790,12 @@ function routineAIOutputMessage(issue) {
 }
 
 var ROUTINE_AI_VALUE_BYTES = 256 * 1024, ROUTINE_AI_RESULT_BYTES = 6 * ROUTINE_AI_VALUE_BYTES + 1024, ROUTINE_AI_EVIDENCE_BYTES = 4 * 1024;
-var RoutineAIError = class extends Error {
+var AIError = class extends Error {
   constructor(code, options = {}) {
     let detail = code === "invalid_output" ? parseRoutineAIOutputIssue(options.detail) : void 0;
     super(detail ? routineAIOutputMessage(detail) : code);
     this.code = code;
-    this.name = "RoutineAIError", detail && (this.detail = Object.freeze(detail)), code === "invalid_output" && typeof options.text == "string" && new TextEncoder().encode(options.text).byteLength <= ROUTINE_AI_VALUE_BYTES && Object.defineProperty(this, "text", { value: options.text });
+    this.name = "AIError", detail && (this.detail = Object.freeze(detail)), code === "invalid_output" && typeof options.text == "string" && new TextEncoder().encode(options.text).byteLength <= ROUTINE_AI_VALUE_BYTES && Object.defineProperty(this, "text", { value: options.text });
   }
   code;
   detail;
@@ -783,10 +804,10 @@ function capture(value, invalid9, oversized, limit = ROUTINE_AI_VALUE_BYTES) {
   try {
     assertRoutineJson(value);
     let encoded = JSON.stringify(value);
-    if (new TextEncoder().encode(encoded).byteLength > limit) throw new RoutineAIError(oversized);
+    if (new TextEncoder().encode(encoded).byteLength > limit) throw new AIError(oversized);
     return freezeRoutineMetadata(JSON.parse(encoded));
   } catch (error) {
-    throw error instanceof RoutineAIError ? error : new RoutineAIError(invalid9);
+    throw error instanceof AIError ? error : new AIError(invalid9);
   }
 }
 function parseRoutineAIRequest(value) {
@@ -798,7 +819,7 @@ function parseRoutineAIRequest(value) {
     let schema2 = parseAppRoutineContract({ routine: "ai", input: v.schema, steps: [{ id: "generate" }] }).input;
     return freezeRoutineMetadata({ kind: v.kind, instructions: v.instructions, input, schema: schema2 });
   } catch {
-    throw new RoutineAIError("invalid_input");
+    throw new AIError("invalid_input");
   }
 }
 function parseRoutineAIResult(request2, value) {
@@ -815,7 +836,7 @@ function parseRoutineAIResult(request2, value) {
     }
     if (!Object.hasOwn(v, "object")) throw new Error();
   } catch (error) {
-    throw error instanceof RoutineAIError ? error : new RoutineAIError("invalid_output", { detail: { reason: "invalid_response" } });
+    throw error instanceof AIError ? error : new AIError("invalid_output", { detail: { reason: "invalid_response" } });
   }
   return validateObject(request2.schema, v.object), freezeRoutineMetadata({ object: v.object });
 }
@@ -826,20 +847,20 @@ function validateObject(schema2, object5, text5) {
       detail = issue;
     });
   } catch {
-    throw new RoutineAIError("invalid_output", { ...text5 === void 0 ? {} : { text: text5 }, detail });
+    throw new AIError("invalid_output", { ...text5 === void 0 ? {} : { text: text5 }, detail });
   }
 }
 function acceptText(request2, text5) {
-  if (new TextEncoder().encode(text5).byteLength > ROUTINE_AI_VALUE_BYTES) throw new RoutineAIError("output_too_large");
+  if (new TextEncoder().encode(text5).byteLength > ROUTINE_AI_VALUE_BYTES) throw new AIError("output_too_large");
   if (request2.kind === "generateText") {
-    if (!text5.trim()) throw new RoutineAIError("invalid_output", { text: text5, detail: { reason: "empty_text" } });
+    if (!text5.trim()) throw new AIError("invalid_output", { text: text5, detail: { reason: "empty_text" } });
     return freezeRoutineMetadata({ text: text5 });
   }
-  let object5;
+  let object5, trimmed = text5.trim(), fenced = /^(`{3,}|~{3,})(?:json)?[ \t]*\r?\n([\s\S]*?)\r?\n\1[ \t]*$/i.exec(trimmed);
   try {
-    object5 = JSON.parse(text5);
+    object5 = JSON.parse(fenced ? fenced[2] : text5);
   } catch {
-    throw new RoutineAIError("invalid_output", { text: text5, detail: { reason: "invalid_json" } });
+    throw new AIError("invalid_output", { text: text5, detail: { reason: "invalid_json" } });
   }
   return validateObject(request2.schema, object5, text5), capture({ object: object5 }, "invalid_output", "output_too_large");
 }
@@ -849,10 +870,10 @@ var LIMIT = 256 * 1024, invalid3 = () => {
 }, invalidContract3 = () => {
   throw new AppRoutineContractError("invalid_contract");
 }, empty = { type: "object", properties: {}, required: [], additionalProperties: !1 };
-function captureJson(value) {
+function captureJson(value, maximum = LIMIT) {
   assertRoutineJson(value);
   let encoded = JSON.stringify(value);
-  return new TextEncoder().encode(encoded).byteLength > LIMIT ? invalid3() : freezeRoutineMetadata(JSON.parse(encoded));
+  return maximum !== null && new TextEncoder().encode(encoded).byteLength > maximum ? invalid3() : freezeRoutineMetadata(JSON.parse(encoded));
 }
 function capture2(schema2, value) {
   let captured = captureJson(value);
@@ -887,8 +908,8 @@ var schema = {
   object(properties) {
     return declaration({ type: "object", properties: Object.fromEntries(Object.entries(properties).map(([key, value]) => [key, nestedSchema(value)])), required: Object.keys(properties), additionalProperties: !1 });
   },
-  array(items, options) {
-    return declaration({ type: "array", items: nestedSchema(items), maxItems: options.maxItems });
+  array(items, options = {}) {
+    return assertRoutineFields(options, ["maxItems"]), declaration({ type: "array", items: nestedSchema(items), ...options });
   },
   string(options = {}) {
     return declaration({ type: "string", ...options });
@@ -970,8 +991,8 @@ function captureRoutineInput(definition, input) {
 async function executeRoutineDefinition(definition, input, runtime) {
   let captured = captureRoutineInput(definition, input), { contract, steps, run } = definitions.get(definition), active2 = !0, accepting = !0, broken = !1, work = Promise.resolve(), aiWork = /* @__PURE__ */ new Set(), generate = (kind, value) => {
     let operation2 = (async () => {
-      if (!active2 || broken || contract.access.ai !== !0) throw new RoutineAIError("access_denied");
-      if (!runtime.ai) throw new RoutineAIError("capability_unavailable");
+      if (!active2 || broken || contract.access.ai !== !0) throw new AIError("access_denied");
+      if (!runtime.ai) throw new AIError("capability_unavailable");
       let request2;
       try {
         assertRoutineFields(value, kind === "generateObject" ? ["instructions", "input", "schema"] : ["instructions", "input"]), request2 = parseRoutineAIRequest({
@@ -981,10 +1002,10 @@ async function executeRoutineDefinition(definition, input, runtime) {
           ...kind === "generateObject" ? { schema: schemaMetadata(value.schema).schema } : {}
         });
       } catch (error) {
-        throw error instanceof RoutineAIError ? error : new RoutineAIError("invalid_input");
+        throw error instanceof AIError ? error : new AIError("invalid_input");
       }
       let result3 = await runtime.ai[kind](request2);
-      if (!active2 || broken) throw new RoutineAIError("access_denied");
+      if (!active2 || broken) throw new AIError("access_denied");
       return parseRoutineAIResult(request2, result3);
     })();
     return aiWork.add(operation2), operation2.then(() => aiWork.delete(operation2), () => aiWork.delete(operation2)), operation2;
@@ -1020,7 +1041,7 @@ async function executeRoutineDefinition(definition, input, runtime) {
       let saved;
       try {
         if (!active2 || !accepting || broken || !Object.hasOwn(steps, id3) || called.has(id3) || input2.length > 1) return invalid3();
-        input2.length && (saved = captureJson(input2[0])), called.add(id3);
+        input2.length && (saved = captureJson(input2[0], null)), called.add(id3);
       } catch (error) {
         return broken = !0, Promise.reject(error);
       }
@@ -1056,26 +1077,171 @@ async function executeRoutineDefinition(definition, input, runtime) {
   if (result2 !== void 0) return invalid3();
 }
 
+var RECORD_READ_INPUT_LIMIT = 1024 * 1024, RECORD_CAPTURE_OUTPUT_LIMIT = 25 * 1024 * 1024;
+function validRecordRef(value) {
+  return typeof value == "string" && value.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)+$/.test(value);
+}
+
+var fieldProblems = ["unknown", "missing", "invalid", "source_schema"], reasons = {
+  unknown: "unknown_field",
+  missing: "missing_field",
+  invalid: "invalid_value",
+  source_schema: "source_schema_mismatch"
+}, expectationKinds = {
+  string: "a string",
+  integer: "a safe integer",
+  number: "a finite number",
+  boolean: "a boolean",
+  date: "a date in YYYY-MM-DD format",
+  const: "the constant declared in the schema",
+  enum: "one of the choices declared in the schema",
+  link: "a link to an existing record of an allowed type",
+  object: "an object matching the schema",
+  map: "a map matching the schema"
+};
+function expectationText(expected) {
+  if (!Object.hasOwn(expectationKinds, expected.type) || typeof expected.many != "boolean" || typeof expected.nullable != "boolean" || expected.decimalPlaces !== void 0 && (expected.type !== "number" || !Number.isInteger(expected.decimalPlaces) || expected.decimalPlaces < 0 || expected.decimalPlaces > 6) || expected.format !== void 0 && (expected.type !== "date" || expected.format !== "month")) return;
+  let scalar = expected.type === "number" && expected.decimalPlaces !== void 0 ? `a finite number with at most ${expected.decimalPlaces} decimal places` : expected.type === "date" && expected.format === "month" ? "a date in YYYY-MM format" : expectationKinds[expected.type];
+  return `${expected.many ? "Expected a list. Each item must be" : "Expected"} ${scalar}.${expected.nullable ? " The field may also be null." : ""}`;
+}
+function parseExpectation(text5) {
+  if (!text5) return;
+  let parts = /^Expected (a list\. Each item must be )?(.+?)\.( The field may also be null\.)?$/.exec(text5);
+  if (!parts) return;
+  let number = /^a finite number with at most ([0-6]) decimal places$/.exec(parts[2]), month = parts[2] === "a date in YYYY-MM format", kind = number ? "number" : month ? "date" : Object.keys(expectationKinds).find((kind2) => expectationKinds[kind2] === parts[2]);
+  if (!kind) return;
+  let expected = {
+    type: kind,
+    many: !!parts[1],
+    nullable: !!parts[3],
+    ...number ? { decimalPlaces: Number(number[1]) } : {},
+    ...month ? { format: "month" } : {}
+  };
+  return expectationText(expected) === text5 ? expected : void 0;
+}
+function parseDataValidationDetail(value) {
+  if (!value || typeof value != "object" || Array.isArray(value)) return;
+  let v = value;
+  if (Object.keys(v).some((key) => !["record", "field", "reason", "schemaFile", "expected"].includes(key)) || typeof v.record != "string" || typeof v.field != "string") return;
+  let problem = fieldProblems.find((problem2) => reasons[problem2] === v.reason);
+  if (!problem || v.schemaFile !== void 0 && typeof v.schemaFile != "string") return;
+  let expected;
+  if (Object.hasOwn(v, "expected")) {
+    if (!v.expected || typeof v.expected != "object" || Array.isArray(v.expected)) return;
+    let e = v.expected;
+    if (Object.keys(e).some((key) => !["type", "many", "nullable", "decimalPlaces", "format"].includes(key)) || (expected = { ...e }, !expectationText(expected))) return;
+  }
+  if (!(problem === "unknown" && expected || problem === "source_schema" && (v.field !== "media_type" || expected?.type !== "string" || expected.many || expected.nullable)) && recordFieldMessage(
+    v.record,
+    v.field,
+    problem,
+    v.schemaFile,
+    expected
+  ))
+    return {
+      record: v.record,
+      field: v.field,
+      reason: reasons[problem],
+      ...typeof v.schemaFile == "string" ? { schemaFile: v.schemaFile } : {},
+      ...expected ? { expected } : {}
+    };
+}
+function recordFieldMessage(record4, field, problem, schemaPath, expected) {
+  if (!validRecordRef(record4) || !/^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/.test(field) || schemaPath !== void 0 && (schemaPath.length > 256 || !/^[a-zA-Z0-9_.-]+(?:\/[a-zA-Z0-9_.-]+)*\/_schema\.yaml$/.test(schemaPath) || schemaPath.split("/").some((part) => [".", "..", ".git", "routines"].includes(part)))) return;
+  let prefix = `Record "${record4}" isn't valid.`, schema2 = schemaPath ? `"${schemaPath}"` : "the collection schema";
+  if (problem === "source_schema") return field === "media_type" ? `${prefix} This repository's Source schema${schemaPath ? ` ${schema2}` : ""} doesn't include "media_type". The OS SDK uses "media_type" for file Sources. Update the Source schema in this repository to include this field.` : void 0;
+  if (problem === "unknown") return `${prefix} The record contains "${field}", but ${schema2} doesn't define that field. Check that the record and ${schemaPath ? "that file" : "the collection schema"} use the same field name.`;
+  if (problem === "missing") return `${prefix} The record is missing required field "${field}". Add it as defined in ${schema2}.`;
+  let expectation = expected ? expectationText(expected) : void 0;
+  if (!(expected && !expectation))
+    return `${prefix} The record has an invalid value for field "${field}".${expectation ? ` ${expectation}` : ""} Check its definition in ${schema2}.`;
+}
+function safeRecordFieldMessage(value) {
+  if (typeof value != "string" || value.length > 1200) return;
+  let parts = /^Record "([^"]+)" isn't valid\. (.+)$/.exec(value);
+  if (!parts) return;
+  let schemaPath = /"([^"]+\/_schema\.yaml)"/.exec(value)?.[1], field = [...parts[2].matchAll(/"([^"]+)"/g)].map((match) => match[1]).find((part) => part !== schemaPath);
+  if (!field) return;
+  let expected = parseExpectation(/\. (Expected .+) Check its definition in /.exec(value)?.[1]);
+  return fieldProblems.map((problem) => recordFieldMessage(parts[1], field, problem, schemaPath, expected)).find((message2) => message2 === value);
+}
+function dataValidationMessageFacts(error) {
+  if (error.code === "invalid_change") {
+    let detail = parseDataValidationDetail(error.detail);
+    if (detail) {
+      let problem = fieldProblems.find((problem2) => reasons[problem2] === detail.reason);
+      return { detail, message: recordFieldMessage(
+        detail.record,
+        detail.field,
+        problem,
+        detail.schemaFile,
+        detail.expected
+      ) };
+    }
+  }
+  let message2 = error.code === "invalid_change" ? safeRecordFieldMessage(error.message) : void 0;
+  return message2 ? { message: message2 } : {};
+}
+function explainDataValidation(error, message2, detail) {
+  return Object.assign(error, dataValidationMessageFacts({ code: error.code, message: typeof message2 == "string" ? message2 : "", detail })), error;
+}
+
+var localDataPath = (value, repository) => typeof value == "string" && value.length <= 1024 && value.startsWith(`${repository}/`) && !value.includes("\\") && !/[\x00-\x1f\x7f]/.test(value) && value.split("/").every((part) => !!part && part !== "." && part !== ".."), localDataFile = (value, repository) => {
+  if (!value || typeof value != "object" || Array.isArray(value)) return !1;
+  let row = value;
+  return Object.keys(row).sort().join(",") === "action,path" && ["created", "updated", "deleted"].includes(String(row.action)) && localDataPath(row.path, repository);
+};
+function parseDataFailureDetail(value) {
+  let invalid9 = () => {
+    throw new Error("Invalid local Data failure detail");
+  };
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid9();
+  let row = value;
+  if (Object.keys(row).sort().join(",") !== "cause,code,files,nextAction,operation,repository" || !["local_data_read_failed", "local_data_write_failed", "local_data_write_partial"].includes(String(row.code)) || !["read", "write"].includes(String(row.operation)) || typeof row.repository != "string" || !/^[a-z0-9][a-z0-9._/-]{0,127}$/.test(row.repository) || row.repository.includes("//") || row.repository.includes("..") || !["fix_failed_file_then_rerun", "review_resolve_then_rerun"].includes(String(row.nextAction))) return invalid9();
+  let repository = row.repository;
+  if (!row.cause || typeof row.cause != "object" || Array.isArray(row.cause)) return invalid9();
+  let cause = row.cause;
+  if (!["code,message", "code,message,path"].includes(Object.keys(cause).sort().join(",")) || !["schema_validation_failed", "invalid_record", "unsafe_record", "stale_record", "path_conflict", "filesystem_unavailable"].includes(String(cause.code)) || typeof cause.message != "string" || !cause.message || cause.message.length > 512 || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(cause.message) || cause.path !== void 0 && !localDataPath(cause.path, repository) || !row.files || typeof row.files != "object" || Array.isArray(row.files)) return invalid9();
+  let files3 = row.files;
+  if (Object.keys(files3).some((key) => !["state", "saved", "failed", "notAttempted", "savedOmitted", "notAttemptedOmitted"].includes(key)) || !["none", "partial"].includes(String(files3.state)) || !Array.isArray(files3.saved) || files3.saved.length > 128 || !files3.saved.every((item) => localDataFile(item, repository)) || files3.failed !== void 0 && !localDataFile(files3.failed, repository) || !Array.isArray(files3.notAttempted) || files3.notAttempted.length > 128 || !files3.notAttempted.every((item) => localDataFile(item, repository))) return invalid9();
+  for (let key of ["savedOmitted", "notAttemptedOmitted"]) if (files3[key] !== void 0 && (!Number.isSafeInteger(files3[key]) || Number(files3[key]) < 1 || Number(files3[key]) > 1e4)) return invalid9();
+  return row.operation === "read" && (row.code !== "local_data_read_failed" || files3.state !== "none" || files3.saved.length || files3.failed !== void 0 || files3.notAttempted.length) || row.operation === "write" && row.code === "local_data_read_failed" || row.code === "local_data_write_partial" && (files3.state !== "partial" || !files3.saved.length) || row.code !== "local_data_write_partial" && files3.state === "partial" ? invalid9() : structuredClone(value);
+}
+function parseDataOperationDetail(value) {
+  let validation = parseDataValidationDetail(value);
+  if (validation) return validation;
+  if (value && typeof value == "object" && !Array.isArray(value) && value.code === "record_limit_exceeded") {
+    let row = value;
+    if (Object.keys(row).sort().join(",") !== "code,collections,maxRecords" || !Number.isSafeInteger(row.maxRecords) || Number(row.maxRecords) < 1 || !Array.isArray(row.collections) || !row.collections.length || row.collections.length > 16 || !row.collections.every((name2) => typeof name2 == "string" && name2.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(name2)) || new Set(row.collections).size !== row.collections.length)
+      throw new Error("Invalid Data operation detail");
+    return structuredClone(value);
+  }
+  return parseDataFailureDetail(value);
+}
+function dataRecordLimitMessage(detail) {
+  let scope = detail.collections.length === 1 ? ` from ${detail.collections[0]}` : ` across ${detail.collections.join(", ")}`;
+  return `The routine tried to load more than ${detail.maxRecords.toLocaleString("en-US")} matching Records${scope}. Narrow the query or increase maxRecords.`;
+}
 var DataOperationError = class extends Error {
-  constructor(code, retryable = !1, effect, component) {
-    super(`Data operation failed: ${code}`);
+  constructor(code, retryable = !1, effect, component, detail) {
+    let parsed = detail === void 0 ? void 0 : parseDataOperationDetail(detail);
+    if (parsed && ("reason" in parsed ? code !== "invalid_change" : parsed.code === "record_limit_exceeded" && code !== "capacity"))
+      throw new Error("Invalid Data operation detail");
+    super(code === "capacity" && parsed && "code" in parsed && parsed.code === "record_limit_exceeded" ? dataRecordLimitMessage(parsed) : `Data operation failed: ${code}`);
     this.code = code;
     this.retryable = retryable;
     this.effect = effect;
     this.component = component;
-    this.name = "DataOperationError";
+    this.detail = detail;
+    this.name = "DataOperationError", parsed !== void 0 && (this.detail = parsed);
   }
   code;
   retryable;
   effect;
   component;
+  detail;
 };
 
-var RECORD_READ_INPUT_LIMIT = 1024 * 1024, RECORD_CAPTURE_OUTPUT_LIMIT = 25 * 1024 * 1024;
-function validRecordRef(value) {
-  return typeof value == "string" && value.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)+$/.test(value);
-}
-
 var invalid4 = () => {
   throw new DataOperationError("invalid_query");
 }, historyText = (value) => typeof value == "string" && !/[\u0000\uD800-\uDFFF]/u.test(value);
@@ -1169,8 +1335,24 @@ function captureRecordsReadRefs(value) {
     throw new DataOperationError("invalid_query");
   return refs;
 }
+function captureRecordsReadOptions(value) {
+  if (value === void 0) return {};
+  let row;
+  try {
+    row = Object.fromEntries(Object.entries(historyProperties(value)).map(([key, descriptor]) => [key, descriptor.value]));
+  } catch {
+    throw new DataOperationError("invalid_query");
+  }
+  if (!value || typeof value != "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some((key) => key !== "body" || !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), "value")) || Object.hasOwn(row, "body") && typeof row.body != "boolean") throw new DataOperationError("invalid_query");
+  return Object.hasOwn(row, "body") ? { body: row.body } : {};
+}
 
-var DATA_REQUEST_LIMIT = 256 * 1024, invalidChange = () => {
+function validRecordBody(value) {
+  return typeof value == "string" && value === new TextDecoder("utf-8", { ignoreBOM: !0 }).decode(new TextEncoder().encode(value));
+}
+var RECORD_BODY_READ_BYTES = 8 * 1024 * 1024;
+
+var DATA_REQUEST_LIMIT = 256 * 1024, LOCAL_DATA_CHANGE_REQUEST_LIMIT = 32 * 1024 * 1024, invalidChange = () => {
   throw new DataOperationError("invalid_change", !1, "unapplied");
 };
 function mapping(value) {
@@ -1195,16 +1377,16 @@ function captureDataDelete(record4) {
   return !validRecordRef(identity.$ref) || typeof identity.$version != "string" || !identity.$version.length || identity.$version.length > 512 ? invalidChange() : { ref: identity.$ref, expectedVersion: identity.$version };
 }
 function captureDataUpdate(record4, set) {
-  let identity = captureDataDelete(record4), fields5 = mapping(set);
-  return !Object.keys(fields5).length || Object.keys(fields5).some((key) => key.startsWith("$") || ["id", "type"].includes(key)) ? invalidChange() : { ...identity, set: captureValue(fields5) };
+  let identity = captureDataDelete(record4), input = mapping(set), { $body, ...fields5 } = input, body = Object.hasOwn(input, "$body");
+  return body && !validRecordBody($body) || !Object.keys(fields5).length && !body || Object.keys(fields5).some((key) => key.startsWith("$") || ["id", "type"].includes(key)) ? invalidChange() : { ...identity, set: captureValue(fields5), ...body ? { body: $body } : {} };
 }
 function captureIdentities(value, update, allowEmpty = !0) {
   if (!Array.isArray(value) || !allowEmpty && !value.length || value.length > 1e4) return invalidChange();
   let captured = value.map((item) => {
     let row = mapping(item);
-    if (Object.keys(row).sort().join(",") !== (update ? "expectedVersion,ref,set" : "expectedVersion,ref")) return invalidChange();
+    if (Object.keys(row).filter((key) => !update || key !== "body").sort().join(",") !== (update ? "expectedVersion,ref,set" : "expectedVersion,ref")) return invalidChange();
     let identity = { $ref: row.ref, $version: row.expectedVersion };
-    return update ? captureDataUpdate(identity, row.set) : captureDataDelete(identity);
+    return update && Object.keys(mapping(row.set)).some((key) => key.startsWith("$")) ? invalidChange() : update ? captureDataUpdate(identity, { ...mapping(row.set), ...Object.hasOwn(row, "body") ? { $body: row.body } : {} }) : captureDataDelete(identity);
   });
   return new Set(captured.map((item) => item.ref)).size !== captured.length ? invalidChange() : captured;
 }
@@ -1213,30 +1395,37 @@ function captureDataUpdates(value, allowEmpty = !1) {
 }
 function captureDataCreate(value) {
   let row = mapping(value);
-  if (!validRecordRef(row.$ref) || Object.keys(row).some((key) => key.startsWith("$") && !["$ref", "$filing"].includes(key)))
+  if (!validRecordRef(row.$ref) || Object.keys(row).some((key) => key.startsWith("$") && !["$ref", "$filing", "$body"].includes(key)))
     return invalidChange();
-  let { $ref: ref, $filing, ...fields5 } = row, filing;
+  let { $ref: ref, $filing, $body, ...fields5 } = row, body = Object.hasOwn(row, "$body");
+  if (body && !validRecordBody($body)) return invalidChange();
+  let filing;
   if ($filing !== void 0) {
     let components = mapping($filing);
     if (Object.entries(components).some(([name2, value2]) => !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name2) || ["constructor", "prototype"].includes(name2) || typeof value2 != "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value2)))
       return invalidChange();
     filing = { ...components };
   }
-  return { ref, fields: captureValue(fields5), ...filing ? { filing } : {} };
+  return { ref, fields: captureValue(fields5), ...filing ? { filing } : {}, ...body ? { body: $body } : {} };
 }
 function captureDataChanges(updatesValue, createsValue = [], deletesValue = []) {
   let updates = captureDataUpdates(updatesValue, !0);
   if (!Array.isArray(createsValue) || createsValue.length > 1e4) return invalidChange();
   let creates = createsValue.map((item) => {
     let row = mapping(item);
-    if (Object.keys(row).some((key) => !["ref", "fields", "filing"].includes(key)) || !Object.hasOwn(row, "ref") || !Object.hasOwn(row, "fields")) return invalidChange();
+    if (Object.keys(row).some((key) => !["ref", "fields", "filing", "body"].includes(key)) || !Object.hasOwn(row, "ref") || !Object.hasOwn(row, "fields")) return invalidChange();
     let fields5 = mapping(row.fields);
-    return Object.keys(fields5).some((key) => key.startsWith("$")) ? invalidChange() : captureDataCreate({ ...fields5, $ref: row.ref, ...Object.hasOwn(row, "filing") ? { $filing: row.filing } : {} });
+    return Object.keys(fields5).some((key) => key.startsWith("$")) ? invalidChange() : captureDataCreate({
+      ...fields5,
+      $ref: row.ref,
+      ...Object.hasOwn(row, "filing") ? { $filing: row.filing } : {},
+      ...Object.hasOwn(row, "body") ? { $body: row.body } : {}
+    });
   }), deletes = captureIdentities(deletesValue, !1), refs = [...updates, ...creates, ...deletes].map((item) => item.ref);
   return !refs.length || refs.length > 1e4 || new Set(refs).size !== refs.length ? invalidChange() : { updates, creates, deletes };
 }
-function checkDataRequestSize(input) {
-  if (new TextEncoder().encode(JSON.stringify(input)).byteLength > DATA_REQUEST_LIMIT)
+function checkDataRequestSize(input, limit = DATA_REQUEST_LIMIT) {
+  if (new TextEncoder().encode(JSON.stringify(input)).byteLength > limit)
     throw new DataOperationError("request_too_large", !1, "unapplied");
 }
 function dataTransportError(status, value) {
@@ -1244,17 +1433,22 @@ function dataTransportError(status, value) {
     400: ["invalid_query", "invalid_change"],
     401: ["unauthenticated"],
     403: ["access_denied"],
-    409: ["conflict", "publication_pending"],
+    409: ["conflict", "apply_pending"],
     413: ["request_too_large"],
     429: ["capacity"],
-    503: ["unavailable", "publication_pending"]
-  }, error = value && typeof value == "object" && "error" in value ? value.error : void 0, row = error && typeof error == "object" ? error : void 0, code = failures2[status]?.find((allowed) => allowed === row?.code) ?? "unavailable", effect = ["unapplied", "uncertain", "applied"].includes(String(row?.effect)) ? row.effect : void 0;
-  return new DataOperationError(
+    503: ["unavailable", "apply_pending"]
+  }, error = value && typeof value == "object" && "error" in value ? value.error : void 0, row = error && typeof error == "object" ? error : void 0, code = failures2[status]?.find((allowed) => allowed === row?.code) ?? "unavailable", effect = ["unapplied", "uncertain", "applied"].includes(String(row?.effect)) ? row.effect : void 0, detail;
+  try {
+    detail = row?.detail === void 0 ? void 0 : parseDataOperationDetail(row.detail);
+  } catch {
+  }
+  return detail && "reason" in detail && code !== "invalid_change" && (detail = void 0), explainDataValidation(new DataOperationError(
     code,
-    ["capacity", "unavailable", "publication_pending"].includes(code),
+    typeof row?.retryable == "boolean" ? row.retryable : ["capacity", "unavailable", "apply_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 : void 0
-  );
+    code === "invalid_change" && typeof row?.component == "string" && /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/.test(row.component) ? row.component : void 0,
+    detail
+  ), row?.message, row?.detail);
 }
 
 var installed, ended = !1;
@@ -1404,12 +1598,21 @@ function recordPagination(select) {
   async function all(query, options) {
     let properties = historyProperties(options), maxRecords = properties.maxRecords?.value;
     (Object.keys(properties).join(",") !== "maxRecords" || !Number.isSafeInteger(maxRecords) || maxRecords < 1) && invalid6();
+    let captured = capture3(query), names = Object.keys(historyProperties(captured));
+    if (names.length === 1) {
+      let name2 = names[0], selection2 = historyProperties(captured[name2]), selectionNames = Object.keys(selection2), authored = selection2.$ ? historyProperties(selection2.$.value) : {};
+      selectionNames.every((key) => key === "$") && !Object.hasOwn(authored, "limit") && (captured[name2] = { ...captured[name2], $: { ...captured[name2].$, limit: Math.min(500, maxRecords) } });
+    }
     let result2, total = 0;
-    for await (let page of pages(query)) {
-      let names = Object.keys(page.$meta.collections), size = names.reduce((sum, name2) => sum + page[name2].length, 0);
-      if (size > maxRecords - total) throw new DataOperationError("capacity");
-      total += size, result2 ??= { ...Object.fromEntries(names.map((name2) => [name2, []])), $meta: page.$meta };
-      for (let name2 of names) {
+    for await (let page of pages(captured)) {
+      let names2 = Object.keys(page.$meta.collections), size = names2.reduce((sum, name2) => sum + page[name2].length, 0);
+      if (size > maxRecords - total) throw new DataOperationError("capacity", !1, void 0, void 0, {
+        code: "record_limit_exceeded",
+        maxRecords,
+        collections: names2
+      });
+      total += size, result2 ??= { ...Object.fromEntries(names2.map((name2) => [name2, []])), $meta: page.$meta };
+      for (let name2 of names2) {
         let target = result2[name2];
         for (let record4 of page[name2]) target.push(record4);
       }
@@ -1423,8 +1626,8 @@ function recordPagination(select) {
 var genericData = {
   repository(repository) {
     async function send3(input) {
-      let context = await resolveDataContext(), envelope = { repository, ...input };
-      if (checkDataRequestSize(envelope), "local" in context) return await context.local("data/query", envelope);
+      let context = await resolveDataContext(), envelope = { repository, ...input }, changing = "operation" in input && ["changes.validate", "changes.apply"].includes(String(input.operation));
+      if (checkDataRequestSize(envelope, "local" in context && changing ? LOCAL_DATA_CHANGE_REQUEST_LIMIT : DATA_REQUEST_LIMIT), "local" in context) return await context.local("data/query", envelope);
       try {
         let response2 = await fetch(context.url, {
           method: "POST",
@@ -1440,8 +1643,8 @@ var genericData = {
         throw error instanceof DataOperationError ? error : new DataOperationError("unavailable", !0);
       }
     }
-    async function read2(input) {
-      let refs = captureRecordsReadRefs(typeof input == "string" ? [input] : input), result2 = await send3({ operation: "records.read", refs });
+    async function read2(input, options) {
+      let refs = captureRecordsReadRefs(typeof input == "string" ? [input] : input), captured = captureRecordsReadOptions(options), result2 = await send3({ operation: "records.read", refs, ...options === void 0 ? {} : { options: captured } });
       return typeof input == "string" ? result2.records[0] : result2;
     }
     let select = (query) => send3({ operation: "records.select", query });
@@ -1462,16 +1665,16 @@ var genericData = {
         changes: async (options) => send3({ operation: "history.changes", options: captureHistoryChangesOptions(options) })
       },
       changes() {
-        let updates = [], creates = [], deletes = [], publicationId, pending, confirmed, assertMutable = () => {
-          if (publicationId) throw new DataOperationError("invalid_change", !1, "unapplied");
+        let updates = [], creates = [], deletes = [], applyId, pending, confirmed, assertMutable = () => {
+          if (applyId) throw new DataOperationError("invalid_change", !1, "unapplied");
         }, snapshot = (nextUpdates = updates, nextCreates = creates, nextDeletes = deletes) => {
           let { updates: updates2, creates: creates2, deletes: deletes2 } = captureDataChanges(nextUpdates, nextCreates, nextDeletes), input = { updates: updates2, ...creates2.length ? { creates: creates2 } : {}, ...deletes2.length ? { deletes: deletes2 } : {} };
           return checkDataRequestSize({
             repository,
-            operation: "changes.publish",
+            operation: "changes.apply",
             ...input,
-            publicationId: publicationId ?? "00000000-0000-4000-8000-000000000000"
-          }), input;
+            applyId: applyId ?? "00000000-0000-4000-8000-000000000000"
+          }, LOCAL_DATA_CHANGE_REQUEST_LIMIT), input;
         };
         return {
           create(record4) {
@@ -1492,7 +1695,7 @@ var genericData = {
           async validate() {
             await send3({ operation: "changes.validate", ...snapshot() });
           },
-          publish() {
+          apply() {
             if (confirmed) return Promise.resolve(structuredClone(confirmed));
             if (!pending) {
               let captured;
@@ -1501,13 +1704,14 @@ var genericData = {
               } catch (error) {
                 return Promise.reject(error);
               }
-              publicationId ??= routineTransport()?.key("data") ?? crypto.randomUUID(), pending = send3({ operation: "changes.publish", ...captured, publicationId }).then((result2) => (confirmed = structuredClone(result2), result2)).catch((error) => {
-                throw error instanceof DataOperationError ? new DataOperationError(
+              applyId ??= routineTransport()?.key("data") ?? crypto.randomUUID(), pending = send3({ operation: "changes.apply", ...captured, applyId }).then((result2) => (confirmed = structuredClone(result2), result2)).catch((error) => {
+                throw error instanceof DataOperationError ? explainDataValidation(new DataOperationError(
                   error.code,
                   error.retryable,
-                  error.effect ?? (["unavailable", "publication_pending"].includes(error.code) ? "uncertain" : "unapplied"),
-                  error.component
-                ) : new DataOperationError("unavailable", !0, "uncertain");
+                  error.effect ?? (["unavailable", "apply_pending"].includes(error.code) ? "uncertain" : "unapplied"),
+                  error.component,
+                  error.detail
+                ), error.message, error.detail) : new DataOperationError("unavailable", !0, "uncertain");
               }).finally(() => {
                 pending = void 0;
               });
@@ -1578,7 +1782,7 @@ async function hostedContent(url, init2, parent, upstream = fetch, check = async
   }
 }
 
-var MAX_BYTES = 16 * 1024 * 1024, PART_BYTES = 8 * 1024 * 1024, METADATA_BYTES = 4096, RESULT_BYTES = 16 * 1024, CONTROL_RESULT_BYTES = 128 * 1024, TIMEOUT_MS = 3e4, MAX_ACTIVE = 4, ATTEMPTS = 2, active = 0, invalid7 = () => new FileOperationError("invalid_input", 400), unavailable2 = () => new FileOperationError("unavailable", 503, !0), failures = {
+var MAX_BYTES = 16 * 1024 * 1024, PART_BYTES = 8 * 1024 * 1024, METADATA_BYTES = 4096, RESULT_BYTES = 16 * 1024, CONTROL_RESULT_BYTES = 128 * 1024, TIMEOUT_MS = 3e4, MAX_ACTIVE = 4, ATTEMPTS = 2, active = 0, waiters = [], invalid7 = () => new FileOperationError("invalid_input", 400), unavailable2 = () => new FileOperationError("unavailable", 503, !0), failures = {
   400: ["invalid_input", "unsupported_context"],
   401: ["unauthenticated"],
   403: ["access_denied"],
@@ -1588,6 +1792,41 @@ var MAX_BYTES = 16 * 1024 * 1024, PART_BYTES = 8 * 1024 * 1024, METADATA_BYTES =
   429: ["capacity"],
   503: ["integrity", "unavailable"]
 };
+function heldSlot() {
+  let held = !0;
+  return () => {
+    if (held)
+      for (held = !1; ; ) {
+        let waiter = waiters.shift();
+        if (!waiter) {
+          active--;
+          return;
+        }
+        if (waiter.waiting) {
+          waiter.waiting = !1, waiter.signal?.removeEventListener("abort", waiter.abort), waiter.resolve(heldSlot());
+          return;
+        }
+      }
+  };
+}
+async function acquireSlot(signal) {
+  if (signal?.aborted) throw unavailable2();
+  return active < MAX_ACTIVE ? (active++, heldSlot()) : new Promise((resolve, reject) => {
+    let waiter = {
+      signal,
+      waiting: !0,
+      resolve,
+      reject,
+      abort() {
+        if (!waiter.waiting) return;
+        waiter.waiting = !1;
+        let index = waiters.indexOf(waiter);
+        index !== -1 && waiters.splice(index, 1), reject(unavailable2());
+      }
+    };
+    waiters.push(waiter), signal?.addEventListener("abort", waiter.abort, { once: !0 }), signal?.aborted && waiter.abort();
+  });
+}
 async function boundedBytes(stream, limit, signal) {
   if (!stream) return new Uint8Array();
   let reader = stream.getReader(), bytes = new Uint8Array(limit), size = 0, cancel = () => {
@@ -1665,7 +1904,7 @@ async function send(suffix, init2, descriptor, initial, parent) {
           parseFileErrorDetail(error?.detail)
         ) : unavailable2();
       }
-      if (response2.status !== (descriptor === 204 ? 204 : 200) || descriptor === 204 && response2.body !== null)
+      if (response2.status !== 200)
         throw response2.body?.cancel().catch(() => {
         }), unavailable2();
       try {
@@ -1674,7 +1913,6 @@ async function send(suffix, init2, descriptor, initial, parent) {
         throw response2.body?.cancel().catch(() => {
         }), error;
       }
-      if (descriptor === 204) return;
       if (!descriptor) return response2;
       let value = await result(response2, descriptor === "control" ? CONTROL_RESULT_BYTES : RESULT_BYTES);
       if (descriptor === "control")
@@ -1698,9 +1936,7 @@ function idPath(id3) {
   if (typeof id3 != "string" || !FILE_ID_PATTERN.test(id3)) throw invalid7();
   return `/${id3}`;
 }
-async function multipartCreate(input, metadata, exchange, release = () => {
-  active--;
-}, upload) {
+async function multipartCreate(input, metadata, exchange, release, upload, expectedSha256) {
   let route = upload ? `${idPath(upload.file.id)}/upload/multipart` : "/multipart", ticket, reader, chunk, offset = 0, receipts = [], pending = /* @__PURE__ */ new Set(), request2 = (work, timeout = TIMEOUT_MS) => timed((signal) => {
     let task = work(signal);
     return pending.add(task), task.then(() => pending.delete(task), () => pending.delete(task)), task;
@@ -1710,7 +1946,9 @@ async function multipartCreate(input, metadata, exchange, release = () => {
     body: JSON.stringify(body)
   });
   try {
-    let start = await request2((signal) => exchange(`${route}/start`, control(upload?.file ?? metadata), "control", signal));
+    let startRequest = control(upload?.file ?? metadata);
+    expectedSha256 && (startRequest.headers["x-os-original-sha256"] = expectedSha256);
+    let start = await request2((signal) => exchange(`${route}/start`, startRequest, "control", signal));
     if (!start || typeof start != "object" || Array.isArray(start)) throw unavailable2();
     let session = start;
     if (Object.keys(session).sort().join(",") !== "partBytes,ticket" || session.partBytes !== PART_BYTES || typeof session.ticket != "string" || !session.ticket || session.ticket.length > 64 * 1024) throw unavailable2();
@@ -1773,10 +2011,15 @@ async function multipartCreate(input, metadata, exchange, release = () => {
     await upload?.beforeComplete();
     let completion = control({ parts: receipts });
     if (new TextEncoder().encode(completion.body).byteLength > 128 * 1024) throw unavailable2();
-    return parseFileDescriptor(await request2(
+    let completed = parseFileDescriptor(await request2(
       (signal) => exchange(`${route}/complete`, completion, !0, signal),
       TIMEOUT_MS + Math.ceil(metadata.size / (1024 * 1024)) * 1e3
     ));
+    if (!upload) {
+      let acknowledged = await request2((signal) => exchange(`${route}/acknowledge`, control(completed), "control", signal));
+      if (!acknowledged || typeof acknowledged != "object" || Object.keys(acknowledged).join(",") !== "acknowledged" || acknowledged.acknowledged !== !0) throw unavailable2();
+    }
+    return completed;
   } catch (error) {
     throw reader && await reader.cancel(error).catch(() => {
     }), ticket && await request2((signal) => exchange(`${route}/abort`, control({}), "control", signal)).catch(() => {
@@ -1786,16 +2029,13 @@ async function multipartCreate(input, metadata, exchange, release = () => {
   }
 }
 async function operation(work, initial, parent) {
-  let context = initial ?? await resolveFilesContext();
-  if (active >= MAX_ACTIVE) throw new FileOperationError("capacity", 429, !0);
-  active++;
-  let execute = async (signal2) => {
+  let context = initial ?? await resolveFilesContext(), signal = context.signal && parent ? AbortSignal.any([context.signal, parent]) : context.signal ?? parent, release = await acquireSlot(signal), execute = async (signal2) => {
     try {
       return await work(context, signal2);
     } finally {
-      active--;
+      release();
     }
-  }, signal = context.signal && parent ? AbortSignal.any([context.signal, parent]) : context.signal ?? parent;
+  };
   return context.localFiles ? execute(signal ?? new AbortController().signal) : timed(execute, signal).catch((error) => {
     throw error instanceof FileOperationError ? error : unavailable2();
   });
@@ -1839,9 +2079,6 @@ async function read(id3, names) {
   });
 }
 var files = {
-  delete(id3) {
-    return operation((context, signal) => send(idPath(id3), { method: "DELETE" }, 204, context, signal));
-  },
   async upload(id3) {
     return operation(async (context, signal) => {
       let file2 = await send(`${idPath(id3)}/upload`, { method: "POST" }, !0, context, signal);
@@ -1876,28 +2113,27 @@ var files = {
     if (!context.local && !context.localFiles && metadata.storage === "local") throw new FileOperationError("unsupported_context", 400);
     let header = encodeURIComponent(JSON.stringify(metadata));
     if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid7();
-    if (active >= MAX_ACTIVE) throw new FileOperationError("capacity", 429, !0);
-    if (active++, context.localFiles && !routineTransport() && metadata.size > MAX_BYTES) {
-      let signal = context.signal ?? new AbortController().signal, file2 = input.file, offset = 0, body = file2 instanceof Blob ? context.signal ? file2 : file2.stream() : file2 instanceof ReadableStream ? file2 : new ReadableStream({
-        pull(controller) {
-          if (offset === file2.byteLength) {
-            controller.close();
-            return;
-          }
-          let end = Math.min(offset + 256 * 1024, file2.byteLength);
-          controller.enqueue(file2.subarray(offset, end)), offset = end;
-        }
-      }, { highWaterMark: 0 });
+    let release = await acquireSlot(context.signal);
+    if (context.localFiles && !routineTransport() && metadata.size > MAX_BYTES)
       try {
+        let signal = context.signal ?? new AbortController().signal, file2 = input.file, offset = 0, body = file2 instanceof Blob ? context.signal ? file2 : file2.stream() : file2 instanceof ReadableStream ? file2 : new ReadableStream({
+          pull(controller) {
+            if (offset === file2.byteLength) {
+              controller.close();
+              return;
+            }
+            let end = Math.min(offset + 256 * 1024, file2.byteLength);
+            controller.enqueue(file2.subarray(offset, end)), offset = end;
+          }
+        }, { highWaterMark: 0 });
         return await send("", { method: "POST", headers: {
           "content-type": "application/octet-stream",
           "x-os-file": header
         }, body }, !0, context, signal);
       } finally {
-        active--;
+        release();
       }
-    }
-    return metadata.size > MAX_BYTES ? multipartCreate(input, metadata, (suffix, init2, kind, signal) => kind === !0 ? send(suffix, init2, !0, context, signal) : send(suffix, init2, "control", context, signal)) : timed(async (signal) => {
+    return metadata.size > MAX_BYTES ? multipartCreate(input, metadata, (suffix, init2, kind, signal) => kind === !0 ? send(suffix, init2, !0, context, signal) : send(suffix, init2, "control", context, signal), release) : timed(async (signal) => {
       try {
         let bytes = array3 ? new Uint8Array(input.file) : await boundedBytes(
           blob ? input.file.stream() : input.file,
@@ -1917,7 +2153,7 @@ var files = {
           body: bytes.buffer
         }, !0, context, signal);
       } finally {
-        active--;
+        release();
       }
     }, context.signal).catch((error) => {
       throw error instanceof FileOperationError ? error : unavailable2();
@@ -2310,16 +2546,75 @@ async function reportLocalRoutineEffect(value) {
   await observer?.(value);
 }
 
+var identityPattern = /^(gmail|airtable|dropbox|outlook|sharepoint)\/([a-z0-9][a-z0-9-]{0,62})$/, workspacePattern = /^[a-z0-9][a-z0-9-]{0,62}$/, providerNames = {
+  gmail: "Gmail",
+  airtable: "Airtable",
+  dropbox: "Dropbox",
+  outlook: "Outlook",
+  sharepoint: "SharePoint"
+};
+function parseConnectionFailureDetail(value) {
+  if (!value || typeof value != "object" || Array.isArray(value)) throw new Error("Invalid Connection failure");
+  let detail = value;
+  if (!["identity", "identity,workspace"].includes(Object.keys(detail).sort().join(",")) || typeof detail.identity != "string" || !identityPattern.test(detail.identity) || detail.workspace !== void 0 && (typeof detail.workspace != "string" || !workspacePattern.test(detail.workspace)))
+    throw new Error("Invalid Connection failure");
+  return { identity: detail.identity, ...detail.workspace === void 0 ? {} : { workspace: detail.workspace } };
+}
+function connectionFailureMessage(value) {
+  let detail = parseConnectionFailureDetail(value), [, provider2, name2] = identityPattern.exec(detail.identity), first = `Couldn\u2019t use ${providerNames[provider2] ?? provider2} connection ${name2}.`;
+  return detail.workspace ? `${first}
+
+Check it with:
+  os connection test --workspace ${detail.workspace} --connection ${detail.identity}` : `${first}
+
+Check or reconnect this Connection, then try again.`;
+}
+var ConnectionOperationError = class extends Error {
+  code = "unavailable";
+  detail;
+  constructor(identity, workspace) {
+    let detail = parseConnectionFailureDetail({ identity, ...workspace === void 0 ? {} : { workspace } });
+    super(connectionFailureMessage(detail)), this.name = "ConnectionOperationError", this.detail = detail;
+  }
+};
+
 var local;
-async function localLease(identity, reportUse = !0) {
+async function localLease(identity) {
   let current2 = local;
   if (!current2 || !current2.declared.includes(identity)) throw new Error("Connection unavailable");
-  reportUse && await current2.recheck(identity);
-  let lease = current2.acquire ? parseConnectionLease(await current2.acquire(identity)) : current2.leases.find((lease2) => `${lease2.provider}/${lease2.name}` === identity);
+  let lease = current2.leases.find((value) => `${value.provider}/${value.name}` === identity);
+  if (lease)
+    try {
+      return parseConnectionLease(lease);
+    } catch {
+      let index = current2.leases.indexOf(lease);
+      if (index !== -1 && current2.leases.splice(index, 1), !current2.acquire) throw new Error("Connection unavailable");
+      lease = void 0;
+    }
+  if (!lease && current2.acquire) {
+    let acquiring = current2.acquiring.get(identity);
+    acquiring || (acquiring = (async () => {
+      let acquired = parseConnectionLease(await current2.acquire(identity));
+      if (local !== current2 || acquired.runId !== current2.runId || `${acquired.provider}/${acquired.name}` !== identity)
+        throw new Error("Connection unavailable");
+      return current2.leases.push(acquired), acquired;
+    })(), current2.acquiring.set(identity, acquiring), acquiring.finally(() => {
+      current2.acquiring.get(identity) === acquiring && current2.acquiring.delete(identity);
+    }).catch(() => {
+    })), lease = await acquiring;
+  }
   if (local !== current2 || !lease || lease.runId !== current2.runId || `${lease.provider}/${lease.name}` !== identity)
     throw new Error("Connection unavailable");
   return parseConnectionLease(lease);
 }
+function connectionFailure(identity) {
+  let workspace = typeof process > "u" ? void 0 : process.env.OS_ROUTINE_WORKSPACE;
+  try {
+    return new ConnectionOperationError(identity, workspace);
+  } catch {
+    return new Error("Connection unavailable");
+  }
+}
 var airtable = /* @__PURE__ */ createConnections(async (name2, operation2, input) => {
   throw new AirtableOperationError("Airtable connection unavailable");
 });
@@ -2327,7 +2622,7 @@ function runtimeConnections() {
   return {
     ...airtable,
     async get(identity) {
-      throw new Error("Connection unavailable");
+      throw connectionFailure(identity);
     }
   };
 }
@@ -2452,8 +2747,7 @@ var operations = {
   "items.listRecipientCandidates": ["itemId"],
   "items.addRecipient": ["itemId", "personId"],
   "questions.answer": ["itemId", "revision", "questionId", "response"],
-  "questions.searchRecords": ["itemId", "revision", "questionId", "query"],
-  "files.read": ["itemId", "fileId"]
+  "questions.searchRecords": ["itemId", "revision", "questionId", "query"]
 };
 function assert(value) {
   if (!value) throw new Error("Invalid Inbox result");
@@ -3259,34 +3553,6 @@ async function send2(operation2, input, admitted) {
     if (response2.status !== 200)
       throw response2.body?.cancel().catch(() => {
       }), unavailable3();
-    if (operation2 === "files.read") {
-      if (!response2.body) throw unavailable3();
-      let source2 = response2.body, reader, size = 0, cancel = async (reason) => {
-        try {
-          await (reader ? reader.cancel(reason) : source2.cancel(reason));
-        } finally {
-          reader?.releaseLock();
-        }
-      }, body = new ReadableStream({
-        async pull(controller) {
-          try {
-            check(), reader ??= source2.getReader();
-            let next = await reader.read();
-            if (check(), next.done) {
-              reader.releaseLock(), controller.close();
-              return;
-            }
-            if (size += next.value.byteLength, size > 25 * 1024 * 1024) throw unavailable3();
-            controller.enqueue(next.value);
-          } catch (error) {
-            controller.error(error), await cancel(error).catch(() => {
-            });
-          }
-        },
-        cancel
-      }, { highWaterMark: 0 });
-      return new Response(body, { status: response2.status, headers: response2.headers });
-    }
     let bytes = await limitedBody(response2, INBOX_RESULT_BYTES);
     if (check(), !bytes) throw unavailable3();
     let value = JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(bytes)), parsed = parseInboxResult(operation2, value);
@@ -3365,8 +3631,7 @@ var inbox = {
     },
     answer: async (input) => await send2("questions.answer", input),
     searchRecords: async (input) => await send2("questions.searchRecords", input)
-  },
-  files: { read: async (input) => await send2("files.read", input) }
+  }
 };
 
 var sources = /* @__PURE__ */ new WeakMap();
@@ -3882,7 +4147,6 @@ function routineRunHandle(operations2) {
   return Object.freeze({
     current: operations2.current,
     step: operations2.step,
-    ...operations2.publish ? { publish: operations2.publish } : {},
     async *watch() {
       let previous;
       for (; ; ) {
@@ -3947,7 +4211,18 @@ function parseRemoteRun(value, expected = {}) {
   };
 }
 
-var identifier = /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/, uuid2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?![\s\S])/i, SUMMARY_BYTES = 17 * 1024 * 1024, AppRoutineError = class extends Error {
+var identifier = /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/, uuid2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?![\s\S])/i, dataErrorCodes = /* @__PURE__ */ new Set([
+  "context_unavailable",
+  "unauthenticated",
+  "access_denied",
+  "invalid_query",
+  "request_too_large",
+  "capacity",
+  "unavailable",
+  "invalid_change",
+  "conflict",
+  "apply_pending"
+]), SUMMARY_BYTES = 17 * 1024 * 1024, AppRoutineError = class extends Error {
   constructor(reason) {
     super(reason);
     this.reason = reason;
@@ -4013,7 +4288,7 @@ function summary(value, key, context, id3) {
       return fail3("execution_unavailable");
     }
   let run = value;
-  return (!only(run, "id,routine,placement,status,createdAt,startedAt,finishedAt,steps,result,failure,publication") || typeof run.id != "string" || !uuid2.test(run.id) || id3 !== void 0 && run.id !== id3 || run.routine !== key || run.placement !== "local" || !["queued", "running", "succeeded", "failed"].includes(run.status) || !timestamp(run.createdAt) || !optionalTimes(run) || !Array.isArray(run.steps) || run.steps.length > 64 || run.steps.some((step) => !only(step, "id,title,status,startedAt,finishedAt,summary,detailAvailable") || typeof step.detailAvailable != "boolean" || !validStep(step)) || new Set(run.steps.map((step) => step.id)).size !== run.steps.length || Object.hasOwn(run, "result") && (run.status !== "succeeded" || !bounded2(run.result)) || run.failure !== void 0 && (run.status !== "failed" || !only(run.failure, "message") || !message(run.failure.message)) || run.publication !== void 0 && (run.status !== "succeeded" || !validPublication(run.publication))) && fail3("execution_unavailable"), run;
+  return (!only(run, "id,routine,placement,status,createdAt,startedAt,finishedAt,steps,result,failure,local") || typeof run.id != "string" || !uuid2.test(run.id) || id3 !== void 0 && run.id !== id3 || run.routine !== key || run.placement !== "local" || !["queued", "running", "succeeded", "failed"].includes(run.status) || !timestamp(run.createdAt) || !optionalTimes(run) || !Array.isArray(run.steps) || run.steps.length > 64 || run.steps.some((step) => !only(step, "id,title,status,startedAt,finishedAt,summary,detailAvailable") || typeof step.detailAvailable != "boolean" || !validStep(step)) || new Set(run.steps.map((step) => step.id)).size !== run.steps.length || Object.hasOwn(run, "result") && (run.status !== "succeeded" || !bounded2(run.result)) || run.failure !== void 0 && (run.status !== "failed" || !only(run.failure, "message") || !message(run.failure.message)) || run.local !== void 0 && !validLocalActivity(run.local)) && fail3("execution_unavailable"), run;
 }
 function only(value, allowed) {
   return !!value && typeof value == "object" && !Array.isArray(value) && Object.keys(value).every((key) => allowed.split(",").includes(key));
@@ -4025,8 +4300,15 @@ function optionalTimes(value) {
 function validStep(step) {
   return typeof step.id == "string" && identifier.test(step.id) && typeof step.title == "string" && step.title.length > 0 && step.title.length <= 256 && ["pending", "running", "completed", "failed", "skipped"].includes(step.status) && optionalTimes(step) && (!Object.hasOwn(step, "summary") || bounded2(step.summary)) && (!Object.hasOwn(step, "data") || bounded2(step.data));
 }
-function validPublication(value) {
-  return value && only(value, value.state === "failed" ? "state,message" : "state") && (["not_needed", "ready", "published"].includes(value.state) || value.state === "failed" && message(value.message));
+function validLocalActivity(value) {
+  let paths = (value2) => Array.isArray(value2) && value2.every((path) => typeof path == "string" && path.length > 0 && path.length <= 4096 && !path.startsWith("/") && !path.includes("\\") && !path.split("/").some((part) => !part || part === "." || part === "..") && !/[\x00-\x1f\x7f]/.test(path));
+  return value && only(value, "data,effects,git") && bounded2(value) && Array.isArray(value.data) && Array.isArray(value.effects) && value.data.every((item) => only(item, "repository,created,updated,deleted,failures,failure") && typeof item.repository == "string" && identifier.test(item.repository) && paths(item.created) && paths(item.updated) && paths(item.deleted) && (item.failures === void 0 || Array.isArray(item.failures) && item.failures.every((code) => typeof code == "string" && dataErrorCodes.has(code))) && (item.failure === void 0 || (() => {
+    try {
+      return parseDataFailureDetail(item.failure), !0;
+    } catch {
+      return !1;
+    }
+  })())) && value.effects.every((item) => only(item, "capability,operation,status,reference,summary") && ["files", "inbox", "ai"].includes(item.capability) && typeof item.operation == "string" && /^[a-zA-Z][a-zA-Z0-9-]{0,62}$/.test(item.operation) && ["completed", "failed"].includes(item.status) && (item.reference === void 0 || typeof item.reference == "string" && uuid2.test(item.reference)) && (!Object.hasOwn(item, "summary") || bounded2(item.summary))) && (value.git === void 0 || only(value.git, "branch,commit,dirty") && typeof value.git.dirty == "boolean" && (value.git.branch === void 0 || typeof value.git.branch == "string" && value.git.branch.length <= 256 && !/[\x00-\x1f\x7f]/.test(value.git.branch)) && (value.git.commit === void 0 || typeof value.git.commit == "string" && /^[0-9a-f]{40}$/.test(value.git.commit)));
 }
 function jsonInput(value, ancestors = /* @__PURE__ */ new Set()) {
   if (value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value)) return;
@@ -4062,9 +4344,6 @@ function handle(key, id3, context) {
           return fail3("execution_unavailable");
         }
       return (!only(value, "id,title,status,startedAt,finishedAt,summary,data") || value.id !== step || !validStep(value)) && fail3("execution_unavailable"), value;
-    },
-    async publish() {
-      return context.kind !== "local" && fail3("execution_unavailable"), summary(await request(key, `runs/${id3}/publish`, { method: "POST" }, SUMMARY_BYTES, context), key, context, id3);
     }
   });
 }
@@ -4144,21 +4423,31 @@ var app = /* @__PURE__ */ Object.freeze({
   })
 });
 
-function validateFileAddOptions(value) {
-  let v = serializable(value);
-  if (!v || typeof v != "object" || Array.isArray(v) || Object.keys(v).some((k) => !["path", "name"].includes(k)) || typeof v.path != "string" || !v.path || v.path !== v.path.trim() || /[\\\x00-\x1f]/.test(v.path) || v.path.split("/").some((part) => !part || part === "." || part === "..") || /^[A-Za-z]:/.test(v.path))
-    throw new InboxContractError("File path must be relative to the configured working root");
-  if (v.name !== void 0 && (typeof v.name != "string" || !v.name || v.name !== v.name.trim() || v.name.length > 255 || /[\x00-\x1f\x7f/\\]/.test(v.name))) throw new InboxContractError("File name must be a safe filename");
-  return v;
+async function requestInboxPublication(operation2, request2, caller) {
+  let attempt = () => {
+    if (caller?.aborted) throw caller.reason;
+    let timeout = AbortSignal.timeout(3e4);
+    return request2(caller ? AbortSignal.any([caller, timeout]) : timeout);
+  };
+  if (operation2 !== "publish") return attempt();
+  try {
+    let response2 = await attempt();
+    if (response2.status !== 408 && response2.status !== 429 && response2.status < 500) return response2;
+    await response2.body?.cancel();
+  } catch (error) {
+    if (caller?.aborted) throw error;
+  }
+  if (caller?.aborted) throw caller.reason;
+  return attempt();
 }
 
 function routinePublicationClient2(options = {}) {
-  let environment = {}, installed2 = routineTransport(), local2 = installed2?.request ?? void 0, workspace = installed2 ? "installed" : options.workspace ?? environment.OS_ROUTINE_WORKSPACE, capability = options.capability ?? environment.OS_ROUTINE_RUN;
+  let environment = {}, installed2 = options.request ? void 0 : routineTransport(), local2 = options.request ? void 0 : installed2?.request ?? void 0, workspace = installed2 ? "installed" : options.workspace ?? environment.OS_ROUTINE_WORKSPACE, capability = options.capability ?? (options.request ? void 0 : environment.OS_ROUTINE_RUN);
   if (!workspace || !/^[a-z0-9][a-z0-9-]*$/.test(workspace) || capability !== void 0 && !/^[0-9a-f]{64}$/.test(capability))
     throw new Error("A workspace and valid optional routine capability are required");
-  let workingRoot = options.workingRoot ?? environment.OS_INBOX_WORKING_ROOT ?? void 0, headers = capability ? { "x-os-run": capability } : {}, request2 = options.request ?? (capability ? async (path, init2) => {
+  let headers = capability ? { "x-os-run": capability } : {}, request2 = options.request ?? (capability ? async (path, init2) => {
     let origin = `https://${workspace}.oddington.ai`, target = new URL(path, `${origin}/`);
-    if (workspace.length > 63 || ["auth", "www", "api", "os"].includes(workspace) || target.origin !== origin || target.search || target.hash || target.username || target.password || !/^\/api\/inbox\/(check|publish|resolve|files)$/.test(path) || init2?.method !== "POST")
+    if (workspace.length > 63 || ["auth", "www", "api", "os"].includes(workspace) || target.origin !== origin || target.search || target.hash || target.username || target.password || !/^\/api\/inbox\/(check|publish|resolve)$/.test(path) || init2?.method !== "POST")
       throw new Error("Invalid routine endpoint");
     return fetch(target, { ...init2, redirect: "error" });
   } : async () => {
@@ -4166,11 +4455,12 @@ function routinePublicationClient2(options = {}) {
   });
   async function send3(operation2, body) {
     if (local2) return await local2(operation2, body);
-    let response2 = await request2(`/api/inbox/${operation2}`, {
+    let response2 = await requestInboxPublication(operation2, (signal) => request2(`/api/inbox/${operation2}`, {
       method: "POST",
       headers: { "content-type": "application/json", ...headers },
-      body: JSON.stringify(body)
-    }), result2 = await response2.json();
+      body: JSON.stringify(body),
+      signal
+    })), result2 = await response2.json();
     if (!response2.ok) throw new Error(result2.error ?? "Could not confirm routine publication");
     return result2;
   }
@@ -4183,19 +4473,13 @@ function routinePublicationClient2(options = {}) {
         await send3("resolve", body);
       }
     }),
-    files: {
-      async add(value) {
-        let input = validateFileAddOptions(value);
-        if (local2) return validateInboxFile(await local2("files/add", input));
-        throw workingRoot ? new Error("Inbox file reads require a Node working root") : new Error("Inbox file reads require a working root");
-      }
-    },
     async check(body) {
-      await send3("check", { requestKey: body.requestKey, item: validatePublication(body.item) });
+      await send3("check", { requestKey: body.requestKey, item: enforcePublicationSize(validatePublication(body.item)) });
     }
   };
 }
 export {
+  AIError,
   AirtableOperationError,
   AppRoutineError,
   BrowserAuthError,
@@ -4203,7 +4487,7 @@ export {
   FileOperationError,
   InboxContractError,
   InboxOperationError,
-  RoutineAIError,
+  AIError as RoutineAIError,
   app,
   asksBlock,
   auth,