@oddington/sdk 0.1.38 → 0.1.40

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;
@@ -271,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);
 }
@@ -612,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 };
     },
@@ -621,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") };
     },
@@ -774,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;
@@ -788,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) {
@@ -803,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) {
@@ -820,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 });
 }
@@ -831,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");
 }
@@ -854,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);
@@ -975,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({
@@ -986,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;
@@ -1025,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);
       }
@@ -1061,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);
@@ -1174,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) {
@@ -1200,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;
 }
@@ -1218,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) {
@@ -1249,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;
@@ -1409,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);
       }
@@ -1428,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",
@@ -1445,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 });
@@ -1467,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) {
@@ -1497,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;
@@ -1506,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;
               });
@@ -1583,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"],
@@ -1593,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 = () => {
@@ -1702,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;
@@ -1714,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();
@@ -1795,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();
   });
@@ -1882,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,
@@ -1923,7 +2153,7 @@ var files = {
           body: bytes.buffer
         }, !0, context, signal);
       } finally {
-        active--;
+        release();
       }
     }, context.signal).catch((error) => {
       throw error instanceof FileOperationError ? error : unavailable2();
@@ -2316,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");
 });
@@ -2333,7 +2622,7 @@ function runtimeConnections() {
   return {
     ...airtable,
     async get(identity) {
-      throw new Error("Connection unavailable");
+      throw connectionFailure(identity);
     }
   };
 }
@@ -3922,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;
@@ -4002,7 +4302,13 @@ function validStep(step) {
 }
 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") && 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) => code === "unavailable"))) && 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)));
+  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,durationMs,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.durationMs === void 0 || typeof item.durationMs == "number" && Number.isFinite(item.durationMs) && item.durationMs >= 0) && (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;
@@ -4168,11 +4474,12 @@ function routinePublicationClient2(options = {}) {
       }
     }),
     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,
@@ -4180,7 +4487,7 @@ export {
   FileOperationError,
   InboxContractError,
   InboxOperationError,
-  RoutineAIError,
+  AIError as RoutineAIError,
   app,
   asksBlock,
   auth,