@oddington/sdk 0.1.6 → 0.1.8

package/dist/browser.js

@@ -0,0 +1,1965 @@
+var InboxContractError = class extends Error {
+  constructor(message) {
+    super(message), this.name = "InboxContractError";
+  }
+};
+function fail(message) {
+  throw new InboxContractError(message);
+}
+function object(value, label) {
+  return (!value || typeof value != "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) && fail(`${label} must be a plain object`), value;
+}
+function keys(value, allowed, label) {
+  for (let key of Reflect.ownKeys(value)) {
+    (typeof key != "string" || !allowed.includes(key)) && fail(`${label} does not support ${String(key)}`);
+    let descriptor2 = Object.getOwnPropertyDescriptor(value, key);
+    (!descriptor2.enumerable || !("value" in descriptor2)) && fail(`${label} must contain only JSON data`);
+  }
+}
+function text(value, label) {
+  return (typeof value != "string" || !value.trim()) && fail(`${label} must be nonempty text`), value;
+}
+function id(value, label) {
+  let result2 = text(value, label);
+  return result2 !== result2.trim() && fail(`${label} cannot have surrounding whitespace`), result2;
+}
+function array(value, label) {
+  (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype || Reflect.ownKeys(value).length !== value.length + 1) && fail(`${label} must be a dense array`);
+  for (let index = 0; index < value.length; index += 1) {
+    let descriptor2 = Object.getOwnPropertyDescriptor(value, String(index));
+    (!descriptor2?.enumerable || !("value" in descriptor2)) && fail(`${label} must contain only JSON data`);
+  }
+  return value;
+}
+function distinctIds(value, label, nonempty = !0) {
+  let result2 = array(value, label).map((entry) => id(entry, label));
+  return nonempty && !result2.length && fail(`${label} must not be empty`), new Set(result2).size !== result2.length && fail(`${label} contains duplicate IDs`), result2;
+}
+var memberEmail = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function personReference(value, label) {
+  let result2 = id(value, label);
+  return memberEmail.test(result2) ? result2.toLowerCase() : result2;
+}
+function distinctPeople(value, label, nonempty = !0) {
+  let result2 = array(value, label).map((entry) => personReference(entry, label));
+  return nonempty && !result2.length && fail(`${label} must not be empty`), new Set(result2).size !== result2.length && fail(`${label} contains duplicate IDs`), result2;
+}
+function serializable(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value == "boolean" || typeof value == "string" || typeof value == "number" && Number.isFinite(value)) return value;
+  (!value || typeof value != "object") && fail("Input must be losslessly serializable JSON"), ancestors.has(value) && fail("Input cannot contain cycles"), ancestors.add(value);
+  try {
+    if (Array.isArray(value))
+      return array(value, "JSON array"), value.map((entry) => serializable(entry, ancestors));
+    let source = object(value, "JSON input");
+    return keys(source, Object.keys(source), "JSON input"), Object.fromEntries(Object.entries(source).map(([key, entry]) => [key, serializable(entry, ancestors)]));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function natural(value, label, minimum = 0) {
+  return (!Number.isSafeInteger(value) || value < minimum) && fail(`${label} must be an integer >= ${minimum}`), value;
+}
+function validateInboxFile(value) {
+  let v = object(serializable(value), "Inbox file");
+  keys(v, ["id", "name", "mediaType", "size", "sha256", "details"], "Inbox file");
+  let fileId = id(v.id, "Inbox file ID"), name = id(v.name, "filename"), mediaType = id(v.mediaType, "media type");
+  (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(fileId) || /[\x00-\x1f\x7f/\\]/.test(name) || !/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(mediaType) || typeof v.sha256 != "string" || !/^[0-9a-f]{64}$/.test(v.sha256)) && fail("Invalid Inbox file identity or metadata");
+  let size = natural(v.size, "file size");
+  size > 25 * 1024 * 1024 && fail("File exceeds supported size");
+  let d = object(v.details, "file details"), details;
+  switch (d.kind) {
+    case "csv":
+      keys(d, ["kind", "encoding", "delimiter", "headerRow", "dataRows"], "CSV details"), (mediaType !== "text/csv" || !["utf-8", "windows-1252"].includes(d.encoding) || ![",", ";", "	"].includes(d.delimiter)) && fail("Invalid CSV details"), details = {
+        kind: "csv",
+        encoding: d.encoding,
+        delimiter: d.delimiter,
+        headerRow: natural(d.headerRow, "header row"),
+        dataRows: natural(d.dataRows, "data rows")
+      };
+      break;
+    case "pdf":
+      keys(d, ["kind", "pages"], "PDF details"), mediaType !== "application/pdf" && fail("Invalid PDF media type"), details = { kind: "pdf", ...d.pages === void 0 ? {} : { pages: natural(d.pages, "PDF pages", 1) } };
+      break;
+    case "other":
+      keys(d, ["kind"], "other file details"), ["text/csv", "application/pdf"].includes(mediaType) && fail("File type and details differ"), details = { kind: "other" };
+      break;
+    default:
+      return fail("Unknown file details kind");
+  }
+  return { id: fileId, name, mediaType, size, sha256: v.sha256, details };
+}
+function fields(value) {
+  let result2 = array(value, "selected fields").map((entry) => {
+    let field = object(entry, "field");
+    return keys(field, ["label", "value"], "field"), { label: text(field.label, "field label"), value: text(field.value, "field value") };
+  });
+  return new Set(result2.map((field) => field.label)).size !== result2.length && fail("Duplicate field label"), result2;
+}
+function validateBlock(value) {
+  let b = object(serializable(value), "Block");
+  if (b.kind === "rich-text")
+    return keys(b, ["kind", "markdown"], "Rich text Block"), { kind: "rich-text", markdown: text(b.markdown, "Markdown") };
+  if (b.kind === "asks") {
+    keys(b, ["kind", "problem", "asks"], "Asks Block");
+    let asks = distinctIds(b.asks, "Ask IDs");
+    return asks.some((ask) => !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(ask)) && fail("Invalid Ask ID"), { kind: "asks", problem: text(b.problem, "problem"), asks };
+  }
+  ["record", "records", "files"].includes(b.kind) || fail("Unknown Block kind"), keys(b, ["kind", "label", "initiallyExpanded", ...b.kind === "record" ? ["record", "view"] : b.kind === "records" ? ["records", "view"] : ["files"]], "Block");
+  let label = text(b.label, "Block label");
+  b.initiallyExpanded !== void 0 && typeof b.initiallyExpanded != "boolean" && fail("Invalid initiallyExpanded");
+  let expanded = b.initiallyExpanded === void 0 ? {} : { initiallyExpanded: b.initiallyExpanded }, target = b.view === void 0 ? {} : { view: id(b.view, "View target") };
+  if (b.kind === "record") {
+    let r = object(b.record, "presented record");
+    return keys(r, ["ref", "title", "fields"], "presented record"), {
+      kind: "record",
+      label,
+      ...target,
+      ...expanded,
+      record: { ref: id(r.ref, "record reference"), title: text(r.title, "record title"), fields: fields(r.fields) }
+    };
+  }
+  if (b.kind === "records") {
+    let records = array(b.records, "records").map((entry) => {
+      let r = object(entry, "record summary");
+      return keys(r, ["ref", "title", "description", "facts", "view"], "record summary"), {
+        ref: id(r.ref, "record reference"),
+        title: text(r.title, "record title"),
+        ...r.description === void 0 ? {} : { description: text(r.description, "record description") },
+        ...r.facts === void 0 ? {} : { facts: fields(r.facts) },
+        ...r.view === void 0 ? {} : { view: id(r.view, "row View target") }
+      };
+    });
+    return (!records.length || new Set(records.map((r) => r.ref)).size !== records.length) && fail("Empty or duplicate records"), { kind: "records", label, records, ...target, ...expanded };
+  }
+  let files2 = array(b.files, "files").map(validateInboxFile);
+  return (!files2.length || new Set(files2.map((file) => file.id)).size !== files2.length) && fail("Empty or duplicate files"), { kind: "files", label, files: files2, ...expanded };
+}
+function richTextBlock(value) {
+  return validateBlock({ ...value, kind: "rich-text" });
+}
+function recordBlock(value) {
+  return validateBlock({ ...value, kind: "record" });
+}
+function recordsBlock(value) {
+  return validateBlock({ ...value, kind: "records" });
+}
+function fileBlock(value) {
+  return validateBlock({ ...value, kind: "files" });
+}
+function asksBlock(value) {
+  return validateBlock({ ...value, kind: "asks" });
+}
+function selection(value) {
+  let input = object(value, "selection");
+  return keys(input, ["source"], "selection"), validateResponseDefinition({ type: "selection", source: input.source });
+}
+function validateAuthoredSource(value) {
+  let source = object(value, "response definition");
+  keys(source, ["type", "options", "suggestions", "search"], "response definition"), source.type !== "authored" && fail("Expected authored options");
+  let options = array(source.options, "options").map((entry) => {
+    let option = object(entry, "choice");
+    keys(option, ["value", "label", "description", "note"], "choice");
+    let note;
+    if (option.note !== void 0) {
+      let declaration = object(option.note, "choice note");
+      keys(declaration, ["placeholder"], "choice note"), note = { placeholder: text(declaration.placeholder, "note placeholder") };
+    }
+    return {
+      value: id(option.value, "choice value"),
+      label: text(option.label, "choice label"),
+      ...option.description === void 0 ? {} : { description: text(option.description, "choice description") },
+      ...note ? { note } : {}
+    };
+  });
+  if (options.length || fail("Choices require at least one option"), new Set(options.map((option) => option.value)).size !== options.length && fail("Duplicate choice value"), Object.hasOwn(source, "search") || Object.hasOwn(source, "suggestions")) {
+    let labels = object(source.search, "choice search");
+    keys(labels, ["triggerLabel", "placeholder", "emptyLabel"], "choice search");
+    let search = {
+      triggerLabel: text(labels.triggerLabel, "search trigger label"),
+      placeholder: text(labels.placeholder, "search placeholder"),
+      emptyLabel: text(labels.emptyLabel, "search empty label")
+    }, suggestions = array(source.suggestions, "suggestions").map((value2) => id(value2, "suggestion value"));
+    return (suggestions.length > 8 || new Set(suggestions).size !== suggestions.length || suggestions.some((value2) => !options.some((option) => option.value === value2))) && fail("Search permits at most eight unique published suggestions"), { type: "authored", options, suggestions, search };
+  }
+  return options.length > 9 && fail("Choices require one to nine options"), { type: "authored", options };
+}
+function validateRecordReference(value) {
+  let row = object(value, "Record reference");
+  keys(row, ["repository", "ref"], "Record reference");
+  let repository = id(row.repository, "repository"), ref = id(row.ref, "Record reference");
+  return (!/^[a-z0-9][a-z0-9._/-]{0,127}$/.test(repository) || /\.\.|\/\//.test(repository) || ref.length > 512 || !/^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)+$/.test(ref)) && fail("Invalid Record identity"), { repository, ref };
+}
+function validateRecordSource(value) {
+  let source = object(value, "Record selection");
+  keys(source, ["type", "collection", "refPrefix", "where", "display", "suggestions"], "Record selection"), source.type !== "records" && fail("Expected Record options");
+  let collection = object(source.collection, "collection");
+  keys(collection, ["repository", "name"], "collection");
+  let repository = validateRecordReference({ repository: collection.repository, ref: "records/example" }).repository, name = id(collection.name, "collection name");
+  /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*$/.test(name) || fail("Invalid collection name");
+  let refPrefix = source.refPrefix === void 0 ? void 0 : id(source.refPrefix, "Record reference prefix");
+  refPrefix !== void 0 && (!refPrefix.endsWith("/") || refPrefix.length > 512 || !/^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)*\/$/.test(refPrefix)) && fail("Invalid Record reference prefix");
+  let where = object(source.where ?? {}, "Record filter"), fieldName = (name2) => /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name2) && !["constructor", "prototype"].includes(name2);
+  for (let [name2, value2] of Object.entries(where))
+    (!fieldName(name2) || !(value2 === null || ["string", "number", "boolean"].includes(typeof value2)) || typeof value2 == "number" && !Number.isFinite(value2)) && fail("Record filters require scalar equality");
+  let display = object(source.display, "Record display");
+  keys(display, ["labelFields"], "Record display");
+  let labelFields = distinctIds(display.labelFields, "label fields");
+  (labelFields.length > 2 || labelFields.some((name2) => !fieldName(name2))) && fail("Select one or two scalar label fields");
+  let suggestions = array(source.suggestions ?? [], "suggestions").map((value2) => {
+    let entry = object(value2, "suggestion");
+    keys(entry, ["record", "reason"], "suggestion");
+    let record2 = validateRecordReference(entry.record);
+    return record2.repository !== repository && fail("Suggestion belongs to another repository"), { record: record2, ...entry.reason === void 0 ? {} : { reason: text(entry.reason, "suggestion reason") } };
+  });
+  return (suggestions.length > 8 || new Set(suggestions.map((entry) => entry.record.ref)).size !== suggestions.length) && fail("Record selection permits at most eight unique suggestions"), {
+    type: "records",
+    collection: { repository, name },
+    ...refPrefix ? { refPrefix } : {},
+    where: { ...where },
+    display: { labelFields },
+    suggestions
+  };
+}
+function validateResponseDefinition(value) {
+  let definition = object(value, "response definition");
+  keys(definition, ["type", "source"], "response definition"), definition.type !== "selection" && fail("Expected a selection definition");
+  let source = object(definition.source, "option source");
+  switch (source.type) {
+    case "authored":
+      return { type: "selection", source: validateAuthoredSource(source) };
+    case "records":
+      return { type: "selection", source: validateRecordSource(source) };
+    default:
+      return fail("Unsupported option source");
+  }
+}
+function handlerReference(value) {
+  let source = object(value, "handler reference");
+  return keys(source, ["id", "input"], "handler reference"), { id: id(source.id, "handler ID"), input: serializable(source.input) };
+}
+function defineHandler(value) {
+  let source = object(value, "handler");
+  return keys(source, ["id", "run"], "handler"), id(source.id, "handler ID"), typeof source.run != "function" && fail("Handler requires a run function"), Object.freeze({ id: value.id, run: value.run });
+}
+function respond(handler, input) {
+  return defineHandler(handler), handlerReference({ id: handler.id, input });
+}
+function question(value) {
+  let source = object(value, "question");
+  keys(source, ["id", "to", "allowedResponders", "prompt", "instructions", "response", "handler"], "question");
+  let to = personReference(source.to, "question assignee"), allowedResponders = source.allowedResponders === void 0 ? [to] : distinctPeople(source.allowedResponders, "allowed responders");
+  return allowedResponders.includes(to) || fail("Allowed responders must include the assignee"), {
+    id: id(source.id, "question ID"),
+    to,
+    allowedResponders,
+    prompt: text(source.prompt, "question prompt"),
+    ...source.instructions === void 0 ? {} : { instructions: text(source.instructions, "instructions") },
+    response: validateResponseDefinition(source.response),
+    ...Object.hasOwn(source, "handler") ? { handler: handlerReference(source.handler) } : {}
+  };
+}
+function presentation(source) {
+  let views = source.views === void 0 ? [] : array(source.views, "views").map((entry) => {
+    let view = object(entry, "view");
+    return keys(view, ["id", "view", "input"], "view"), { id: id(view.id, "view ID"), view: id(view.view, "view name"), input: serializable(view.input) };
+  });
+  new Set(views.map((view) => view.id)).size !== views.length && fail("Duplicate view ID");
+  let body2 = source.body === void 0 ? [] : array(source.body, "body").map(validateBlock);
+  for (let block of body2) {
+    let targets = block.kind === "record" ? [block.view] : block.kind === "records" ? [block.view, ...block.records.map((record2) => record2.view)] : [];
+    for (let target of targets) target !== void 0 && !views.some((view) => view.id === target) && fail(`Unknown Block View target: ${target}`);
+  }
+  return { title: text(source.title, "title"), description: text(source.description, "description"), views, body: body2 };
+}
+function validatePublication(value) {
+  let source = object(value, "publication");
+  source.kind !== "ask" && source.kind !== "digest" && fail("Publication requires an explicit kind"), keys(source, [
+    "kind",
+    "title",
+    "description",
+    "recipients",
+    "views",
+    "body",
+    "notifyImmediately",
+    ...source.kind === "ask" ? ["questions"] : []
+  ], "publication"), source.notifyImmediately !== void 0 && typeof source.notifyImmediately != "boolean" && fail("notifyImmediately must be a boolean");
+  let itemPresentation = { ...presentation(source), ...source.notifyImmediately === void 0 ? {} : { notifyImmediately: source.notifyImmediately } }, linkedAsks = (itemPresentation.body ?? []).flatMap((block) => block.kind === "asks" ? block.asks : []);
+  if (new Set(linkedAsks).size !== linkedAsks.length && fail("Ask belongs to more than one problem"), source.kind === "digest") return {
+    kind: "digest",
+    ...itemPresentation,
+    recipients: distinctPeople(source.recipients, "digest recipients")
+  };
+  itemPresentation.body?.some((block) => block.kind === "asks") && fail("Asks Blocks belong to Digests");
+  let questions = array(source.questions === void 0 ? [] : source.questions, "questions").map((value2) => question(value2));
+  new Set(questions.map((entry) => entry.id)).size !== questions.length && fail("Duplicate question ID");
+  let extra = source.recipients === void 0 ? [] : distinctPeople(source.recipients, "recipients", !1);
+  return !questions.length && !extra.length && fail("Ask requires at least one recipient"), {
+    kind: "ask",
+    ...itemPresentation,
+    questions,
+    recipients: [.../* @__PURE__ */ new Set([...extra, ...questions.flatMap((entry) => [entry.to, ...entry.allowedResponders])])]
+  };
+}
+function continueAsk(value) {
+  let source = object(value, "continueAsk");
+  return keys(source, [], "continueAsk"), { type: "continue" };
+}
+function resolution(value) {
+  let source = object(value, "resolution");
+  return keys(source, ["outcome", "evidence"], "resolution"), { outcome: text(source.outcome, "outcome"), ...source.evidence === void 0 ? {} : {
+    evidence: array(source.evidence, "evidence").map((entry) => serializable(entry))
+  } };
+}
+function resolveAsk(value) {
+  return { type: "resolve", ...resolution(value) };
+}
+function validateResolution(value) {
+  let source = object(value, "published resolution");
+  return keys(source, ["expectedRevision", "outcome", "evidence"], "published resolution"), (!Number.isSafeInteger(source.expectedRevision) || source.expectedRevision < 1) && fail("Expected revision must be a positive integer"), {
+    expectedRevision: source.expectedRevision,
+    ...resolution({
+      outcome: source.outcome,
+      ...source.evidence === void 0 ? {} : { evidence: source.evidence }
+    })
+  };
+}
+function publicationRequestKey(value) {
+  let options = object(value, "publication options");
+  return keys(options, ["requestKey"], "publication options"), id(options.requestKey, "publication request key");
+}
+function createInboxPublisher(transport) {
+  return {
+    async publishAsk(value, options) {
+      let source = object(value, "ask");
+      keys(source, ["title", "description", "recipients", "views", "body", "questions", "notifyImmediately"], "ask");
+      let result2 = await transport.publish({
+        requestKey: publicationRequestKey(options),
+        item: validatePublication({ ...source, 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 };
+    },
+    async publishDigest(value, options) {
+      let source = object(value, "digest");
+      keys(source, ["title", "description", "recipients", "views", "body", "notifyImmediately"], "digest");
+      let result2 = await transport.publish({
+        requestKey: publicationRequestKey(options),
+        item: validatePublication({ ...source, kind: "digest" })
+      });
+      return { id: id(result2.id, "published digest ID") };
+    },
+    async publishResolution(askId, value) {
+      await transport.resolve({ askId: id(askId, "ask ID"), resolution: validateResolution(value) });
+    }
+  };
+}
+
+var REPOSITORY = /^[a-z0-9][a-z0-9._/-]{0,127}$/;
+function validRepositoryAlias(value) {
+  return typeof value == "string" && REPOSITORY.test(value) && !value.includes("//") && !value.includes("..");
+}
+
+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);
+}
+function validateRecordRead(value) {
+  if (!value || typeof value != "object" || Array.isArray(value))
+    throw new InboxContractError("Invalid selected-record read");
+  let input = value;
+  if (Object.keys(input).some((key) => !["repository", "refs", "atCommit"].includes(key)) || !validRepositoryAlias(input.repository) || !Array.isArray(input.refs) || !input.refs.length || input.refs.length > 1e4 || input.refs.some((ref) => !validRecordRef(ref)) || new Set(input.refs).size !== input.refs.length || input.atCommit !== void 0 && (typeof input.atCommit != "string" || !/^[0-9a-f]{40}$/.test(input.atCommit)))
+    throw new InboxContractError("Invalid selected-record read");
+  return {
+    repository: input.repository,
+    refs: [...input.refs],
+    ...input.atCommit === void 0 ? {} : { atCommit: input.atCommit }
+  };
+}
+
+var RECORD_WRITE_INPUT_LIMIT = 8 * 1024 * 1024, RoutineRecordWriteError = class extends Error {
+  constructor(message, effect) {
+    super(message);
+    this.effect = effect;
+    this.name = "RoutineRecordWriteError";
+  }
+  effect;
+};
+function validateRecordWrite(value) {
+  let input = serializable(value);
+  if (!input || Array.isArray(input) || typeof input != "object" || Object.keys(input).sort().join(",") !== "records,repository" || !validRepositoryAlias(input.repository) || !Array.isArray(input.records) || !input.records.length || input.records.length > 1e4 || new Set(input.records.map((edit) => edit?.ref)).size !== input.records.length)
+    throw new InboxContractError("Invalid record update batch");
+  for (let edit of input.records) {
+    if (!edit || Array.isArray(edit) || typeof edit != "object" || !validRecordRef(edit.ref))
+      throw new InboxContractError("Invalid record edit");
+    if ("expectedVersion" in edit) {
+      if (Object.keys(edit).sort().join(",") !== "expectedVersion,ref,set" || typeof edit.expectedVersion != "string" || !/^record-v1:[0-9a-f]{64}$/.test(edit.expectedVersion) || !edit.set || Array.isArray(edit.set) || typeof edit.set != "object" || !Object.keys(edit.set).length)
+        throw new InboxContractError("Invalid record edit");
+      continue;
+    }
+    if (Object.keys(edit).sort().join(",") !== "fields,path,ref" || typeof edit.path != "string" || !validCreatePath(edit.path) || !edit.fields || Array.isArray(edit.fields) || typeof edit.fields != "object" || !Object.keys(edit.fields).length)
+      throw new InboxContractError("Invalid record creation");
+  }
+  return structuredClone(input);
+}
+function validateRecordUpdate(value) {
+  let input = validateRecordWrite(value);
+  if (input.records.some((record2) => !("expectedVersion" in record2)))
+    throw new InboxContractError("Record creation is unavailable for this operation");
+  return input;
+}
+function validateRecordDelete(value) {
+  let input = serializable(value);
+  if (!input || Array.isArray(input) || typeof input != "object" || Object.keys(input).sort().join(",") !== "records,repository" || !validRepositoryAlias(input.repository) || !Array.isArray(input.records) || !input.records.length || input.records.length > 1e4 || new Set(input.records.map((record2) => record2?.ref)).size !== input.records.length)
+    throw new InboxContractError("Invalid record deletion batch");
+  for (let record2 of input.records)
+    if (!record2 || Array.isArray(record2) || typeof record2 != "object" || Object.keys(record2).sort().join(",") !== "expectedVersion,ref" || !validRecordRef(record2.ref) || typeof record2.expectedVersion != "string" || !/^record-v1:[0-9a-f]{64}$/.test(record2.expectedVersion))
+      throw new InboxContractError("Invalid record deletion");
+  return structuredClone(input);
+}
+function validateRecordChange(value) {
+  let input = serializable(value);
+  if (!input || Array.isArray(input) || typeof input != "object" || Object.keys(input).sort().join(",") !== "records,repository" || !validRepositoryAlias(input.repository) || !Array.isArray(input.records) || !input.records.length || input.records.length > 1e4 || new Set(input.records.map((record2) => record2?.ref)).size !== input.records.length || new TextEncoder().encode(JSON.stringify(input)).byteLength > RECORD_WRITE_INPUT_LIMIT)
+    throw new InboxContractError("Invalid record change batch");
+  let writes = [], deletes = [];
+  for (let record2 of input.records) {
+    if (!record2 || typeof record2 != "object" || Array.isArray(record2))
+      throw new InboxContractError("Invalid record change");
+    "set" in record2 || "fields" in record2 ? writes.push(record2) : deletes.push(record2);
+  }
+  return writes.length && validateRecordWrite({ repository: input.repository, records: writes }), deletes.length && validateRecordDelete({ repository: input.repository, records: deletes }), structuredClone(input);
+}
+function validateRoutineRecordWrite(value) {
+  let body2 = serializable(value);
+  if (!body2 || typeof body2 != "object" || Array.isArray(body2) || Object.keys(body2).sort().join(",") !== "input,requestKey" || typeof body2.requestKey != "string" || !body2.requestKey.trim() || body2.requestKey !== body2.requestKey.trim() || body2.requestKey.length > 512)
+    throw new InboxContractError("A stable routine request key is required");
+  return { input: validateRecordChange(body2.input), requestKey: body2.requestKey };
+}
+function validCreatePath(value) {
+  return value === value.trim() && value.endsWith(".md") && !value.startsWith("/") && value.split("/").every((segment) => !!segment && ![".", ".."].includes(segment) && /^[a-zA-Z0-9_.-]+$/.test(segment));
+}
+
+function validGoogleScopes(value) {
+  return Array.isArray(value) && value.length > 0 && value.length <= 32 && value.every((scope) => typeof scope == "string" && scope.length <= 256 && /^(https:\/\/www\.googleapis\.com\/auth\/[A-Za-z0-9._-]+|https:\/\/mail\.google\.com\/|openid|email|profile)$/.test(scope)) && new Set(value).size === value.length;
+}
+
+var ROUTINE_CONNECTION_CREDENTIALS_ENV = "ODDINGTON_ROUTINE_CONNECTION_CREDENTIALS";
+var connectionUuid = (v) => typeof v == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(v);
+function parseConnectionLease(raw, now = Date.now()) {
+  let v = raw;
+  if (!v || typeof v != "object" || Array.isArray(v) || !connectionUuid(v.connectionId) || !connectionUuid(v.runId) || typeof v.name != "string" || !/^[a-z0-9][a-z0-9-]{0,62}$/.test(v.name) || typeof v.accessToken != "string" || !/^[A-Za-z0-9._~+/-]{1,8192}={0,2}$/.test(v.accessToken))
+    throw new Error("Invalid connection credential");
+  if (v.provider === "gmail") {
+    if (Object.keys(v).sort().join(",") !== "accessToken,accountEmail,connectionId,expiresAt,name,provider,runId,scopes" || typeof v.accountEmail != "string" || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v.accountEmail) || !validGoogleScopes(v.scopes) || typeof v.expiresAt != "string" || !Number.isFinite(Date.parse(v.expiresAt)) || Date.parse(v.expiresAt) <= now + 6e4 || Date.parse(v.expiresAt) > now + 36e5)
+      throw new Error("Invalid connection credential");
+    return v;
+  }
+  if (v.provider === "airtable" && Object.keys(v).sort().join(",") === "accessToken,baseId,connectionId,name,provider,runExpiresAt,runId" && typeof v.baseId == "string" && /^app[A-Za-z0-9]+$/.test(v.baseId) && typeof v.runExpiresAt == "string" && Number.isFinite(Date.parse(v.runExpiresAt)) && Date.parse(v.runExpiresAt) > now + 6e4 && Date.parse(v.runExpiresAt) <= now + 15 * 6e4)
+    return v;
+  throw new Error("Invalid connection credential");
+}
+
+var AirtableOperationError = class extends Error {
+  constructor(message, effect = "unapplied", receipts = []) {
+    super(message);
+    this.effect = effect;
+    this.receipts = receipts;
+    this.name = "AirtableOperationError";
+  }
+  effect;
+  receipts;
+};
+
+var recordId = (v) => typeof v == "string" && /^rec[A-Za-z0-9]+$/.test(v), tableId = (v) => typeof v == "string" && /^tbl[A-Za-z0-9]+$/.test(v);
+function fail2(message) {
+  throw new AirtableOperationError(message);
+}
+function object2(v) {
+  return (!v || typeof v != "object" || Array.isArray(v) || ![null, Object.prototype].includes(Object.getPrototypeOf(v))) && fail2("Invalid Airtable data"), v;
+}
+function keys2(v, allowed, required = allowed) {
+  (Object.keys(v).some((k) => !allowed.includes(k)) || required.some((k) => !Object.hasOwn(v, k))) && fail2("Invalid Airtable input");
+}
+function text2(v) {
+  return typeof v == "string" && v.length > 0 && v.length <= 1024;
+}
+function fields2(v, nonempty = !1) {
+  let result2 = object2(v);
+  (nonempty && !Object.keys(result2).length || Object.keys(result2).some((k) => !text2(k))) && fail2("Invalid Airtable fields");
+  try {
+    return serializable(result2);
+  } catch {
+    return fail2("Invalid Airtable fields");
+  }
+}
+function record(v) {
+  let r = object2(v);
+  return (!recordId(r.id) || r.createdTime !== void 0 && (typeof r.createdTime != "string" || !Number.isFinite(Date.parse(r.createdTime)))) && fail2("Malformed Airtable record"), { id: r.id, ...r.createdTime === void 0 ? {} : { createdTime: r.createdTime }, fields: fields2(r.fields) };
+}
+function equal(a, b) {
+  if (a === b) return !0;
+  if (!a || !b || typeof a != "object" || typeof b != "object" || Array.isArray(a) !== Array.isArray(b)) return !1;
+  let left = Object.keys(a), right = Object.keys(b);
+  return left.length === right.length && left.every((k) => Object.hasOwn(b, k) && equal(
+    a[k],
+    b[k]
+  ));
+}
+function createConnections(transport) {
+  return { airtable(name) {
+    (typeof name != "string" || !/^[a-z0-9][a-z0-9-]{0,62}$/.test(name)) && fail2("Invalid Airtable connection name");
+    let call = (operation2, input) => transport(name, operation2, input);
+    return {
+      tables: { list: async () => await call("tables.list", {}) },
+      records: {
+        list: async (input) => await call("records.list", input),
+        get: async (input) => await call("records.get", input),
+        create: async (input) => await call("records.create", input),
+        update: async (input) => await call("records.update", input),
+        delete: async (input) => await call("records.delete", input)
+      }
+    };
+  } };
+}
+async function executeAirtableOperation(authority, operation2, raw, options = {}) {
+  let { name, baseId, accessToken } = authority;
+  (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(name) || !/^app[A-Za-z0-9]+$/.test(baseId) || !/^[A-Za-z0-9._~+/-]{1,8192}={0,2}$/.test(accessToken)) && fail2("Airtable connection unavailable");
+  let input;
+  try {
+    input = object2(serializable(raw));
+  } catch {
+    return fail2("Invalid Airtable input");
+  }
+  let mutation = ["records.create", "records.update", "records.delete"].includes(operation2), receipt = (ids2) => ({
+    provider: "airtable",
+    connection: `airtable/${name}`,
+    baseId,
+    table: input.table,
+    operation: operation2.slice(8),
+    records: ids2.map((id2) => ({ id: id2 }))
+  });
+  async function request(path2, init2 = {}, write = !1) {
+    let response;
+    try {
+      response = await (options.fetch ?? fetch)(`https://api.airtable.com/v0/${path2}`, {
+        ...init2,
+        headers: { authorization: `Bearer ${accessToken}`, "content-type": "application/json" },
+        redirect: "manual",
+        signal: options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(15e3)]) : AbortSignal.timeout(15e3)
+      });
+    } catch {
+      throw new AirtableOperationError("Airtable request acknowledgment unavailable", write ? "uncertain" : "unapplied");
+    }
+    if (!response.ok)
+      throw await response.body?.cancel().catch(() => {
+      }), new AirtableOperationError("Airtable request rejected", write && (response.status >= 500 || response.status === 408 || response.status < 400) ? "uncertain" : "unapplied");
+    try {
+      if (!response.headers.get("content-type")?.toLowerCase().includes("application/json")) throw new Error();
+      let value = object2(await response.json()), safe = serializable(value);
+      if (Object.hasOwn(value, "error") || JSON.stringify(safe).includes(accessToken)) throw new Error();
+      return value;
+    } catch {
+      throw new AirtableOperationError("Malformed Airtable acknowledgment", write ? "uncertain" : "unapplied");
+    }
+  }
+  if (operation2 === "tables.list") {
+    keys2(input, []);
+    let tables = [], seen = /* @__PURE__ */ new Set(), offset;
+    do {
+      let query2 = new URLSearchParams(offset ? { offset } : {}), page = await request(`meta/bases/${baseId}/tables?${query2}`);
+      Array.isArray(page.tables) || fail2("Malformed Airtable tables");
+      for (let value of page.tables) {
+        let t = object2(value);
+        (!tableId(t.id) || !text2(t.name) || !text2(t.primaryFieldId) || !Array.isArray(t.fields) || tables.some((existing) => existing.id === t.id)) && fail2("Malformed Airtable table");
+        let metadata = t.fields.map((value2) => {
+          let f = object2(value2);
+          return (typeof f.id != "string" || !/^fld[A-Za-z0-9]+$/.test(f.id) || !text2(f.name) || !text2(f.type)) && fail2("Malformed Airtable field"), { id: f.id, name: f.name, type: f.type, ...f.options === void 0 ? {} : { options: serializable(f.options) } };
+        });
+        (!metadata.some((f) => f.id === t.primaryFieldId) || new Set(metadata.map((f) => f.id)).size !== metadata.length) && fail2("Malformed Airtable fields"), tables.push({ id: t.id, name: t.name, primaryFieldId: t.primaryFieldId, fields: metadata });
+      }
+      offset = nextOffset(page.offset, seen);
+    } while (offset);
+    return tables;
+  }
+  (!text2(input.table) || input.table === "." || input.table === "..") && fail2("Invalid Airtable table"), mutation && !tableId(input.table) && fail2("Airtable writes require a stable table ID");
+  let path = `${baseId}/${encodeURIComponent(input.table)}`;
+  if (operation2 === "records.get") {
+    keys2(input, ["table", "id"]), recordId(input.id) || fail2("Invalid Airtable record ID");
+    let result3 = record(await request(`${path}/${input.id}`));
+    return result3.id !== input.id && fail2("Malformed Airtable record"), result3;
+  }
+  if (operation2 === "records.list") {
+    keys2(input, ["table", "fields"], ["table"]), input.fields !== void 0 && (!Array.isArray(input.fields) || !input.fields.length || input.fields.some((f) => !text2(f)) || new Set(input.fields).size !== input.fields.length) && fail2("Invalid Airtable field selection");
+    let records2 = [], ids2 = /* @__PURE__ */ new Set(), seen = /* @__PURE__ */ new Set(), offset;
+    do {
+      let query2 = new URLSearchParams();
+      for (let field of input.fields ?? []) query2.append("fields[]", field);
+      offset && query2.set("offset", offset);
+      let page = await request(`${path}?${query2}`);
+      Array.isArray(page.records) || fail2("Malformed Airtable records");
+      for (let value of page.records) {
+        let r = record(value);
+        ids2.has(r.id) && fail2("Malformed Airtable pagination"), ids2.add(r.id), records2.push(r);
+      }
+      offset = nextOffset(page.offset, seen);
+    } while (offset);
+    return records2;
+  }
+  mutation || fail2("Unsupported Airtable operation"), keys2(input, ["table", "records"]), (!Array.isArray(input.records) || !input.records.length || input.records.length > 10) && fail2("Invalid Airtable batch");
+  let kind = operation2.slice(8), ids = /* @__PURE__ */ new Set(), records = input.records.map((value) => {
+    let r = object2(value);
+    if (keys2(r, kind === "create" ? ["fields"] : kind === "update" ? ["id", "expected", "set"] : ["id", "expected"]), kind === "create") return { fields: fields2(r.fields, !0) };
+    (!recordId(r.id) || ids.has(r.id)) && fail2("Invalid Airtable batch record ID"), ids.add(r.id);
+    let set = kind === "update" ? fields2(r.set, !0) : void 0;
+    return set && Object.values(set).some((value2) => value2 === null) && fail2("Airtable guard null cannot be an update value"), { id: r.id, expected: fields2(r.expected), ...set ? { set } : {} };
+  });
+  for (let r of records) {
+    if (!("id" in r)) continue;
+    let current2 = record(await request(`${path}/${r.id}`));
+    current2.id !== r.id && fail2("Malformed Airtable record");
+    for (let [key, value] of Object.entries(r.expected))
+      (value === null ? Object.hasOwn(current2.fields, key) : !Object.hasOwn(current2.fields, key) || !equal(current2.fields[key], value)) && fail2("Airtable reviewed values are stale");
+  }
+  await options.beforeMutation?.();
+  let query = new URLSearchParams();
+  if (kind === "delete") for (let id2 of ids) query.append("records[]", id2);
+  let result2 = await request(`${path}${kind === "delete" ? `?${query}` : ""}`, {
+    method: kind === "create" ? "POST" : kind === "update" ? "PATCH" : "DELETE",
+    ...kind === "delete" ? {} : { body: JSON.stringify({ records: records.map((r) => "id" in r ? { id: r.id, fields: r.set } : r) }) }
+  }, !0), acknowledged = [], returned = [];
+  try {
+    if (!Array.isArray(result2.records)) throw new Error();
+    for (let value of result2.records) {
+      let r = object2(value);
+      if (!recordId(r.id) || acknowledged.includes(r.id) || kind !== "create" && !ids.has(r.id) || kind === "delete" && r.deleted !== !0) throw new Error();
+      acknowledged.push(r.id), kind !== "delete" && returned.push(record(r));
+    }
+    if (acknowledged.length !== records.length) throw new Error();
+  } catch {
+    throw new AirtableOperationError(
+      "Incomplete Airtable mutation acknowledgment",
+      acknowledged.length ? "partial" : "uncertain",
+      acknowledged.length ? [receipt(acknowledged)] : []
+    );
+  }
+  return { receipt: receipt(acknowledged), ...kind === "delete" ? {} : { records: returned } };
+}
+function nextOffset(value, seen) {
+  if (value !== void 0)
+    return (!text2(value) || seen.has(value)) && fail2("Malformed Airtable pagination"), seen.add(value), value;
+}
+
+var MANAGED_CONNECTION_CAPABILITY_ENV = "ODDINGTON_MANAGED_CONNECTION_CAPABILITY";
+function managedConnections(capability) {
+  let endpoint = new URL(capability.endpoint);
+  if (endpoint.protocol !== "http:" || endpoint.hostname !== "127.0.0.1" || !endpoint.port || endpoint.pathname !== "/" || endpoint.search || endpoint.hash || endpoint.username || endpoint.password || !/^[0-9a-f-]{36}$/.test(capability.token)) throw new AirtableOperationError("Airtable capability unavailable");
+  return createConnections(async (name, operation2, input) => {
+    let safeInput;
+    try {
+      safeInput = serializable(input);
+    } catch {
+      safeInput = null;
+    }
+    try {
+      let response = await fetch(new URL("airtable", endpoint), {
+        method: "POST",
+        redirect: "error",
+        headers: { authorization: `Bearer ${capability.token}`, "content-type": "application/json" },
+        body: JSON.stringify({ name, operation: operation2, input: safeInput }),
+        signal: AbortSignal.timeout(125e3)
+      }), value = await response.json();
+      if (!response.ok) throw new AirtableOperationError(
+        "Airtable operation failed; the execution retains its evidence",
+        value.effect === "partial" || value.effect === "uncertain" ? value.effect : "unapplied",
+        value.receipts ?? []
+      );
+      return value;
+    } catch (error) {
+      throw error instanceof AirtableOperationError ? error : new AirtableOperationError(
+        "Airtable parent acknowledgment unavailable",
+        ["records.create", "records.update", "records.delete"].includes(operation2) ? "uncertain" : "unapplied"
+      );
+    }
+  });
+}
+
+var connections = /* @__PURE__ */ createConnections(async (name, operation2, input) => {
+  try {
+    let managed = process.env[MANAGED_CONNECTION_CAPABILITY_ENV];
+    if (managed) {
+      let client = managedConnections(JSON.parse(managed)).airtable(name);
+      return operation2 === "tables.list" ? await client.tables.list() : await client.records[operation2.slice(8)](input);
+    }
+    let raw = JSON.parse(process.env[ROUTINE_CONNECTION_CREDENTIALS_ENV] ?? "[]");
+    if (!Array.isArray(raw)) throw new Error();
+    let leases = raw.map((value) => parseConnectionLease(value));
+    if (leases.some((lease2) => lease2.provider !== "airtable") || new Set(leases.map((lease2) => lease2.name)).size !== leases.length) throw new Error();
+    let lease = leases.find((lease2) => lease2.name === name);
+    if (!lease || lease.provider !== "airtable") throw new Error();
+    return await executeAirtableOperation(lease, operation2, input);
+  } catch (error) {
+    throw error instanceof AirtableOperationError ? error : new AirtableOperationError("Airtable connection unavailable");
+  }
+});
+
+var DataOperationError = class extends Error {
+  constructor(code, retryable = !1, effect, component) {
+    super(`Data operation failed: ${code}`);
+    this.code = code;
+    this.retryable = retryable;
+    this.effect = effect;
+    this.component = component;
+    this.name = "DataOperationError";
+  }
+  code;
+  retryable;
+  effect;
+  component;
+};
+
+var invalid = () => {
+  throw new DataOperationError("invalid_query");
+}, scalarText = (value) => typeof value == "string" && !/[\u0000\uD800-\uDFFF]/u.test(value);
+function captureRecordsSearchInput(query, options) {
+  if (!scalarText(query)) return invalid();
+  let length = [...query.trim()].length;
+  if (length < 1 || length > 256) return invalid();
+  if (options === void 0) return { query };
+  if (!options || typeof options != "object" || Array.isArray(options) || ![Object.prototype, null].includes(Object.getPrototypeOf(options))) return invalid();
+  let descriptors = Object.getOwnPropertyDescriptors(options);
+  if (Reflect.ownKeys(options).some((key) => typeof key != "string" || !["collections", "limit"].includes(key) || !descriptors[key]?.enumerable || !Object.hasOwn(descriptors[key], "value"))) return invalid();
+  let captured = {};
+  if (Object.hasOwn(descriptors, "collections")) {
+    let supplied = descriptors.collections.value;
+    if (!Array.isArray(supplied) || supplied.length < 1 || supplied.length > 16 || Reflect.ownKeys(supplied).length !== supplied.length + 1) return invalid();
+    let collections = [];
+    for (let index = 0; index < supplied.length; index++) {
+      let descriptor2 = Object.getOwnPropertyDescriptor(supplied, String(index));
+      if (!descriptor2?.enumerable || !Object.hasOwn(descriptor2, "value") || !scalarText(descriptor2.value)) return invalid();
+      collections.push(descriptor2.value);
+    }
+    if (new Set(collections).size !== collections.length) return invalid();
+    captured.collections = collections;
+  }
+  if (Object.hasOwn(descriptors, "limit")) {
+    let supplied = descriptors.limit.value;
+    if (!Number.isInteger(supplied) || supplied < 1 || supplied > 100) return invalid();
+    captured.limit = supplied;
+  }
+  return { query, options: captured };
+}
+
+var DATA_REQUEST_LIMIT = 256 * 1024, invalidChange = () => {
+  throw new DataOperationError("invalid_change", !1, "unapplied");
+};
+function mapping(value) {
+  return !value || typeof value != "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)) || Reflect.ownKeys(value).some((key) => typeof key != "string" || !Object.getOwnPropertyDescriptor(value, key)?.enumerable || !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), "value")) ? invalidChange() : value;
+}
+function captureValue(value, ancestors = /* @__PURE__ */ new Set(), depth = 0) {
+  if (value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value)) return value;
+  if (!value || typeof value != "object" || ancestors.has(value) || depth > 32) return invalidChange();
+  ancestors.add(value);
+  try {
+    return Array.isArray(value) ? value.length > 1e5 || Object.keys(value).length !== value.length || Object.getOwnPropertySymbols(value).length ? invalidChange() : Array.from(value, (item) => captureValue(item, ancestors, depth + 1)) : Object.fromEntries(Object.entries(mapping(value)).map(([key, item]) => ["__proto__", "constructor", "prototype"].includes(key) ? invalidChange() : [key, captureValue(item, ancestors, depth + 1)]));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function captureDataDelete(record2) {
+  let identity = mapping(record2);
+  return !validRecordRef(identity.$ref) || typeof identity.$version != "string" || !identity.$version.length || identity.$version.length > 512 ? invalidChange() : { ref: identity.$ref, expectedVersion: identity.$version };
+}
+function captureDataUpdate(record2, set) {
+  let identity = captureDataDelete(record2), fields3 = mapping(set);
+  return !Object.keys(fields3).length || Object.keys(fields3).some((key) => key.startsWith("$") || ["id", "type"].includes(key)) ? invalidChange() : { ...identity, set: captureValue(fields3) };
+}
+function captureDataUpdates(value, allowEmpty = !1) {
+  if (!Array.isArray(value) || !allowEmpty && !value.length || value.length > 1e4) return invalidChange();
+  let updates = value.map((item) => {
+    let row = mapping(item);
+    return Object.keys(row).sort().join(",") !== "expectedVersion,ref,set" ? invalidChange() : captureDataUpdate({ $ref: row.ref, $version: row.expectedVersion }, row.set);
+  });
+  return new Set(updates.map((update) => update.ref)).size !== updates.length ? invalidChange() : updates;
+}
+function captureDataCreate(value) {
+  let row = mapping(value);
+  if (!validRecordRef(row.$ref) || Object.keys(row).some((key) => key.startsWith("$") && !["$ref", "$filing"].includes(key)))
+    return invalidChange();
+  let { $ref: ref, $filing, ...fields3 } = row, filing;
+  if ($filing !== void 0) {
+    let components = mapping($filing);
+    if (Object.entries(components).some(([name, value2]) => !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name) || ["constructor", "prototype"].includes(name) || typeof value2 != "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value2)))
+      return invalidChange();
+    filing = { ...components };
+  }
+  return { ref, fields: captureValue(fields3), ...filing ? { filing } : {} };
+}
+function captureDataChanges(updatesValue, createsValue = [], deletesValue = []) {
+  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();
+    let fields3 = mapping(row.fields);
+    return Object.keys(fields3).some((key) => key.startsWith("$")) ? invalidChange() : captureDataCreate({ ...fields3, $ref: row.ref, ...Object.hasOwn(row, "filing") ? { $filing: row.filing } : {} });
+  });
+  if (!Array.isArray(deletesValue) || deletesValue.length > 1e4) return invalidChange();
+  let deletes = deletesValue.map((item) => {
+    let row = mapping(item);
+    return Object.keys(row).sort().join(",") !== "expectedVersion,ref" ? invalidChange() : captureDataDelete({ $ref: row.ref, $version: row.expectedVersion });
+  }), 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)
+    throw new DataOperationError("request_too_large", !1, "unapplied");
+}
+function dataTransportError(status, value) {
+  let failures2 = {
+    400: ["invalid_query", "invalid_change"],
+    401: ["unauthenticated"],
+    403: ["access_denied"],
+    409: ["conflict", "publication_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(
+    code,
+    ["capacity", "unavailable", "publication_pending"].includes(code),
+    code === "conflict" ? "unapplied" : effect,
+    code === "invalid_change" && typeof row?.component == "string" && /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/.test(row.component) ? row.component : void 0
+  );
+}
+
+var FileOperationError = class extends Error {
+  constructor(code, status, retryable = !1) {
+    super(code);
+    this.code = code;
+    this.status = status;
+    this.retryable = retryable;
+  }
+  code;
+  status;
+  retryable;
+}, FILE_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/, FILE_ORIGINAL_MAX_BYTES = 5 * 1024 ** 3;
+function parseFileDescriptor(value) {
+  let invalid3 = () => {
+    throw new FileOperationError("unavailable", 503, !0);
+  };
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid3();
+  let f = value;
+  if (Object.keys(f).sort().join(",") !== "details,enrichments,id,mediaType,name,path,sha256,size" || typeof f.id != "string" || !FILE_ID_PATTERN.test(f.id) || !safeFileName(f.name) || !safeFilePath(f.path) || !Number.isSafeInteger(f.size) || f.size < 0 || f.size > FILE_ORIGINAL_MAX_BYTES || typeof f.sha256 != "string" || !/^[0-9a-f]{64}$/.test(f.sha256) || !f.enrichments || typeof f.enrichments != "object" || Array.isArray(f.enrichments) || !f.details || typeof f.details != "object" || Array.isArray(f.details)) return invalid3();
+  let d = f.details;
+  if (d.kind === "other") {
+    if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream") return invalid3();
+  } else if (d.kind === "csv") {
+    if (Object.keys(d).sort().join(",") !== "dataRows,delimiter,encoding,headerRow,kind" || f.mediaType !== "text/csv" || !["utf-8", "windows-1252"].includes(d.encoding) || ![",", ";", "	"].includes(d.delimiter) || !Number.isSafeInteger(d.headerRow) || d.headerRow < 1 || !Number.isSafeInteger(d.dataRows) || d.dataRows < 0) return invalid3();
+  } else return invalid3();
+  for (let [name, descriptor2] of Object.entries(f.enrichments)) {
+    if (!safeEnrichmentName(name)) return invalid3();
+    parseEnrichmentDescriptor(descriptor2);
+  }
+  return new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024 ? invalid3() : f;
+}
+function parseEnrichmentDescriptor(value) {
+  let invalid3 = () => {
+    throw new FileOperationError("unavailable", 503, !0);
+  };
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid3();
+  let d = value;
+  return Object.keys(d).sort().join(",") !== "mediaType,sha256,size" || !["application/octet-stream", "text/plain", "text/markdown", "application/json"].includes(d.mediaType) || !Number.isSafeInteger(d.size) || d.size < 0 || d.size > 16 * 1024 * 1024 || typeof d.sha256 != "string" || !/^[0-9a-f]{64}$/.test(d.sha256) ? invalid3() : d;
+}
+function safeEnrichmentName(value) {
+  return safeFileName(value) && !/^original(?:\.|$)/i.test(value);
+}
+function parseFileEnrichMetadata(value, maxBytes) {
+  let invalid3 = () => {
+    throw new FileOperationError("invalid_input", 400);
+  };
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid3();
+  let d = value;
+  if (Object.keys(d).some((key) => !["name", "size", "mediaType", "replace"].includes(key)) || !safeEnrichmentName(d.name) || !Number.isSafeInteger(d.size) || d.size < 0 || d.mediaType !== void 0 && (typeof d.mediaType != "string" || d.mediaType.length > 255 || /[\u0000-\u001f\u007f]/.test(d.mediaType)) || d.replace !== void 0 && (typeof d.replace != "string" || !/^[0-9a-f]{64}$/.test(d.replace))) return invalid3();
+  if (d.size > maxBytes) throw new FileOperationError("request_too_large", 413);
+  return d;
+}
+function safeFileName(value) {
+  return typeof value == "string" && value.length > 0 && value.length <= 255 && value === value.trim() && value !== "." && value !== ".." && !/[\u0000-\u001f\u007f-\u009f/\\:*?"<>|]/u.test(value) && !/[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/.test(value) && !/[. ]$/.test(value) && !/^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(value);
+}
+function safeFilePath(value) {
+  return typeof value == "string" && value.length <= 1024 && value.split("/").every(safeFileName);
+}
+function parseFileCreateMetadata(value, maxBytes) {
+  let invalid3 = () => {
+    throw new FileOperationError("invalid_input", 400);
+  };
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid3();
+  let input = value;
+  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "size", "requestKey"].includes(key))) return invalid3();
+  let path = input.path === void 0 ? "Files" : input.path;
+  if (!safeFileName(input.name) || !safeFilePath(path) || input.storage !== void 0 && input.storage !== "remote" && input.storage !== "local" || !Number.isSafeInteger(input.size) || input.size < 0) return invalid3();
+  if (input.size > maxBytes) throw new FileOperationError("request_too_large", 413);
+  if (typeof input.requestKey != "string" || input.requestKey.length < 1 || input.requestKey.length > 256 || input.requestKey !== input.requestKey.trim() || /[\u0000-\u001f\u007f]/.test(input.requestKey)) return invalid3();
+  let csv;
+  if (input.csv !== void 0) {
+    if (!input.csv || typeof input.csv != "object" || Array.isArray(input.csv)) return invalid3();
+    let hints = input.csv;
+    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key))) return invalid3();
+    let encoding = hints.encoding === void 0 ? "utf-8" : hints.encoding, delimiter = hints.delimiter === void 0 ? "," : hints.delimiter, headerRow = hints.headerRow === void 0 ? 1 : hints.headerRow;
+    if (encoding !== "utf-8" && encoding !== "windows-1252" || ![",", ";", "	"].includes(delimiter) || !Number.isSafeInteger(headerRow) || headerRow < 1 || headerRow > 1e5) return invalid3();
+    csv = { encoding, delimiter, headerRow };
+  }
+  return {
+    name: input.name,
+    path,
+    ...input.storage ? { storage: input.storage } : {},
+    ...csv ? { csv } : {},
+    size: input.size,
+    requestKey: input.requestKey
+  };
+}
+
+var DEFAULT_ORIGIN = "https://auth.oddington.ai";
+function oddingtonOrigin(environment = process.env) {
+  let value = environment.ODDINGTON_OS_ORIGIN ?? DEFAULT_ORIGIN, url = new URL(value);
+  if (url.protocol !== "https:" && url.hostname !== "127.0.0.1")
+    throw new Error("ODDINGTON_OS_ORIGIN must use HTTPS");
+  return url.origin;
+}
+
+var memberContext;
+function installMemberContext(resolve) {
+  return memberContext = resolve, () => {
+    memberContext === resolve && (memberContext = void 0);
+  };
+}
+async function resolveAppContext() {
+  let host = memberContext;
+  if (!host) throw new Error("App context unavailable.");
+  let context2 = await host();
+  if (host !== memberContext || !context2.isCurrent() || context2.expiresAt <= Date.now())
+    throw new Error("App context unavailable.");
+  if (context2.kind !== "local" && (typeof context2.accessToken != "string" || !/^[^\s]{1,8192}$/.test(context2.accessToken)))
+    throw new Error("App context unavailable.");
+  return context2;
+}
+async function resolveDataContext() {
+  try {
+    let host = memberContext;
+    if (host !== void 0) {
+      let context2 = await host();
+      if (host !== memberContext || !context2.isCurrent() || context2.expiresAt <= Date.now()) throw new Error();
+      if (context2.kind === "local") return { local: context2.requestData };
+      if (!context2 || !Number.isFinite(context2.expiresAt) || context2.expiresAt <= Date.now() || typeof context2.accessToken != "string" || !/^[^\s]{1,8192}$/.test(context2.accessToken)) throw new Error();
+      return checked(context2.workspace, context2.endpoint, { authorization: `Bearer ${context2.accessToken}` });
+    }
+    throw new Error();
+  } catch {
+    throw new DataOperationError("context_unavailable");
+  }
+}
+async function resolveFilesContext() {
+  try {
+    let environment = {}, host = memberContext;
+    if (host) {
+      let context2 = await host();
+      if (context2.kind === "local") throw new Error();
+      if (!Number.isFinite(context2.expiresAt) || context2.expiresAt <= Date.now() || typeof context2.accessToken != "string" || !/^[^\s]{1,8192}$/.test(context2.accessToken)) throw new Error();
+      return {
+        ...filesContext(context2.workspace, context2.endpoint, { authorization: `Bearer ${context2.accessToken}` }),
+        isCurrent: context2.isCurrent,
+        local: void 0,
+        localFiles: void 0
+      };
+    }
+    throw new Error();
+  } catch {
+    throw new FileOperationError("unsupported_context", 400);
+  }
+}
+function filesContext(workspace, endpoint, headers) {
+  if (!workspace || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(workspace) || workspace.length > 63 || ["auth", "www", "api", "os"].includes(workspace) || endpoint !== `https://${workspace}.oddington.ai`) throw new Error();
+  return { url: `${endpoint}/api/files`, headers: { ...headers, "x-oddington-workspace": workspace }, isCurrent: () => !0 };
+}
+function checked(workspace, endpoint, headers) {
+  if (!workspace || !/^[a-z0-9][a-z0-9-]{0,127}$/.test(workspace)) throw new Error();
+  let origin = new URL(endpoint);
+  if (origin.protocol !== "https:" || origin.username || origin.password || origin.search || origin.hash || origin.pathname !== "/")
+    throw new Error();
+  return { url: `${origin.origin}/api/data`, headers: { ...headers, "x-oddington-workspace": workspace } };
+}
+
+var data = {
+  repository(repository) {
+    async function send2(input) {
+      let context2 = await resolveDataContext();
+      try {
+        if (checkDataRequestSize({ repository, ...input }), "local" in context2) return await context2.local("data/query", { repository, ...input });
+        let response = await fetch(context2.url, {
+          method: "POST",
+          redirect: "error",
+          cache: "no-store",
+          headers: { "content-type": "application/json", ...context2.headers },
+          body: JSON.stringify({ repository, ...input })
+        }), result2 = await response.json();
+        if (!response.ok)
+          throw dataTransportError(response.status, result2);
+        return result2;
+      } catch (error) {
+        throw error instanceof DataOperationError ? error : new DataOperationError("unavailable", !0);
+      }
+    }
+    return {
+      collections: {
+        list: () => send2({ operation: "collections.list" }),
+        schema: (name) => send2({ operation: "collections.schema", name })
+      },
+      records: {
+        select: (query) => send2({ operation: "records.select", query }),
+        search: (query, options) => {
+          try {
+            return send2({ operation: "records.search", ...captureRecordsSearchInput(query, options) });
+          } catch (error) {
+            return Promise.reject(error);
+          }
+        }
+      },
+      changes() {
+        let updates = [], creates = [], deletes = [], publicationId, pending, confirmed, snapshot = () => {
+          let captured = captureDataChanges(updates, creates, deletes), input = {
+            updates: captured.updates,
+            ...captured.creates.length ? { creates: captured.creates } : {},
+            ...captured.deletes.length ? { deletes: captured.deletes } : {}
+          };
+          return checkDataRequestSize({
+            repository,
+            operation: "changes.publish",
+            ...input,
+            publicationId: publicationId ?? "00000000-0000-4000-8000-000000000000"
+          }), input;
+        };
+        return {
+          create(record2) {
+            if (publicationId) throw new DataOperationError("invalid_change", !1, "unapplied");
+            let next = [...creates, captureDataCreate(record2)];
+            captureDataChanges(updates, next, deletes), checkDataRequestSize({
+              repository,
+              operation: "changes.publish",
+              updates,
+              creates: next,
+              ...deletes.length ? { deletes } : {},
+              publicationId: "00000000-0000-4000-8000-000000000000"
+            }), creates = next;
+          },
+          update(record2, set) {
+            if (publicationId) throw new DataOperationError("invalid_change", !1, "unapplied");
+            let next = [...updates, captureDataUpdate(record2, set)];
+            captureDataChanges(next, creates, deletes), checkDataRequestSize({
+              repository,
+              operation: "changes.publish",
+              updates: next,
+              ...creates.length ? { creates } : {},
+              ...deletes.length ? { deletes } : {},
+              publicationId: "00000000-0000-4000-8000-000000000000"
+            }), updates = next;
+          },
+          delete(record2) {
+            if (publicationId) throw new DataOperationError("invalid_change", !1, "unapplied");
+            let next = [...deletes, captureDataDelete(record2)];
+            captureDataChanges(updates, creates, next), checkDataRequestSize({
+              repository,
+              operation: "changes.publish",
+              updates,
+              deletes: next,
+              ...creates.length ? { creates } : {},
+              publicationId: "00000000-0000-4000-8000-000000000000"
+            }), deletes = next;
+          },
+          async validate() {
+            await send2({ operation: "changes.validate", ...snapshot() });
+          },
+          publish() {
+            if (confirmed) return Promise.resolve(structuredClone(confirmed));
+            if (!pending) {
+              let captured;
+              try {
+                captured = snapshot();
+              } catch (error) {
+                return Promise.reject(error);
+              }
+              publicationId ??= crypto.randomUUID(), pending = send2({ operation: "changes.publish", ...captured, publicationId }).then((result2) => (confirmed = structuredClone(result2), result2)).catch((error) => {
+                throw error instanceof DataOperationError ? new DataOperationError(
+                  error.code,
+                  error.retryable,
+                  error.effect ?? (["unavailable", "publication_pending"].includes(error.code) ? "uncertain" : "unapplied"),
+                  error.component
+                ) : new DataOperationError("unavailable", !0, "uncertain");
+              }).finally(() => {
+                pending = void 0;
+              });
+            }
+            return pending.then((result2) => structuredClone(result2));
+          }
+        };
+      }
+    };
+  }
+};
+
+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, invalid2 = () => new FileOperationError("invalid_input", 400), unavailable = () => new FileOperationError("unavailable", 503, !0), failures = {
+  400: ["invalid_input", "unsupported_context"],
+  401: ["unauthenticated"],
+  403: ["access_denied"],
+  405: ["method_not_allowed"],
+  409: ["conflict", "local_only"],
+  413: ["request_too_large"],
+  429: ["capacity"],
+  503: ["integrity", "unavailable"]
+};
+async function boundedBytes(stream, limit) {
+  if (!stream) return new Uint8Array();
+  let reader = stream.getReader(), bytes = new Uint8Array(limit), size = 0;
+  try {
+    for (; ; ) {
+      let { done, value } = await reader.read();
+      if (done) break;
+      if (!(value instanceof Uint8Array)) throw invalid2();
+      if (size += value.byteLength, size > limit) throw new FileOperationError("request_too_large", 413);
+      bytes.set(value, size - value.byteLength);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return bytes.slice(0, size);
+}
+async function timed(work, parent, timeout = TIMEOUT_MS) {
+  let controller = new AbortController(), timer, abort, expiry = new Promise((_, reject) => {
+    abort = () => {
+      controller.abort(), reject(unavailable());
+    }, timer = setTimeout(abort, timeout), parent?.addEventListener("abort", abort, { once: !0 }), parent?.aborted && abort();
+  });
+  try {
+    return await Promise.race([work(controller.signal), expiry]);
+  } finally {
+    clearTimeout(timer), parent?.removeEventListener("abort", abort);
+  }
+}
+async function result(response, maximum = RESULT_BYTES) {
+  try {
+    let bytes = await boundedBytes(response.body, maximum);
+    return JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(bytes));
+  } catch {
+    throw unavailable();
+  }
+}
+async function hostedContent(url, init2, parent, upstream = fetch) {
+  let delivery = new AbortController(), abort = () => delivery.abort(parent.reason);
+  parent.addEventListener("abort", abort, { once: !0 }), parent.aborted && abort();
+  let detach = () => parent.removeEventListener("abort", abort);
+  try {
+    let response = await upstream(url, { ...init2, signal: delivery.signal });
+    if (delivery.signal.aborted)
+      throw response.body?.cancel().catch(() => {
+      }), unavailable();
+    if (!response.body)
+      return detach(), response;
+    let source = response.body, reader, settled = !1, cancel = async (reason) => {
+      if (!settled) {
+        settled = !0, detach(), delivery.abort(reason);
+        try {
+          await (reader ? reader.cancel(reason) : source.cancel(reason));
+        } catch (error) {
+          if (error !== delivery.signal.reason && !(error instanceof Error && error.name === "AbortError")) throw error;
+        } finally {
+          reader?.releaseLock();
+        }
+      }
+    }, body2 = new ReadableStream({
+      async pull(controller) {
+        try {
+          reader ??= source.getReader();
+          let { done, value } = await reader.read();
+          if (settled) return;
+          done ? (settled = !0, detach(), reader.releaseLock(), controller.close()) : controller.enqueue(value);
+        } catch (error) {
+          if (settled) return;
+          controller.error(error), await cancel(error).catch(() => {
+          });
+        }
+      },
+      cancel
+    }, { highWaterMark: 0 }), wrapped = new Response(body2, { status: response.status, statusText: response.statusText, headers: response.headers });
+    for (let key of ["url", "redirected", "type"])
+      Object.defineProperty(wrapped, key, { value: response[key] });
+    return wrapped;
+  } catch (error) {
+    throw detach(), delivery.abort(error), error;
+  }
+}
+async function send(suffix, init2, descriptor2, initial, parent) {
+  let original = initial, checkCurrent = () => {
+    if (parent?.aborted) throw unavailable();
+    if (!original.isCurrent()) throw new FileOperationError("unsupported_context", 400);
+  };
+  for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
+    checkCurrent();
+    let context2 = await resolveFilesContext();
+    if (checkCurrent(), context2.url !== original.url) throw new FileOperationError("unsupported_context", 400);
+    try {
+      return await (async () => {
+        let response = context2.localFiles ? await context2.localFiles(suffix, init2, parent) : await (async () => {
+          let url = `${context2.url}${suffix}`, request = {
+            ...init2,
+            signal: parent,
+            headers: { ...context2.headers, ...init2.headers },
+            redirect: "error",
+            cache: "no-store"
+          };
+          return descriptor2 ? fetch(url, request) : hostedContent(url, request, parent);
+        })();
+        if (!response.ok) {
+          let value2 = await result(response), error = value2 && typeof value2 == "object" && "error" in value2 ? value2.error : void 0, received = error && typeof error == "object" && "code" in error ? error.code : void 0, code = failures[response.status]?.find((code2) => code2 === received);
+          throw code ? new FileOperationError(code, response.status, code === "capacity" || code === "unavailable") : unavailable();
+        }
+        if (response.status !== 200)
+          throw response.body?.cancel().catch(() => {
+          }), unavailable();
+        try {
+          checkCurrent();
+        } catch (error) {
+          throw response.body?.cancel().catch(() => {
+          }), error;
+        }
+        if (!descriptor2) return response;
+        let value = await result(response, descriptor2 === "control" ? CONTROL_RESULT_BYTES : RESULT_BYTES);
+        if (descriptor2 === "control")
+          return checkCurrent(), value;
+        let parsed;
+        if (descriptor2 === "enrichment") {
+          if (!value || typeof value != "object" || Array.isArray(value)) throw unavailable();
+          let { name, ...metadata } = value;
+          if (!safeEnrichmentName(name)) throw unavailable();
+          parsed = { name, ...parseEnrichmentDescriptor(metadata) };
+        } else parsed = parseFileDescriptor(value);
+        return checkCurrent(), parsed;
+      })();
+    } catch (error) {
+      let failure = error instanceof FileOperationError ? error : unavailable();
+      if (init2.body instanceof ReadableStream || !failure.retryable || attempt + 1 === ATTEMPTS) throw failure;
+    }
+  }
+  throw unavailable();
+}
+function idPath(id2) {
+  if (typeof id2 != "string" || !FILE_ID_PATTERN.test(id2)) throw invalid2();
+  return `/${id2}`;
+}
+async function multipartCreate(input, metadata, exchange, release = () => {
+  active--;
+}, upload) {
+  let route = upload ? `${idPath(upload.file.id)}/upload/multipart` : "/multipart", ticket, reader, chunk, offset = 0, receipts = [], pending = /* @__PURE__ */ new Set(), request = (work, timeout = TIMEOUT_MS) => timed((signal) => {
+    let task = work(signal);
+    return pending.add(task), task.then(() => pending.delete(task), () => pending.delete(task)), task;
+  }, void 0, timeout), control = (body2) => ({
+    method: "POST",
+    headers: { "content-type": "application/json", ...ticket ? { "x-oddington-transfer": ticket } : {} },
+    body: JSON.stringify(body2)
+  });
+  try {
+    let start = await request((signal) => exchange(`${route}/start`, control(upload?.file ?? metadata), "control", signal));
+    if (!start || typeof start != "object" || Array.isArray(start)) throw unavailable();
+    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 unavailable();
+    ticket = session.ticket, input.file instanceof ReadableStream && (reader = input.file.getReader());
+    let lastProgress = Date.now(), next = async () => {
+      try {
+        if (Date.now() - lastProgress >= TIMEOUT_MS) throw unavailable();
+        let value = await request(() => reader.read(), Math.max(1, TIMEOUT_MS - (Date.now() - lastProgress)));
+        return value.value?.byteLength && (lastProgress = Date.now()), value;
+      } catch (error) {
+        throw await reader.cancel(error).catch(() => {
+        }), error;
+      }
+    };
+    for (let sent = 0, partNumber = 1; sent < metadata.size || metadata.size === 0 && partNumber === 1; partNumber++) {
+      let length = Math.min(PART_BYTES, metadata.size - sent), part;
+      if (input.file instanceof Uint8Array) part = input.file.subarray(sent, sent + length).slice();
+      else if (input.file instanceof Blob) {
+        let slice = input.file.slice(sent, sent + length);
+        part = new Uint8Array(await request(() => slice.arrayBuffer()));
+      } else {
+        part = new Uint8Array(length);
+        let filled = 0;
+        for (; filled < length; ) {
+          if (!chunk || offset === chunk.byteLength) {
+            chunk = void 0, offset = 0;
+            let value2 = await next();
+            if (value2.done || !(value2.value instanceof Uint8Array) || (chunk = value2.value, chunk.byteLength > metadata.size - sent - filled)) throw invalid2();
+          }
+          let take = Math.min(length - filled, chunk.byteLength - offset);
+          part.set(chunk.subarray(offset, offset + take), filled), filled += take, offset += take, offset === chunk.byteLength && (chunk = void 0, offset = 0);
+        }
+      }
+      if (part.byteLength !== length) throw invalid2();
+      if (reader && sent + length === metadata.size)
+        for (lastProgress = Date.now(); ; ) {
+          let value2 = await next();
+          if (value2.done) break;
+          if (!(value2.value instanceof Uint8Array) || value2.value.byteLength) throw invalid2();
+        }
+      let value = await request((signal) => exchange(`${route}/part`, {
+        method: "POST",
+        headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket, "x-oddington-part": String(partNumber) },
+        body: part.buffer
+      }, "control", signal));
+      part = void 0;
+      let receipt = value;
+      if (!receipt || typeof receipt != "object" || Object.keys(receipt).sort().join(",") !== "etag,partNumber" || receipt.partNumber !== partNumber || typeof receipt.etag != "string" || !receipt.etag || receipt.etag.length > 256 || /[\u0000-\u001f\u007f]/.test(receipt.etag)) throw unavailable();
+      receipts.push({ partNumber, etag: receipt.etag }), sent += length, lastProgress = Date.now();
+    }
+    if (upload) for (let name of Object.keys(upload.file.enrichments)) {
+      let bytes = await request(() => upload.enrichment(name));
+      if (bytes.byteLength !== upload.file.enrichments[name].size || bytes.byteLength > MAX_BYTES) throw invalid2();
+      await request((signal) => exchange(`${route}/enrichments/${encodeURIComponent(name)}`, {
+        method: "POST",
+        headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket },
+        body: bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength)
+      }, "control", signal));
+    }
+    await upload?.beforeComplete();
+    let completion = control({ parts: receipts });
+    if (new TextEncoder().encode(completion.body).byteLength > 128 * 1024) throw unavailable();
+    return parseFileDescriptor(await request(
+      (signal) => exchange(`${route}/complete`, completion, !0, signal),
+      TIMEOUT_MS + Math.ceil(metadata.size / (1024 * 1024)) * 1e3
+    ));
+  } catch (error) {
+    throw reader && await reader.cancel(error).catch(() => {
+    }), ticket && await request((signal) => exchange(`${route}/abort`, control({}), "control", signal)).catch(() => {
+    }), error instanceof FileOperationError ? error : unavailable();
+  } finally {
+    chunk = void 0, reader?.releaseLock(), pending.size ? Promise.allSettled([...pending]).then(release) : release();
+  }
+}
+async function operation(work, initial, parent) {
+  let context2 = initial ?? await resolveFilesContext();
+  if (active >= MAX_ACTIVE) throw new FileOperationError("capacity", 429, !0);
+  if (active++, context2.localFiles)
+    try {
+      return await work(context2, parent ?? new AbortController().signal);
+    } finally {
+      active--;
+    }
+  return timed(async (signal) => {
+    try {
+      return await work(context2, signal);
+    } finally {
+      active--;
+    }
+  }, parent).catch((error) => {
+    throw error instanceof FileOperationError ? error : unavailable();
+  });
+}
+function contentPath(id2, name) {
+  let path = idPath(id2);
+  if (name === void 0) return `${path}/content`;
+  if (!safeEnrichmentName(name)) throw invalid2();
+  return `${path}/enrichments/${encodeURIComponent(name)}/content`;
+}
+async function read(id2, names) {
+  let context2 = await resolveFilesContext();
+  if (idPath(id2), names === void 0 || typeof names == "string") {
+    let path = contentPath(id2, names);
+    return operation((context3, signal) => send(path, { method: "GET" }, !1, context3, signal), context2);
+  }
+  if (!Array.isArray(names)) throw invalid2();
+  let distinct = [], seen = /* @__PURE__ */ new Set();
+  for (let name of names) {
+    if (typeof name != "string" || !safeEnrichmentName(name)) throw invalid2();
+    if (!seen.has(name)) {
+      if (seen.size === 16) throw invalid2();
+      seen.add(name), distinct.push(name);
+    }
+  }
+  let paths = distinct.map((name) => contentPath(id2, name));
+  return timed(async (parent) => {
+    let responses = {};
+    try {
+      for (let i = 0; i < paths.length; i++) {
+        let response = await operation((context3, signal) => send(paths[i], { method: "GET" }, !1, context3, signal), context2, parent);
+        Object.defineProperty(responses, distinct[i], { value: response, enumerable: !0 });
+      }
+      if (!context2.isCurrent()) throw new FileOperationError("unsupported_context", 400);
+      return responses;
+    } catch (error) {
+      for (let response of Object.values(responses)) response.body?.cancel().catch(() => {
+      });
+      throw error;
+    }
+  });
+}
+var files = {
+  async upload(id2) {
+    return operation(async (context2, signal) => {
+      let file = await send(`${idPath(id2)}/upload`, { method: "POST" }, !0, context2, signal);
+      if (file.id !== id2) throw unavailable();
+      return file;
+    });
+  },
+  async create(input, options) {
+    let context2 = await resolveFilesContext();
+    if (!input || typeof input != "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "size", "path", "name", "storage", "csv"].includes(key)) || options !== void 0 && (!options || typeof options != "object" || Array.isArray(options) || Object.keys(options).some((key) => key !== "requestKey")))
+      throw invalid2();
+    let blob = input.file instanceof Blob, array2 = input.file instanceof Uint8Array, stream = input.file instanceof ReadableStream;
+    if (!blob && !array2 && !stream) throw invalid2();
+    let intrinsic = blob ? input.file.size : array2 ? input.file.byteLength : void 0;
+    if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid2();
+    let name = input.name;
+    name === void 0 && blob && "name" in input.file && typeof input.file.name == "string" && (name = typeof globalThis.File < "u" && input.file instanceof globalThis.File ? input.file.name : input.file.name.split(/[\\/]/).at(-1));
+    let metadata = parseFileCreateMetadata({
+      name,
+      size: intrinsic ?? input.size,
+      path: input.path,
+      storage: input.storage,
+      csv: input.csv,
+      requestKey: options?.requestKey === void 0 ? crypto.randomUUID() : options.requestKey
+    }, FILE_ORIGINAL_MAX_BYTES);
+    if (!context2.local && metadata.storage === "local") throw new FileOperationError("unsupported_context", 400);
+    let header = encodeURIComponent(JSON.stringify(metadata));
+    if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid2();
+    if (active >= MAX_ACTIVE) throw new FileOperationError("capacity", 429, !0);
+    if (active++, context2.localFiles && metadata.size > MAX_BYTES) {
+      let controller = new AbortController(), file = input.file, offset = 0, body2 = file instanceof ReadableStream ? file : file instanceof Blob ? file.stream() : new ReadableStream({
+        pull(controller2) {
+          if (offset === file.byteLength) {
+            controller2.close();
+            return;
+          }
+          let end = Math.min(offset + 256 * 1024, file.byteLength);
+          controller2.enqueue(file.subarray(offset, end)), offset = end;
+        }
+      }, { highWaterMark: 0 });
+      try {
+        return await send("", { method: "POST", headers: {
+          "content-type": "application/octet-stream",
+          "x-oddington-file": header
+        }, body: body2 }, !0, context2, controller.signal);
+      } finally {
+        active--;
+      }
+    }
+    return metadata.size > MAX_BYTES ? multipartCreate(input, metadata, (suffix, init2, kind, signal) => kind === !0 ? send(suffix, init2, !0, context2, signal) : send(suffix, init2, "control", context2, signal)) : timed(async (signal) => {
+      try {
+        let bytes = array2 ? input.file.slice() : await boundedBytes(
+          blob ? input.file.stream() : input.file,
+          metadata.size
+        );
+        if (bytes.byteLength !== metadata.size) throw invalid2();
+        if (signal.aborted) throw unavailable();
+        return await send("", {
+          method: "POST",
+          headers: { "content-type": "application/octet-stream", "x-oddington-file": header },
+          body: bytes.buffer
+        }, !0, context2, signal);
+      } finally {
+        active--;
+      }
+    }).catch((error) => {
+      throw error instanceof FileOperationError ? error : unavailable();
+    });
+  },
+  async enrich(input) {
+    let context2 = await resolveFilesContext();
+    if (!input || typeof input != "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "name", "content", "mediaType", "replace"].includes(key)) || typeof input.content != "string" && !(input.content instanceof Uint8Array)) throw invalid2();
+    let path = `${idPath(input.file)}/enrichments`;
+    if (typeof input.content == "string" ? input.content.length > MAX_BYTES : input.content.byteLength > MAX_BYTES)
+      throw new FileOperationError("request_too_large", 413);
+    return operation(async (context3, signal) => {
+      let bytes;
+      if (typeof input.content == "string") {
+        let buffer = new Uint8Array(Math.min(MAX_BYTES, input.content.length * 3)), encoded = new TextEncoder().encodeInto(input.content, buffer);
+        if (encoded.read !== input.content.length) throw new FileOperationError("request_too_large", 413);
+        bytes = buffer.slice(0, encoded.written);
+      } else bytes = input.content.slice();
+      let metadata = parseFileEnrichMetadata({
+        name: input.name,
+        size: bytes.byteLength,
+        ...input.mediaType === void 0 ? {} : { mediaType: input.mediaType },
+        ...input.replace === void 0 ? {} : { replace: input.replace }
+      }, MAX_BYTES), header = encodeURIComponent(JSON.stringify(metadata));
+      if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid2();
+      let result2 = await send(path, { method: "POST", headers: {
+        "content-type": "application/octet-stream",
+        "x-oddington-enrichment": header
+      }, body: bytes.buffer }, "enrichment", context3, signal);
+      if (result2.name !== metadata.name) throw unavailable();
+      return result2;
+    }, context2);
+  },
+  async get(id2) {
+    return operation((context2, signal) => send(idPath(id2), { method: "GET" }, !0, context2, signal));
+  },
+  read
+};
+
+var sessionKey = "_os.app.session", AppResponseReadError = class extends Error {
+};
+async function appResponse(response, maximum, signal) {
+  if (signal.aborted || !response.body || response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json") throw new Error();
+  let reader = response.body.getReader(), abort = () => {
+    reader.cancel().catch(() => {
+    });
+  };
+  signal.addEventListener("abort", abort, { once: !0 });
+  let bytes = 0, text3 = "", decoder = new TextDecoder("utf-8", { fatal: !0 });
+  try {
+    for (; ; ) {
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch {
+        throw new AppResponseReadError();
+      }
+      if (signal.aborted) throw new Error();
+      if (chunk.done) return JSON.parse(text3 + decoder.decode());
+      if (bytes += chunk.value.byteLength, bytes > maximum)
+        throw abort(), new Error();
+      text3 += decoder.decode(chunk.value, { stream: !0 });
+    }
+  } finally {
+    signal.removeEventListener("abort", abort), reader.releaseLock();
+  }
+}
+function isAppOrigin(value) {
+  try {
+    let url = new URL(value);
+    return url.protocol === "http:" && url.hostname === "127.0.0.1" && !!url.port && url.port !== "0" && url.origin === value;
+  } catch {
+    return !1;
+  }
+}
+function appContext(origin, active2) {
+  let binding, credential, denied = !1, controller = new AbortController(), expiry, invalidate = () => {
+    denied = !0, controller.abort(), clearTimeout(expiry), clearInterval(monitor);
+    try {
+      active2() && globalThis.location.origin === origin && (!credential || globalThis.localStorage.getItem(sessionKey) === credential) && globalThis.localStorage.removeItem(sessionKey);
+    } catch {
+    }
+  }, current2 = () => {
+    try {
+      return !denied && active2() && globalThis.location.origin === origin && globalThis.localStorage.getItem(sessionKey) === credential && (!binding || binding.expiresAt > Date.now());
+    } catch {
+      return !1;
+    }
+  }, monitor = setInterval(() => {
+    credential && !current2() && invalidate();
+  }, 100), dispose = () => {
+    controller.abort(), clearTimeout(expiry), clearInterval(monitor);
+  };
+  async function requestData(operation2, input) {
+    try {
+      if (operation2 !== "data/query" || !current2()) throw new Error();
+      let url = `${origin}/_os/app/data`, response = await fetch(url, {
+        method: "POST",
+        credentials: "omit",
+        redirect: "error",
+        cache: "no-store",
+        referrerPolicy: "no-referrer",
+        signal: controller.signal,
+        headers: { "content-type": "application/json", authorization: `Bearer ${credential}` },
+        body: JSON.stringify(input)
+      });
+      if (!current2() || response.redirected || response.url && response.url !== url) throw new Error();
+      if (response.status === 401 || response.status === 403)
+        throw invalidate(), new DataOperationError("access_denied");
+      let result2 = await appResponse(response, Number.MAX_SAFE_INTEGER, controller.signal);
+      if (!current2()) throw new Error();
+      if (!response.ok) throw dataTransportError(response.status, result2);
+      return result2;
+    } catch (error) {
+      throw error instanceof DataOperationError ? error : !current2() || controller.signal.aborted ? new DataOperationError("context_unavailable") : new DataOperationError("unavailable", !0);
+    }
+  }
+  async function requestRoutine(key, suffix, init2 = {}) {
+    if (!current2())
+      throw invalidate(), new Error("Local app context unavailable.");
+    let url = `${origin}/_os/app/routines/${encodeURIComponent(key)}/${suffix}`, response = await fetch(url, {
+      ...init2,
+      credentials: "omit",
+      redirect: "error",
+      cache: "no-store",
+      referrerPolicy: "no-referrer",
+      signal: controller.signal,
+      headers: { ...init2.body === void 0 ? {} : { "content-type": "application/json" }, authorization: `Bearer ${credential}` }
+    });
+    if (!current2() || response.redirected || response.url && response.url !== url)
+      throw invalidate(), new Error("Local app context unavailable.");
+    return (response.status === 401 || response.status === 403) && invalidate(), response;
+  }
+  return { resolve: async () => {
+    try {
+      if (denied || !active2() || globalThis.location.origin !== origin) throw new Error();
+      let stored = globalThis.localStorage.getItem(sessionKey);
+      if (!stored || !/^[A-Za-z0-9_-]{43}$/.test(stored) || credential && stored !== credential) throw new Error();
+      if (credential = stored, !current2()) throw new Error();
+      let response = await fetch(`${origin}/_os/app/context`, {
+        credentials: "omit",
+        redirect: "error",
+        referrerPolicy: "no-referrer",
+        headers: { authorization: `Bearer ${credential}` },
+        signal: controller.signal
+      });
+      if (!response.ok || response.redirected || response.url && response.url !== `${origin}/_os/app/context` || !response.headers.get("content-type")?.startsWith("application/json")) throw new Error();
+      let value = await appResponse(response, 4096, controller.signal);
+      if (!validBinding(value) || !current2() || value.expiresAt <= Date.now() || value.expiresAt > Date.now() + 6e5 || binding && (value.appId !== binding.appId || value.memberId !== binding.memberId || value.workspace !== binding.workspace || value.expiresAt > binding.expiresAt)) throw new Error();
+      return binding = { ...value }, clearTimeout(expiry), expiry = setTimeout(invalidate, binding.expiresAt - Date.now()), {
+        kind: "local",
+        ...binding,
+        isCurrent: current2,
+        signal: controller.signal,
+        invalidate,
+        requestRoutine,
+        requestData,
+        requestAvailability: (key) => requestRoutine(key, "availability", { method: "GET" })
+      };
+    } catch {
+      throw invalidate(), new Error("Local app context unavailable.");
+    }
+  }, invalidate, dispose };
+}
+function validBinding(value) {
+  if (!value || typeof value != "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "appId,expiresAt,memberId,workspace") return !1;
+  let binding = value;
+  return typeof binding.appId == "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(binding.appId) && typeof binding.workspace == "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(binding.workspace) && typeof binding.memberId == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(binding.memberId) && typeof binding.expiresAt == "number" && Number.isFinite(binding.expiresAt);
+}
+
+var installedDispose;
+function init({ auth }) {
+  installedDispose?.();
+  let endpoint, workspace, localOrigin;
+  try {
+    let url = new URL(globalThis.location.origin);
+    isAppOrigin(globalThis.location.origin) && (localOrigin = url.origin);
+    let slug = url.hostname.endsWith(".oddington.ai") ? url.hostname.slice(0, -13) : "";
+    url.protocol === "https:" && !url.port && !url.username && !url.password && !url.search && !url.hash && url.pathname === "/" && /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(slug) && slug !== "auth" && (endpoint = url.origin, workspace = slug);
+  } catch {
+  }
+  let active2 = !0, revision = 0, person, local = localOrigin ? appContext(localOrigin, () => active2) : void 0, { data: { subscription } } = auth.onAuthStateChange((event2, session) => {
+    let next = session?.user.id ?? null;
+    (event2 === "SIGNED_OUT" || person !== void 0 && next !== person) && (revision++, local?.invalidate()), person = next;
+  }), uninstall = installMemberContext(async () => {
+    if (local) return local.resolve();
+    if (!active2 || !endpoint || !workspace || globalThis.location.origin !== endpoint) throw new Error("Hosted Data context unavailable.");
+    let started = revision, { data: { session }, error } = await auth.getSession();
+    if (!active2 || globalThis.location.origin !== endpoint || started !== revision || error || !session || person !== void 0 && person !== session.user.id)
+      throw new Error("Hosted Data context unavailable.");
+    let expiresAt = (session.expires_at ?? 0) * 1e3;
+    if (!Number.isFinite(expiresAt) || expiresAt <= Date.now() || !session.user.id)
+      throw new Error("Hosted Data context unavailable.");
+    return person = session.user.id, {
+      workspace,
+      endpoint,
+      accessToken: session.access_token,
+      expiresAt,
+      isCurrent: () => active2 && globalThis.location.origin === endpoint && revision === started && person === session.user.id
+    };
+  }), dispose = () => {
+    active2 && (active2 = !1, local?.dispose(), revision++, subscription.unsubscribe(), uninstall(), installedDispose === dispose && (installedDispose = void 0));
+  };
+  installedDispose = dispose;
+}
+var os = { init };
+
+var identifier = /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/, uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, isReason = (value) => value === "authority_unavailable" || value === "execution_unavailable" || value === "invalid_input", AppRoutineError = class extends Error {
+  constructor(reason) {
+    super(reason);
+    this.reason = reason;
+    this.name = "AppRoutineError";
+  }
+  reason;
+};
+function fail3(reason) {
+  throw new AppRoutineError(reason);
+}
+function object3(value) {
+  return !!value && typeof value == "object" && !Array.isArray(value);
+}
+function keys3(value, expected) {
+  return Object.keys(value).sort().join(",") === expected;
+}
+function current(context2) {
+  (!context2.isCurrent() || context2.signal.aborted) && fail3("authority_unavailable");
+}
+async function body(context2, response, maximum) {
+  try {
+    let value = await appResponse(response, maximum, context2.signal);
+    return current(context2), response.ok || (object3(value) && keys3(value, "error") && isReason(value.error) && (value.error === "authority_unavailable" && context2.invalidate(), fail3(value.error)), fail3("authority_unavailable")), value;
+  } catch (error) {
+    if (current(context2), error instanceof AppResponseReadError || error instanceof AppRoutineError) throw error;
+    return fail3("execution_unavailable");
+  }
+}
+function descriptor(value, key) {
+  return (!object3(value) || !keys3(value, "after,key,routine,runId") || value.key !== key || typeof value.runId != "string" || !uuid.test(value.runId) || value.after !== 0 || typeof value.routine != "string" || !identifier.test(value.routine)) && fail3("execution_unavailable"), value;
+}
+function safeValue(value, depth = 0) {
+  return depth > 32 ? !1 : value === null || typeof value == "string" || typeof value == "boolean" ? !0 : typeof value == "number" ? Number.isFinite(value) : Array.isArray(value) ? value.every((item) => safeValue(item, depth + 1)) : object3(value) && Object.entries(value).every(([key, item]) => !["__proto__", "constructor", "prototype"].includes(key) && safeValue(item, depth + 1));
+}
+function event(value, run, steps) {
+  (!object3(value) || value.runId !== run.runId || value.key !== run.key || value.routine !== run.routine || !Number.isSafeInteger(value.sequence) || value.sequence < 1 || new TextEncoder().encode(JSON.stringify(value)).byteLength > 16 * 1024) && fail3("execution_unavailable");
+  let common = "key,routine,runId,sequence,";
+  if (value.type === "started" && keys3(value, common + "type") && value.sequence === 1) return { type: "started" };
+  if (value.type === "step" && typeof value.id == "string" && identifier.test(value.id) && (!steps || steps.includes(value.id)) && keys3(value, "id," + common + (Object.hasOwn(value, "summary") ? "summary,type" : "type")) && (!Object.hasOwn(value, "summary") || safeValue(value.summary)))
+    return {
+      type: "step",
+      id: value.id,
+      ...Object.hasOwn(value, "summary") ? { summary: value.summary } : {}
+    };
+  if (value.type === "finished") {
+    if (value.state === "succeeded" && keys3(value, "key," + (Object.hasOwn(value, "result") ? "result," : "") + "routine,runId,sequence,state,type") && (!Object.hasOwn(value, "result") || safeValue(value.result)))
+      return {
+        type: "finished",
+        state: "succeeded",
+        ...Object.hasOwn(value, "result") ? { result: value.result } : {}
+      };
+    if (value.state === "failed" && value.error === "execution_failed" && keys3(value, "error," + common + "state,type"))
+      return { type: "finished", state: "failed", error: "execution_failed" };
+    if (value.state === "cancelled" && keys3(value, common + "state,type")) return { type: "finished", state: "cancelled" };
+  }
+  return fail3("execution_unavailable");
+}
+async function pause(context2, delay) {
+  current(context2), await new Promise((resolve, reject) => {
+    let abort = () => {
+      clearTimeout(timer), reject(new AppRoutineError("authority_unavailable"));
+    }, timer = setTimeout(() => {
+      context2.signal.removeEventListener("abort", abort), resolve();
+    }, delay);
+    context2.signal.addEventListener("abort", abort, { once: !0 });
+  }), current(context2);
+}
+function handle(context2, run, steps) {
+  return Object.freeze({
+    async *events(...args) {
+      args.length && fail3("invalid_input");
+      let cursor = 0, terminal = !1, delay = 100, retainedBytes = 0, seen = [];
+      for (; !terminal; ) {
+        current(context2);
+        let response;
+        try {
+          response = await context2.requestRoutine(run.key, `runs/${run.runId}/events?after=${cursor}`);
+        } catch {
+          current(context2), await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
+          continue;
+        }
+        if (response.status >= 500) {
+          await response.body?.cancel(), await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
+          continue;
+        }
+        let value;
+        try {
+          value = await body(context2, response, 80 * 1024);
+        } catch (error) {
+          if (!(error instanceof AppResponseReadError)) throw error;
+          await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
+          continue;
+        }
+        (!object3(value) || !keys3(value, "after,events,terminal") || !Array.isArray(value.events) || value.events.length > 256 || typeof value.terminal != "boolean" || !Number.isSafeInteger(value.after)) && fail3("execution_unavailable");
+        let delivery = [];
+        for (let raw of value.events) {
+          let publicEvent = event(raw, run, steps), encoded = JSON.stringify(raw), sequence = raw.sequence;
+          if (sequence <= cursor) {
+            seen[sequence - 1] !== encoded && fail3("execution_unavailable");
+            continue;
+          }
+          (terminal || sequence !== cursor + 1 || sequence > 256 || (cursor === 0 ? publicEvent.type !== "started" : publicEvent.type === "started")) && fail3("execution_unavailable"), retainedBytes += new TextEncoder().encode(encoded).byteLength, retainedBytes > 1024 * 1024 && fail3("execution_unavailable"), seen.push(encoded), cursor = sequence, terminal = publicEvent.type === "finished", delivery.push(publicEvent);
+        }
+        (value.after !== cursor || value.terminal !== terminal) && fail3("execution_unavailable");
+        for (let item of delivery)
+          current(context2), yield item;
+        delay = 100, terminal || await pause(context2, delivery.length ? 100 : 250);
+      }
+    },
+    async cancel(...args) {
+      args.length && fail3("invalid_input");
+      try {
+        let value = await body(context2, await context2.requestRoutine(run.key, `runs/${run.runId}/cancel`, { method: "POST" }), 1024);
+        (!object3(value) || !keys3(value, "cancelled") || value.cancelled !== !0) && fail3("execution_unavailable");
+      } catch (error) {
+        if (current(context2), error instanceof AppRoutineError) throw error;
+        fail3("execution_unavailable");
+      }
+    }
+  });
+}
+async function appRoutineOperation(key, input, recover) {
+  let context2;
+  try {
+    identifier.test(key) || fail3("authority_unavailable");
+    let resolved = await resolveAppContext();
+    if (resolved.kind !== "local" && fail3("execution_unavailable"), context2 = resolved, recover) {
+      let value2 = await body(context2, await context2.requestRoutine(key, "runs"), 16384);
+      (!object3(value2) || !keys3(value2, "runs") || !Array.isArray(value2.runs) || value2.runs.length > 20) && fail3("execution_unavailable");
+      let runs = value2.runs.map((run) => descriptor(run, key));
+      return (new Set(runs.map((run) => run.runId)).size !== runs.length || new Set(runs.map((run) => run.routine)).size > 1) && fail3("execution_unavailable"), runs.map((run) => handle(resolved, run));
+    }
+    let available = await body(context2, await context2.requestAvailability(key), 16 * 1024);
+    object3(available) && keys3(available, "available,reason") && available.available === !1 && isReason(available.reason) && fail3(available.reason), (!object3(available) || !keys3(available, "available,steps") || available.available !== !0 || !Array.isArray(available.steps) || available.steps.length < 1 || available.steps.length > 64 || !available.steps.every((step) => typeof step == "string" && identifier.test(step)) || new Set(available.steps).size !== available.steps.length) && fail3("execution_unavailable");
+    let steps = [...available.steps], encoded;
+    try {
+      encoded = JSON.stringify(input), (encoded === void 0 || new TextEncoder().encode(encoded).byteLength > 16 * 1024) && fail3("invalid_input");
+    } catch {
+      fail3("invalid_input");
+    }
+    let value = await body(context2, await context2.requestRoutine(key, "runs", {
+      method: "POST",
+      body: `{"input":${encoded}}`
+    }), 16 * 1024);
+    return handle(context2, descriptor(value, key), steps);
+  } catch (error) {
+    if (context2 && current(context2), error instanceof AppRoutineError) throw error;
+    return fail3(context2 ? "execution_unavailable" : "authority_unavailable");
+  }
+}
+
+var authorityUnavailable = () => ({ available: !1, reason: "authority_unavailable" }), MAX_RESPONSE_BYTES = 16 * 1024;
+async function availability(key) {
+  try {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/.test(key)) return authorityUnavailable();
+    let context2 = await resolveAppContext();
+    if (context2.kind !== "local") return { available: !1, reason: "execution_unavailable" };
+    let response = await context2.requestAvailability(key);
+    if (!response.ok || response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json")
+      return authorityUnavailable();
+    let value = await appResponse(response, MAX_RESPONSE_BYTES, context2.signal);
+    if (!context2.isCurrent() || !value || typeof value != "object" || Array.isArray(value)) return authorityUnavailable();
+    let result2 = value;
+    return result2.available === !1 && Object.keys(result2).sort().join(",") === "available,reason" && (result2.reason === "authority_unavailable" || result2.reason === "execution_unavailable") ? { available: !1, reason: result2.reason } : result2.available !== !0 || Object.keys(result2).sort().join(",") !== "available,steps" || !Array.isArray(result2.steps) || result2.steps.length < 1 || result2.steps.length > 64 || !result2.steps.every((step) => typeof step == "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/.test(step)) || new Set(result2.steps).size !== result2.steps.length ? authorityUnavailable() : { available: !0, steps: [...result2.steps] };
+  } catch {
+    return authorityUnavailable();
+  }
+}
+var app = Object.freeze({ routines: new Proxy(/* @__PURE__ */ Object.create(null), {
+  get(_target, key) {
+    if (typeof key == "string")
+      return Object.freeze({
+        availability: (...args) => args.length ? Promise.resolve(authorityUnavailable()) : availability(key),
+        run: (...args) => args.length === 1 ? appRoutineOperation(key, args[0], !1) : Promise.reject(new AppRoutineError("invalid_input")),
+        recover: (...args) => args.length === 0 ? appRoutineOperation(key, void 0, !0) : Promise.reject(new AppRoutineError("invalid_input"))
+      });
+  },
+  set: () => !1,
+  defineProperty: () => !1,
+  deleteProperty: () => !1
+}) });
+
+var LIMIT = 16 * 1024, context;
+var appRun = {
+  current() {
+    return context;
+  }
+};
+
+function validateFileAddOptions(value) {
+  let v = serializable(value);
+  if (!v || typeof v != "object" || Array.isArray(v) || Object.keys(v).some((k) => !["path", "name", "csv"].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.csv !== void 0 && validateCsvHints(v.csv), v;
+}
+function validateCsvHints(value) {
+  let v = serializable(value);
+  if (!v || typeof v != "object" || Array.isArray(v) || Object.keys(v).some((k) => !["encoding", "delimiter", "headerRow"].includes(k)) || v.encoding !== void 0 && !["utf-8", "windows-1252"].includes(v.encoding) || v.delimiter !== void 0 && ![",", ";", "	"].includes(v.delimiter) || v.headerRow !== void 0 && (!Number.isSafeInteger(v.headerRow) || v.headerRow < 0))
+    throw new InboxContractError("Invalid CSV parsing hints");
+  return v;
+}
+
+function routinePublicationClient(options = {}) {
+  let environment = {}, local = void 0, workspace = options.workspace ?? environment.ODDINGTON_ROUTINE_WORKSPACE, capability = options.capability ?? environment.ODDINGTON_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.ODDINGTON_INBOX_WORKING_ROOT ?? void 0, headers = capability ? { "x-oddington-run": capability } : {}, request = options.request ?? (capability ? async (path, init2) => {
+    let origin = oddingtonOrigin(), target = new URL(path, `${origin}/`);
+    if (target.origin !== origin || !target.pathname.startsWith(`/api/cli/workspaces/${workspace}/inbox/`))
+      throw new Error("Invalid routine endpoint");
+    return fetch(target, { ...init2, redirect: "error" });
+  } : async () => {
+    throw new Error("Member publication requires a host-supplied request");
+  });
+  async function send2(operation2, body2) {
+    if (local) return await local(operation2, body2);
+    let response = await request(`/api/cli/workspaces/${workspace}/inbox/${operation2}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...headers },
+      body: JSON.stringify(body2)
+    }), result2 = await response.json();
+    if (!response.ok && operation2 === "records/update")
+      throw new RoutineRecordWriteError(result2.error ?? "Could not confirm routine preparation", result2.effect ?? "uncertain");
+    if (!response.ok) throw new Error(result2.error ?? "Could not confirm routine publication");
+    return result2;
+  }
+  let transport = {
+    async publish(body2) {
+      return await send2("publish", body2);
+    },
+    async resolve(body2) {
+      await send2("resolve", body2);
+    }
+  };
+  async function readRecords(input) {
+    return await send2("records/read", validateRecordRead(input));
+  }
+  return {
+    ...createInboxPublisher(transport),
+    readRecords,
+    repository: {
+      readRecords,
+      async writeRecords(input, options2) {
+        if (!capability) throw new Error("A trusted routine launch is required");
+        return await send2("records/update", validateRoutineRecordWrite({ input, requestKey: options2?.requestKey }));
+      },
+      async updateRecords(input, options2) {
+        if (!capability) throw new Error("A trusted routine launch is required");
+        return await send2("records/update", validateRoutineRecordWrite({ input: validateRecordUpdate(input), requestKey: options2?.requestKey }));
+      },
+      async deleteRecords(input, options2) {
+        if (!capability) throw new Error("A trusted routine launch is required");
+        return await send2("records/update", validateRoutineRecordWrite({ input: validateRecordDelete(input), requestKey: options2?.requestKey }));
+      }
+    },
+    files: {
+      async add(value) {
+        let input = validateFileAddOptions(value);
+        if (local) return validateInboxFile(await local("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(body2) {
+      await send2("check", { requestKey: body2.requestKey, item: validatePublication(body2.item) });
+    }
+  };
+}
+export {
+  AirtableOperationError,
+  AppRoutineError,
+  DataOperationError,
+  FileOperationError,
+  InboxContractError,
+  RoutineRecordWriteError,
+  app,
+  appRun,
+  asksBlock,
+  connections,
+  continueAsk,
+  data,
+  defineHandler,
+  fileBlock,
+  files,
+  os,
+  question,
+  recordBlock,
+  recordsBlock,
+  resolveAsk,
+  respond,
+  richTextBlock,
+  routinePublicationClient,
+  selection
+};