@oddington/sdk 0.1.10 → 0.1.12

package/dist/browser.js

@@ -131,8 +131,8 @@ function validateBlock(value) {
     });
     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 };
+  let files3 = array(b.files, "files").map(validateInboxFile);
+  return (!files3.length || new Set(files3.map((file2) => file2.id)).size !== files3.length) && fail("Empty or duplicate files"), { kind: "files", label, files: files3, ...expanded };
 }
 function richTextBlock(value) {
   return validateBlock({ ...value, kind: "rich-text" });
@@ -161,8 +161,8 @@ function validateAuthoredSource(value) {
     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") };
+      let declaration2 = object(option.note, "choice note");
+      keys(declaration2, ["placeholder"], "choice note"), note = { placeholder: text(declaration2.placeholder, "note placeholder") };
     }
     return {
       value: id(option.value, "choice value"),
@@ -208,8 +208,8 @@ function validateRecordSource(value) {
   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") } };
+    let record3 = validateRecordReference(entry.record);
+    return record3.repository !== repository && fail("Suggestion belongs to another repository"), { record: record3, ...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",
@@ -239,7 +239,11 @@ function handlerReference(value) {
 }
 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 });
+  keys(source, ["id", "results", "run"], "handler");
+  let stable = (value2) => typeof value2 == "string" && /^[a-zA-Z0-9][a-zA-Z0-9_./-]{0,127}$/.test(value2);
+  stable(source.id) || fail("Handler ID must be stable");
+  let results = source.results === void 0 ? void 0 : distinctIds(source.results, "handler results", !1);
+  return results && (results.length > 64 || results.some((result2) => !stable(result2))) && fail("Handler results must be stable IDs"), typeof source.run != "function" && fail("Handler requires a run function"), Object.freeze({ id: value.id, ...results === void 0 ? {} : { results: Object.freeze(results.sort()) }, run: value.run });
 }
 function respond(handler, input) {
   return defineHandler(handler), handlerReference({ id: handler.id, input });
@@ -266,7 +270,7 @@ function presentation(source) {
   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)] : [];
+    let targets = block.kind === "record" ? [block.view] : block.kind === "records" ? [block.view, ...block.records.map((record3) => record3.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 };
@@ -375,1163 +379,1404 @@ function validateRecordRead(value) {
   };
 }
 
-var RECORD_WRITE_INPUT_LIMIT = 8 * 1024 * 1024, RoutineRecordWriteError = class extends Error {
-  constructor(message, effect) {
-    super(message);
-    this.effect = effect;
-    this.name = "RoutineRecordWriteError";
+var FileOperationError = class extends Error {
+  constructor(code, status, retryable = !1) {
+    super(code);
+    this.code = code;
+    this.status = status;
+    this.retryable = retryable;
   }
-  effect;
+  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 invalid5 = () => {
+    throw new FileOperationError("unavailable", 503, !0);
+  };
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid5();
+  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 invalid5();
+  let d = f.details;
+  if (d.kind === "other") {
+    if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream") return invalid5();
+  } 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 invalid5();
+  } else if (d.kind === "pdf") {
+    if (f.mediaType !== "application/pdf" || Object.keys(d).some((key) => !["kind", "pages"].includes(key)) || "pages" in d && (!Number.isSafeInteger(d.pages) || d.pages < 1)) return invalid5();
+  } else return invalid5();
+  for (let [name, descriptor2] of Object.entries(f.enrichments)) {
+    if (!safeEnrichmentName(name)) return invalid5();
+    parseEnrichmentDescriptor(descriptor2);
+  }
+  return new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024 ? invalid5() : f;
+}
+function parseEnrichmentDescriptor(value) {
+  let invalid5 = () => {
+    throw new FileOperationError("unavailable", 503, !0);
+  };
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid5();
+  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) ? invalid5() : d;
+}
+function safeEnrichmentName(value) {
+  return safeFileName(value) && !/^original(?:\.|$)/i.test(value);
+}
+function parseFileEnrichMetadata(value, maxBytes) {
+  let invalid5 = () => {
+    throw new FileOperationError("invalid_input", 400);
+  };
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid5();
+  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 invalid5();
+  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 invalid5 = () => {
+    throw new FileOperationError("invalid_input", 400);
+  };
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid5();
+  let input = value;
+  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "inputMediaType", "size", "requestKey"].includes(key))) return invalid5();
+  let path = input.path === void 0 ? "Files" : input.path;
+  if (!safeFileName(input.name) || !safeFilePath(path) || path.split("/")[0].toLowerCase() === ".os" || input.storage !== void 0 && input.storage !== "remote" && input.storage !== "local" || input.inputMediaType !== void 0 && input.inputMediaType !== "application/pdf" || !Number.isSafeInteger(input.size) || input.size < 0) return invalid5();
+  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 invalid5();
+  let csv;
+  if (input.csv !== void 0) {
+    if (!input.csv || typeof input.csv != "object" || Array.isArray(input.csv)) return invalid5();
+    let hints = input.csv;
+    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key))) return invalid5();
+    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 invalid5();
+    csv = { encoding, delimiter, headerRow };
+  }
+  return {
+    name: input.name,
+    path,
+    ...input.storage ? { storage: input.storage } : {},
+    ...input.inputMediaType === "application/pdf" ? { inputMediaType: input.inputMediaType } : {},
+    ...csv ? { csv } : {},
+    size: input.size,
+    requestKey: input.requestKey
+  };
+}
+
+var AppRoutineContractError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+  code;
+}, propertyName = /^[a-z][A-Za-z0-9]*(?![\s\S])/, stepId = /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/, routineName = /^[a-z0-9][a-z0-9-]{0,62}(?![\s\S])/, owns = (value, key) => Object.hasOwn(value, key), invalidContract = () => {
+  throw new AppRoutineContractError("invalid_contract");
+}, invalidValue = () => {
+  throw new AppRoutineContractError("invalid_value");
 };
-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;
+function record(value) {
+  return value !== null && typeof value == "object" && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function fields2(value, required, optional = []) {
+  return required.every((key) => owns(value, key)) && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+}
+function denseArray(value) {
+  return Array.isArray(value) && Object.keys(value).length === value.length && Array.from({ length: value.length }, (_, index) => owns(value, String(index))).every(Boolean);
+}
+function parseAppRoutineContract(value) {
+  let properties = 0;
+  function schema2(value2, depth = 1) {
+    if (depth > 8 || !record(value2)) return invalidContract();
+    switch (value2.type) {
+      case "object": {
+        if (!fields2(value2, ["type", "properties", "additionalProperties"], ["required"]) || value2.additionalProperties !== !1 || !record(value2.properties)) return invalidContract();
+        let entries = Object.entries(value2.properties);
+        if (properties += entries.length, properties > 64 || entries.some(([key]) => !propertyName.test(key))) return invalidContract();
+        let required;
+        if (owns(value2, "required")) {
+          if (!denseArray(value2.required) || value2.required.some((key) => typeof key != "string" || !owns(value2.properties, key)) || new Set(value2.required).size !== value2.required.length) return invalidContract();
+          required = [...value2.required];
+        }
+        return {
+          type: "object",
+          properties: Object.fromEntries(entries.map(([key, child]) => [key, schema2(child, depth + 1)])),
+          ...required === void 0 ? {} : { required },
+          additionalProperties: !1
+        };
+      }
+      case "array":
+        return !fields2(value2, ["type", "items", "maxItems"]) || !Number.isSafeInteger(value2.maxItems) || value2.maxItems < 1 || value2.maxItems > 64 ? invalidContract() : { type: "array", items: schema2(value2.items, depth + 1), maxItems: value2.maxItems };
+      case "boolean":
+      case "file":
+        return fields2(value2, ["type"]) ? { type: value2.type } : invalidContract();
+      case "string":
+        return !fields2(value2, ["type"], ["maxLength"]) || owns(value2, "maxLength") && (!Number.isSafeInteger(value2.maxLength) || value2.maxLength < 0 || value2.maxLength > 4096) ? invalidContract() : { type: "string", ...owns(value2, "maxLength") ? { maxLength: value2.maxLength } : {} };
+      case "integer":
+      case "number": {
+        let validNumber = value2.type === "integer" ? Number.isSafeInteger : Number.isFinite;
+        return !fields2(value2, ["type"], ["minimum", "maximum"]) || owns(value2, "minimum") && !validNumber(value2.minimum) || owns(value2, "maximum") && !validNumber(value2.maximum) || owns(value2, "minimum") && owns(value2, "maximum") && value2.minimum > value2.maximum ? invalidContract() : {
+          type: value2.type,
+          ...owns(value2, "minimum") ? { minimum: value2.minimum } : {},
+          ...owns(value2, "maximum") ? { maximum: value2.maximum } : {}
+        };
+      }
+      default:
+        return invalidContract();
     }
-    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);
+  if (!record(value) || !fields2(value, ["routine", "input", "steps"], ["result"]) || typeof value.routine != "string" || !routineName.test(value.routine) || !denseArray(value.steps) || value.steps.length < 1 || value.steps.length > 64) return invalidContract();
+  let input = schema2(value.input), result2 = owns(value, "result") ? schema2(value.result) : void 0, ids = /* @__PURE__ */ new Set(), steps = value.steps.map((step) => !record(step) || !fields2(step, ["id"], ["summary"]) || typeof step.id != "string" || !stepId.test(step.id) || ids.has(step.id) ? invalidContract() : (ids.add(step.id), { id: step.id, ...owns(step, "summary") ? { summary: schema2(step.summary) } : {} }));
+  return { routine: value.routine, input, steps, ...result2 === void 0 ? {} : { result: result2 } };
 }
-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 jsonData(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (!(value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value))) {
+    if (!record(value) && !denseArray(value) || ancestors.has(value)) return invalidValue();
+    ancestors.add(value);
+    for (let child of Object.values(value)) jsonData(child, ancestors);
+    ancestors.delete(value);
+  }
 }
-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 validateRoutineSchemaValue(schema2, value) {
+  switch (schema2.type) {
+    case "object":
+      if (!record(value) || (schema2.required ?? []).some((key) => !owns(value, key)) || Object.keys(value).some((key) => !owns(schema2.properties, key))) return invalidValue();
+      for (let [key, child] of Object.entries(value)) validateRoutineSchemaValue(schema2.properties[key], child);
+      return;
+    case "array":
+      if (!denseArray(value) || value.length > schema2.maxItems) return invalidValue();
+      for (let child of value) validateRoutineSchemaValue(schema2.items, child);
+      return;
+    case "boolean":
+      return typeof value != "boolean" ? invalidValue() : void 0;
+    case "string":
+      return typeof value != "string" || Array.from(value).length > (schema2.maxLength ?? 4096) ? invalidValue() : void 0;
+    case "integer":
+    case "number":
+      return typeof value != "number" || !(schema2.type === "integer" ? Number.isSafeInteger(value) : Number.isFinite(value)) || schema2.minimum !== void 0 && value < schema2.minimum || schema2.maximum !== void 0 && value > schema2.maximum ? invalidValue() : void 0;
+    case "file":
+      try {
+        jsonData(value), parseFileDescriptor(value);
+      } catch {
+        return invalidValue();
+      }
+  }
 }
-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);
+
+var LIMIT = 256 * 1024, invalid = () => {
+  throw new AppRoutineContractError("invalid_value");
+}, invalidContract2 = () => {
+  throw new AppRoutineContractError("invalid_contract");
+}, empty = { type: "object", properties: {}, required: [], additionalProperties: !1 };
+function freeze(value) {
+  if (value !== null && typeof value == "object") {
+    for (let child of Object.values(value)) freeze(child);
+    Object.freeze(value);
   }
-  return writes.length && validateRecordWrite({ repository: input.repository, records: writes }), deletes.length && validateRecordDelete({ repository: input.repository, records: deletes }), structuredClone(input);
+  return value;
 }
-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 json(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value)) return;
+  if (!value || typeof value != "object" || ancestors.has(value)) return invalid();
+  let array2 = Array.isArray(value);
+  if (!array2 && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return invalid();
+  let keys4 = Reflect.ownKeys(value);
+  if (array2 && (keys4.length !== value.length + 1 || !Array.from({ length: value.length }, (_, index) => Object.hasOwn(value, index)).every(Boolean))) return invalid();
+  ancestors.add(value);
+  for (let key of keys4) {
+    if (array2 && key === "length") continue;
+    if (typeof key != "string") return invalid();
+    let descriptor2 = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor2.enumerable || !Object.hasOwn(descriptor2, "value")) return invalid();
+    json(descriptor2.value, ancestors);
+  }
+  ancestors.delete(value);
 }
-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 capture(schema2, value) {
+  json(value), validateRoutineSchemaValue(schema2, value);
+  let encoded = JSON.stringify(value);
+  return new TextEncoder().encode(encoded).byteLength > LIMIT ? invalid() : freeze(JSON.parse(encoded));
 }
-
-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;
+function declaration(value) {
+  try {
+    json(value);
+  } catch {
+    return invalidContract2();
+  }
+  return freeze(parseAppRoutineContract({ routine: "definition", input: value, steps: [{ id: "inspect" }] }).input);
 }
-
-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;
+var schema = {
+  object(properties) {
+    return declaration({ type: "object", properties, required: Object.keys(properties), additionalProperties: !1 });
+  },
+  array(items, options) {
+    return declaration({ type: "array", items, maxItems: options.maxItems });
+  },
+  string(options = {}) {
+    return declaration({ type: "string", ...options });
+  },
+  integer(options = {}) {
+    return declaration({ type: "integer", ...options });
+  },
+  number(options = {}) {
+    return declaration({ type: "number", ...options });
+  },
+  boolean() {
+    return declaration({ type: "boolean" });
+  }
+}, file = () => declaration({ type: "file" }), definitions = /* @__PURE__ */ new WeakMap(), defineRoutine = (definition) => {
+  if (!definition || typeof definition != "object" || Object.getPrototypeOf(definition) !== Object.prototype || Reflect.ownKeys(definition).some((key) => typeof key != "string" || !["input", "steps", "result", "run"].includes(key) || !Object.getOwnPropertyDescriptor(definition, key).enumerable || !Object.hasOwn(Object.getOwnPropertyDescriptor(definition, key), "value")) || typeof definition.run != "function") return invalidContract2();
+  try {
+    for (let key of ["input", "steps", "result"])
+      definition[key] !== void 0 && json(definition[key]);
+  } catch {
+    return invalidContract2();
+  }
+  if (definition.steps !== void 0 && (!definition.steps || typeof definition.steps != "object" || Array.isArray(definition.steps))) return invalidContract2();
+  let steps = definition.steps === void 0 ? [] : Object.entries(definition.steps).map(([id2, summary]) => ({ id: id2, ...summary === null ? {} : { summary } })), parsed = parseAppRoutineContract({
+    routine: "definition",
+    input: definition.input === void 0 ? empty : definition.input,
+    steps: steps.length ? steps : [{ id: "inspect" }],
+    ...definition.result === void 0 ? {} : { result: definition.result }
+  }), contract = freeze({
+    input: parsed.input,
+    steps: steps.length ? parsed.steps : [],
+    ...parsed.result === void 0 ? {} : { result: parsed.result }
+  }), captured = Object.freeze({
+    ...definition,
+    ...definition.input === void 0 ? {} : { input: contract.input },
+    ...definition.steps === void 0 ? {} : { steps: freeze(Object.fromEntries(contract.steps.map((step) => [step.id, step.summary ?? null]))) },
+    ...definition.result === void 0 ? {} : { result: contract.result },
+    // Only this authored definition is callable; no generic runner is exported.
+    run: (input, os2) => executeRoutineDefinition(captured, input, os2)
+  });
+  return definitions.set(captured, { contract, run: definition.run }), captured;
+};
+function inspectRoutineDefinition(definition) {
+  if (!definition || typeof definition != "object") return invalidContract2();
+  let registered = definitions.get(definition);
+  return registered ? registered.contract : invalidContract2();
+}
+function captureRoutineInput(definition, input) {
+  return capture(inspectRoutineDefinition(definition).input, input);
+}
+async function executeRoutineDefinition(definition, input, runtime) {
+  let captured = captureRoutineInput(definition, input), { contract, run } = definitions.get(definition), active2 = !0, broken = !1, reports = Promise.resolve(), os2 = Object.freeze({
+    ...runtime,
+    run: freeze({ ...runtime.run }),
+    step(id2, ...summary) {
+      if (!active2 || broken || summary.length > 1)
+        return broken = !0, Promise.reject(new AppRoutineContractError("invalid_value"));
+      let value;
+      try {
+        let step = contract.steps.find((step2) => step2.id === id2);
+        if (!step) return invalid();
+        if (step.summary === void 0) {
+          if (summary.length) return invalid();
+        } else value = capture(step.summary, summary[0]);
+      } catch (error) {
+        return broken = !0, Promise.reject(error);
+      }
+      let report = reports.then(() => broken ? invalid() : runtime.step(id2, value));
+      return reports = report.catch(() => {
+        broken = !0;
+      }), report;
+    }
+  });
+  try {
+    let result2 = await run(captured, os2);
+    return active2 = !1, await reports, broken ? invalid() : contract.result !== void 0 ? capture(contract.result, result2) : result2 !== void 0 ? invalid() : void 0;
+  } finally {
+    active2 = !1;
   }
-  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);
+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.receipts = receipts;
-    this.name = "AirtableOperationError";
+    this.component = component;
+    this.name = "DataOperationError";
   }
+  code;
+  retryable;
   effect;
-  receipts;
+  component;
 };
 
-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);
+var invalid2 = () => {
+  throw new DataOperationError("invalid_query");
+}, historyText = (value) => typeof value == "string" && !/[\u0000\uD800-\uDFFF]/u.test(value);
+function historyVersion(value) {
+  return historyText(value) && value.length > 0 && new TextEncoder().encode(value).length <= 1024 && !/[\u0000-\u001f\u007f-\u009f]/.test(value) && !/^[0-9a-f]{40}$/i.test(value);
 }
-function object2(v) {
-  return (!v || typeof v != "object" || Array.isArray(v) || ![null, Object.prototype].includes(Object.getPrototypeOf(v))) && fail2("Invalid Airtable data"), v;
+function historyProperties(value) {
+  if (!value || typeof value != "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return invalid2();
+  let descriptors = Object.getOwnPropertyDescriptors(value);
+  return Reflect.ownKeys(value).some((key) => typeof key != "string" || !descriptors[key]?.enumerable || !Object.hasOwn(descriptors[key], "value")) ? invalid2() : descriptors;
 }
-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");
+var historyCollection = (value) => typeof value == "string" && value.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value), historyCursor = (value) => typeof value == "string" && value.length <= 128 * 1024 && /^history-cursor-v1\.[A-Za-z0-9_-]{1,64}\.[A-Za-z0-9_-]{16}\.[A-Za-z0-9_-]+$/.test(value);
+function historyArray(value) {
+  if (!Array.isArray(value) || Object.getPrototypeOf(value) !== Array.prototype) return invalid2();
+  let descriptors = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(value).length !== value.length + 1) return invalid2();
+  let result2 = [];
+  for (let i = 0; i < value.length; i++) {
+    let descriptor2 = descriptors[i];
+    if (!descriptor2?.enumerable || !Object.hasOwn(descriptor2, "value")) return invalid2();
+    result2.push(descriptor2.value);
+  }
+  return result2;
 }
-function text2(v) {
-  return typeof v == "string" && v.length > 0 && v.length <= 1024;
+function captureOptions(value, changes) {
+  if (value === void 0) return {};
+  let descriptors = historyProperties(value), result2 = {}, allowed = changes ? ["collections", "refs", "from", "through", "limit", "after"] : ["limit", "before"];
+  if (Object.keys(descriptors).some((key) => !allowed.includes(key))) return invalid2();
+  for (let key of allowed) {
+    if (!Object.hasOwn(descriptors, key)) continue;
+    let scalar = descriptors[key].value;
+    if (key === "collections" || key === "refs") {
+      let values = historyArray(scalar);
+      if (!values.length || values.length > (key === "collections" ? 16 : 100) || !values.every(key === "collections" ? historyCollection : validRecordRef) || new Set(values).size !== values.length) return invalid2();
+      result2[key] = values;
+    } else if (key === "limit") {
+      if (!Number.isInteger(scalar) || scalar < 1 || scalar > (changes ? 500 : 100)) return invalid2();
+      result2.limit = scalar;
+    } else {
+      if (!(key === "after" ? historyCursor(scalar) : historyVersion(scalar))) return invalid2();
+      result2[key] = scalar;
+    }
+  }
+  return result2;
 }
-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");
+var captureHistoryListOptions = (value) => captureOptions(value, !1), captureHistoryChangesOptions = (value) => captureOptions(value, !0);
+function captureHistoryInstant(value) {
+  if (!historyText(value) || value.length > 1024) return invalid2();
+  let match = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?([Zz]|([+-])(\d{2}):(\d{2}))$/.exec(value);
+  if (!match) return invalid2();
+  let [year, month, day, hour, minute, second] = match.slice(1, 7).map(Number), days = new Date(Date.UTC(year, month, 0));
+  return days.setUTCFullYear(year), year < 1 || month < 1 || month > 12 || day < 1 || day > days.getUTCDate() || hour > 23 || minute > 59 || second > 59 || Number(match[9] ?? 0) > 23 || Number(match[10] ?? 0) > 59 ? invalid2() : value;
+}
+
+var invalid3 = () => {
+  throw new DataOperationError("invalid_query");
+};
+function captureRecordsSearchInput(query, options) {
+  if (!historyText(query)) return invalid3();
+  let length = [...query.trim()].length;
+  if (length < 1 || length > 256) return invalid3();
+  if (options === void 0) return { query };
+  let descriptors = historyProperties(options);
+  if (Object.keys(descriptors).some((key) => !["collections", "limit"].includes(key))) return invalid3();
+  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 invalid3();
+    let collections = [];
+    for (let index = 0; index < supplied.length; index++) {
+      let descriptor2 = Object.getOwnPropertyDescriptor(supplied, String(index));
+      if (!descriptor2?.enumerable || !Object.hasOwn(descriptor2, "value") || !historyText(descriptor2.value)) return invalid3();
+      collections.push(descriptor2.value);
+    }
+    if (new Set(collections).size !== collections.length) return invalid3();
+    captured.collections = collections;
+  }
+  if (Object.hasOwn(descriptors, "limit")) {
+    let supplied = descriptors.limit.value;
+    if (!Number.isInteger(supplied) || supplied < 1 || supplied > 100) return invalid3();
+    captured.limit = supplied;
+  }
+  return { query, options: captured };
+}
+
+var DATA_REQUEST_LIMIT = 256 * 1024, invalidChange = () => {
+  throw new DataOperationError("invalid_change", !1, "unapplied");
+};
+function mapping(value) {
   try {
-    return serializable(result2);
+    return historyProperties(value), value;
   } catch {
-    return fail2("Invalid Airtable fields");
+    return invalidChange();
   }
 }
-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 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 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 captureDataDelete(record3) {
+  let identity = mapping(record3);
+  return !validRecordRef(identity.$ref) || typeof identity.$version != "string" || !identity.$version.length || identity.$version.length > 512 ? invalidChange() : { ref: identity.$ref, expectedVersion: identity.$version };
 }
-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)
-      }
-    };
-  } };
+function captureDataUpdate(record3, set) {
+  let identity = captureDataDelete(record3), fields4 = mapping(set);
+  return !Object.keys(fields4).length || Object.keys(fields4).some((key) => key.startsWith("$") || ["id", "type"].includes(key)) ? invalidChange() : { ...identity, set: captureValue(fields4) };
 }
-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 }))
+function captureIdentities(value, update, allowEmpty = !0) {
+  if (!Array.isArray(value) || !allowEmpty && !value.length || value.length > 1e4) return invalidChange();
+  let captured = value.map((item) => {
+    let row = mapping(item);
+    if (Object.keys(row).sort().join(",") !== (update ? "expectedVersion,ref,set" : "expectedVersion,ref")) return invalidChange();
+    let identity = { $ref: row.ref, $version: row.expectedVersion };
+    return update ? captureDataUpdate(identity, row.set) : captureDataDelete(identity);
   });
-  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;
+  return new Set(captured.map((item) => item.ref)).size !== captured.length ? invalidChange() : captured;
+}
+function captureDataUpdates(value, allowEmpty = !1) {
+  return captureIdentities(value, !0, allowEmpty);
+}
+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, ...fields4 } = 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 };
   }
-  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");
+  return { ref, fields: captureValue(fields4), ...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 fields4 = mapping(row.fields);
+    return Object.keys(fields4).some((key) => key.startsWith("$")) ? invalidChange() : captureDataCreate({ ...fields4, $ref: row.ref, ...Object.hasOwn(row, "filing") ? { $filing: row.filing } : {} });
+  }), deletes = captureIdentities(deletesValue, !1), refs = [...updates, ...creates, ...deletes].map((item) => item.ref);
+  return !refs.length || refs.length > 1e4 || new Set(refs).size !== refs.length ? invalidChange() : { updates, creates, deletes };
+}
+function checkDataRequestSize(input) {
+  if (new TextEncoder().encode(JSON.stringify(input)).byteLength > DATA_REQUEST_LIMIT)
+    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 AUTH_ORIGIN = "https://auth.oddington.ai";
+function oddingtonOrigin(environment = process.env) {
+  let value = environment.ODDINGTON_OS_ORIGIN ?? AUTH_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() || 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");
   }
-  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 = [];
+}
+async function resolveFilesContext() {
   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));
+    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
+      };
     }
-    if (acknowledged.length !== records.length) throw new Error();
+    throw new Error();
   } catch {
-    throw new AirtableOperationError(
-      "Incomplete Airtable mutation acknowledgment",
-      acknowledged.length ? "partial" : "uncertain",
-      acknowledged.length ? [receipt(acknowledged)] : []
-    );
+    throw new FileOperationError("unsupported_context", 400);
   }
-  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;
+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 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 data = {
+  repository(repository) {
+    async function send2(input) {
+      let context2 = await resolveDataContext();
+      try {
+        let envelope = { repository, ...input };
+        if (checkDataRequestSize(envelope), "local" in context2) return await context2.local("data/query", envelope);
+        let response = await fetch(context2.url, {
+          method: "POST",
+          redirect: "error",
+          cache: "no-store",
+          headers: { "content-type": "application/json", ...context2.headers },
+          body: JSON.stringify(envelope)
+        }), 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: async (query, options) => send2({ operation: "records.search", ...captureRecordsSearchInput(query, options) })
+      },
+      history: {
+        list: async (options) => send2({ operation: "history.list", options: captureHistoryListOptions(options) }),
+        at: async (instant) => send2({ operation: "history.at", instant: captureHistoryInstant(instant) }),
+        changes: async (options) => send2({ operation: "history.changes", options: captureHistoryChangesOptions(options) })
+      },
+      changes() {
+        let updates = [], creates = [], deletes = [], publicationId, pending, confirmed, assertMutable = () => {
+          if (publicationId) throw new DataOperationError("invalid_change", !1, "unapplied");
+        }, snapshot = (nextUpdates = updates, nextCreates = creates, nextDeletes = deletes) => {
+          let { updates: updates2, creates: creates2, deletes: deletes2 } = captureDataChanges(nextUpdates, nextCreates, nextDeletes), input = { updates: updates2, ...creates2.length ? { creates: creates2 } : {}, ...deletes2.length ? { deletes: deletes2 } : {} };
+          return checkDataRequestSize({
+            repository,
+            operation: "changes.publish",
+            ...input,
+            publicationId: publicationId ?? "00000000-0000-4000-8000-000000000000"
+          }), input;
+        };
+        return {
+          create(record3) {
+            assertMutable();
+            let next = [...creates, captureDataCreate(record3)];
+            snapshot(updates, next, deletes), creates = next;
+          },
+          update(record3, set) {
+            assertMutable();
+            let next = [...updates, captureDataUpdate(record3, set)];
+            snapshot(next, creates, deletes), updates = next;
+          },
+          delete(record3) {
+            assertMutable();
+            let next = [...deletes, captureDataDelete(record3)];
+            snapshot(updates, creates, next), 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 connections = /* @__PURE__ */ createConnections(async (name, operation2, input) => {
+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, invalid4 = () => 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 {
-    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);
+    for (; ; ) {
+      let { done, value } = await reader.read();
+      if (done) break;
+      if (!(value instanceof Uint8Array)) throw invalid4();
+      if (size += value.byteLength, size > limit) throw new FileOperationError("request_too_large", 413);
+      bytes.set(value, size - value.byteLength);
     }
-    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";
+  } finally {
+    reader.releaseLock();
   }
-  code;
-  retryable;
-  effect;
-  component;
-};
-
-var invalid = () => {
-  throw new DataOperationError("invalid_query");
-}, historyText = (value) => typeof value == "string" && !/[\u0000\uD800-\uDFFF]/u.test(value);
-function historyVersion(value) {
-  return historyText(value) && value.length > 0 && new TextEncoder().encode(value).length <= 1024 && !/[\u0000-\u001f\u007f-\u009f]/.test(value) && !/^[0-9a-f]{40}$/i.test(value);
-}
-function historyProperties(value) {
-  if (!value || typeof value != "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return invalid();
-  let descriptors = Object.getOwnPropertyDescriptors(value);
-  return Reflect.ownKeys(value).some((key) => typeof key != "string" || !descriptors[key]?.enumerable || !Object.hasOwn(descriptors[key], "value")) ? invalid() : descriptors;
+  return bytes.slice(0, size);
 }
-function captureHistoryListOptions(value) {
-  if (value === void 0) return {};
-  let descriptors = historyProperties(value), result2 = {};
-  if (Object.keys(descriptors).some((key) => !["limit", "before"].includes(key))) return invalid();
-  if (Object.hasOwn(descriptors, "limit")) {
-    let limit = descriptors.limit.value;
-    if (!Number.isInteger(limit) || limit < 1 || limit > 100) return invalid();
-    result2.limit = limit;
+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);
   }
-  if (Object.hasOwn(descriptors, "before")) {
-    let before = descriptors.before.value;
-    if (!historyVersion(before)) return invalid();
-    result2.before = before;
+}
+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();
   }
-  return result2;
 }
-function captureHistoryInstant(value) {
-  if (!historyText(value) || value.length > 1024) return invalid();
-  let match = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?([Zz]|([+-])(\d{2}):(\d{2}))$/.exec(value);
-  if (!match) return invalid();
-  let [year, month, day, hour, minute, second] = match.slice(1, 7).map(Number), days = new Date(Date.UTC(year, month, 0));
-  return days.setUTCFullYear(year), year < 1 || month < 1 || month > 12 || day < 1 || day > days.getUTCDate() || hour > 23 || minute > 59 || second > 59 || Number(match[9] ?? 0) > 23 || Number(match[10] ?? 0) > 59 ? invalid() : value;
+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;
+  }
 }
-
-var invalid2 = () => {
-  throw new DataOperationError("invalid_query");
-};
-function captureRecordsSearchInput(query, options) {
-  if (!historyText(query)) return invalid2();
-  let length = [...query.trim()].length;
-  if (length < 1 || length > 256) return invalid2();
-  if (options === void 0) return { query };
-  let descriptors = historyProperties(options);
-  if (Object.keys(descriptors).some((key) => !["collections", "limit"].includes(key))) return invalid2();
-  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 invalid2();
-    let collections = [];
-    for (let index = 0; index < supplied.length; index++) {
-      let descriptor2 = Object.getOwnPropertyDescriptor(supplied, String(index));
-      if (!descriptor2?.enumerable || !Object.hasOwn(descriptor2, "value") || !historyText(descriptor2.value)) return invalid2();
-      collections.push(descriptor2.value);
+async function send(suffix, init2, descriptor2, initial, parent) {
+  let original = initial, checkCurrent = (context2 = original) => {
+    if (parent?.aborted) throw unavailable();
+    if (!original.isCurrent() || context2.url !== original.url) throw new FileOperationError("unsupported_context", 400);
+  };
+  for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
+    checkCurrent();
+    let context2 = await resolveFilesContext();
+    checkCurrent(context2);
+    try {
+      let response = 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 !== (descriptor2 === 204 ? 204 : 200) || descriptor2 === 204 && response.body !== null)
+        throw response.body?.cancel().catch(() => {
+        }), unavailable();
+      try {
+        checkCurrent();
+      } catch (error) {
+        throw response.body?.cancel().catch(() => {
+        }), error;
+      }
+      if (descriptor2 === 204) return;
+      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;
     }
-    if (new Set(collections).size !== collections.length) return invalid2();
-    captured.collections = collections;
-  }
-  if (Object.hasOwn(descriptors, "limit")) {
-    let supplied = descriptors.limit.value;
-    if (!Number.isInteger(supplied) || supplied < 1 || supplied > 100) return invalid2();
-    captured.limit = supplied;
   }
-  return { query, options: captured };
+  throw unavailable();
 }
-
-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 idPath(id2) {
+  if (typeof id2 != "string" || !FILE_ID_PATTERN.test(id2)) throw invalid4();
+  return `/${id2}`;
 }
-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);
+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 {
-    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)]));
+    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 invalid4();
+          }
+          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 invalid4();
+      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 invalid4();
+        }
+      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 invalid4();
+      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 {
-    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 };
+    chunk = void 0, reader?.releaseLock(), pending.size ? Promise.allSettled([...pending]).then(release) : release();
   }
-  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 } : {} });
+async function operation(work, initial, parent) {
+  let context2 = initial ?? await resolveFilesContext();
+  if (active >= MAX_ACTIVE) throw new FileOperationError("capacity", 429, !0);
+  return active++, timed(async (signal) => {
+    try {
+      return await work(context2, signal);
+    } finally {
+      active--;
+    }
+  }, parent).catch((error) => {
+    throw error instanceof FileOperationError ? error : unavailable();
   });
-  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
-  );
+function contentPath(id2, name) {
+  let path = idPath(id2);
+  if (name === void 0) return `${path}/content`;
+  if (!safeEnrichmentName(name)) throw invalid4();
+  return `${path}/enrichments/${encodeURIComponent(name)}/content`;
 }
-
-var FileOperationError = class extends Error {
-  constructor(code, status, retryable = !1) {
-    super(code);
-    this.code = code;
-    this.status = status;
-    this.retryable = retryable;
+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);
   }
-  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 invalid4 = () => {
-    throw new FileOperationError("unavailable", 503, !0);
-  };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid4();
-  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 invalid4();
-  let d = f.details;
-  if (d.kind === "other") {
-    if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream") return invalid4();
-  } 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 invalid4();
-  } else return invalid4();
-  for (let [name, descriptor2] of Object.entries(f.enrichments)) {
-    if (!safeEnrichmentName(name)) return invalid4();
-    parseEnrichmentDescriptor(descriptor2);
+  if (!Array.isArray(names)) throw invalid4();
+  let distinct = [], seen = /* @__PURE__ */ new Set();
+  for (let name of names) {
+    if (typeof name != "string" || !safeEnrichmentName(name)) throw invalid4();
+    if (!seen.has(name)) {
+      if (seen.size === 16) throw invalid4();
+      seen.add(name), distinct.push(name);
+    }
   }
-  return new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024 ? invalid4() : f;
-}
-function parseEnrichmentDescriptor(value) {
-  let invalid4 = () => {
-    throw new FileOperationError("unavailable", 503, !0);
-  };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid4();
-  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) ? invalid4() : d;
-}
-function safeEnrichmentName(value) {
-  return safeFileName(value) && !/^original(?:\.|$)/i.test(value);
-}
-function parseFileEnrichMetadata(value, maxBytes) {
-  let invalid4 = () => {
-    throw new FileOperationError("invalid_input", 400);
-  };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid4();
-  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 invalid4();
-  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);
+  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;
+    }
+  });
 }
-function safeFilePath(value) {
-  return typeof value == "string" && value.length <= 1024 && value.split("/").every(safeFileName);
+var files = {
+  delete(id2) {
+    return operation((context2, signal) => send(idPath(id2), { method: "DELETE" }, 204, context2, signal));
+  },
+  async upload(id2) {
+    return operation(async (context2, signal) => {
+      let file2 = await send(`${idPath(id2)}/upload`, { method: "POST" }, !0, context2, signal);
+      if (file2.id !== id2) throw unavailable();
+      return file2;
+    });
+  },
+  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 invalid4();
+    let blob = input.file instanceof Blob, array2 = input.file instanceof Uint8Array, stream = input.file instanceof ReadableStream;
+    if (!blob && !array2 && !stream) throw invalid4();
+    let intrinsic = blob ? input.file.size : array2 ? input.file.byteLength : void 0;
+    if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid4();
+    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,
+      ...blob && input.file.type === "application/pdf" ? { inputMediaType: "application/pdf" } : {},
+      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 invalid4();
+    if (active >= MAX_ACTIVE) throw new FileOperationError("capacity", 429, !0);
+    return active++, 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 invalid4();
+        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 invalid4();
+    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 invalid4();
+      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
+};
+
+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;
 }
-function parseFileCreateMetadata(value, maxBytes) {
-  let invalid4 = () => {
-    throw new FileOperationError("invalid_input", 400);
-  };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid4();
-  let input = value;
-  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "size", "requestKey"].includes(key))) return invalid4();
-  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 invalid4();
-  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 invalid4();
-  let csv;
-  if (input.csv !== void 0) {
-    if (!input.csv || typeof input.csv != "object" || Array.isArray(input.csv)) return invalid4();
-    let hints = input.csv;
-    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key))) return invalid4();
-    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 invalid4();
-    csv = { encoding, delimiter, headerRow };
+
+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;
   }
-  return {
-    name: input.name,
-    path,
-    ...input.storage ? { storage: input.storage } : {},
-    ...csv ? { csv } : {},
-    size: input.size,
-    requestKey: input.requestKey
-  };
+  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 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 AirtableOperationError = class extends Error {
+  constructor(message, effect = "unapplied", receipts = []) {
+    super(message);
+    this.effect = effect;
+    this.receipts = receipts;
+    this.name = "AirtableOperationError";
+  }
+  effect;
+  receipts;
+};
 
-var memberContext;
-function installMemberContext(resolve) {
-  return memberContext = resolve, () => {
-    memberContext === resolve && (memberContext = void 0);
-  };
+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);
 }
-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;
+function object2(v) {
+  return (!v || typeof v != "object" || Array.isArray(v) || ![null, Object.prototype].includes(Object.getPrototypeOf(v))) && fail2("Invalid Airtable data"), v;
 }
-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");
-  }
+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");
 }
-async function resolveFilesContext() {
+function text2(v) {
+  return typeof v == "string" && v.length > 0 && v.length <= 1024;
+}
+function fields3(v, nonempty = !1) {
+  let result2 = object2(v);
+  (nonempty && !Object.keys(result2).length || Object.keys(result2).some((k) => !text2(k))) && fail2("Invalid Airtable fields");
   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();
+    return serializable(result2);
   } catch {
-    throw new FileOperationError("unsupported_context", 400);
+    return fail2("Invalid Airtable fields");
   }
 }
-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 record2(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: fields3(r.fields) };
 }
-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 } };
+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]
+  ));
 }
-
-var data = {
-  repository(repository) {
-    async function send2(input) {
-      let context2 = await resolveDataContext();
-      try {
-        let envelope = { repository, ...input };
-        if (checkDataRequestSize(envelope), "local" in context2) return await context2.local("data/query", envelope);
-        let response = await fetch(context2.url, {
-          method: "POST",
-          redirect: "error",
-          cache: "no-store",
-          headers: { "content-type": "application/json", ...context2.headers },
-          body: JSON.stringify(envelope)
-        }), 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);
-      }
-    }
+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 {
-      collections: {
-        list: () => send2({ operation: "collections.list" }),
-        schema: (name) => send2({ operation: "collections.schema", name })
-      },
+      tables: { list: async () => await call("tables.list", {}) },
       records: {
-        select: (query) => send2({ operation: "records.select", query }),
-        search: async (query, options) => send2({ operation: "records.search", ...captureRecordsSearchInput(query, options) })
-      },
-      history: {
-        list: async (options) => send2({ operation: "history.list", options: captureHistoryListOptions(options) }),
-        at: async (instant) => send2({ operation: "history.at", instant: captureHistoryInstant(instant) })
-      },
-      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));
-          }
-        };
+        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)
       }
     };
-  }
-};
-
-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, invalid3 = () => 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;
+  } };
+}
+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 {
-    for (; ; ) {
-      let { done, value } = await reader.read();
-      if (done) break;
-      if (!(value instanceof Uint8Array)) throw invalid3();
-      if (size += value.byteLength, size > limit) throw new FileOperationError("request_too_large", 413);
-      bytes.set(value, size - value.byteLength);
+    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");
     }
-  } finally {
-    reader.releaseLock();
+    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 = record2(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 = record2(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;
   }
-  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();
+  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: fields3(r.fields, !0) };
+    (!recordId(r.id) || ids.has(r.id)) && fail2("Invalid Airtable batch record ID"), ids.add(r.id);
+    let set = kind === "update" ? fields3(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: fields3(r.expected), ...set ? { set } : {} };
   });
-  try {
-    return await Promise.race([work(controller.signal), expiry]);
-  } finally {
-    clearTimeout(timer), parent?.removeEventListener("abort", abort);
+  for (let r of records) {
+    if (!("id" in r)) continue;
+    let current2 = record2(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");
   }
-}
-async function result(response, maximum = RESULT_BYTES) {
+  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 {
-    let bytes = await boundedBytes(response.body, maximum);
-    return JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(bytes));
+    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(record2(r));
+    }
+    if (acknowledged.length !== records.length) throw new Error();
   } catch {
-    throw unavailable();
+    throw new AirtableOperationError(
+      "Incomplete Airtable mutation acknowledgment",
+      acknowledged.length ? "partial" : "uncertain",
+      acknowledged.length ? [receipt(acknowledged)] : []
+    );
   }
+  return { receipt: receipt(acknowledged), ...kind === "delete" ? {} : { records: returned } };
 }
-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;
-  }
+function nextOffset(value, seen) {
+  if (value !== void 0)
+    return (!text2(value) || seen.has(value)) && fail2("Malformed Airtable pagination"), seen.add(value), value;
 }
-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);
+
+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 {
-      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;
-      })();
+      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) {
-      let failure = error instanceof FileOperationError ? error : unavailable();
-      if (init2.body instanceof ReadableStream || !failure.retryable || attempt + 1 === ATTEMPTS) throw failure;
+      throw error instanceof AirtableOperationError ? error : new AirtableOperationError(
+        "Airtable parent acknowledgment unavailable",
+        ["records.create", "records.update", "records.delete"].includes(operation2) ? "uncertain" : "unapplied"
+      );
     }
-  }
-  throw unavailable();
+  });
 }
-function idPath(id2) {
-  if (typeof id2 != "string" || !FILE_ID_PATTERN.test(id2)) throw invalid3();
-  return `/${id2}`;
+
+var observer;
+async function reportLocalRoutineEffect(value) {
+  await observer?.(value);
 }
-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)
-  });
+
+var connections = /* @__PURE__ */ createConnections(async (name, operation2, input) => {
   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 invalid3();
-          }
-          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 invalid3();
-      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 invalid3();
-        }
-      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();
+    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);
     }
-    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 invalid3();
-      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));
+    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();
+    let writing = ["records.create", "records.update", "records.delete"].includes(operation2), captured = serializable(input), result2;
+    try {
+      result2 = await executeAirtableOperation(lease, operation2, captured);
+    } catch (error) {
+      throw writing && error instanceof AirtableOperationError && await reportLocalRoutineEffect({
+        type: "effect",
+        connection: `airtable/${name}`,
+        operation: operation2,
+        input: captured,
+        effect: error.effect,
+        receipts: error.receipts
+      }), error;
     }
-    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
-    ));
+    return writing && await reportLocalRoutineEffect({
+      type: "effect",
+      connection: `airtable/${name}`,
+      operation: operation2,
+      input: captured,
+      effect: "confirmed",
+      receipts: [result2.receipt]
+    }), result2;
   } 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();
+    throw error instanceof AirtableOperationError ? error : new AirtableOperationError("Airtable connection unavailable");
+  }
+});
+
+var LOCAL_ROUTINE_VALUE_BYTES = 256 * 1024;
+
+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);
 }
-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 validateRecordUpdate(value) {
+  let input = validateRecordWrite(value);
+  if (input.records.some((record3) => !("expectedVersion" in record3)))
+    throw new InboxContractError("Record creation is unavailable for this operation");
+  return input;
 }
-function contentPath(id2, name) {
-  let path = idPath(id2);
-  if (name === void 0) return `${path}/content`;
-  if (!safeEnrichmentName(name)) throw invalid3();
-  return `${path}/enrichments/${encodeURIComponent(name)}/content`;
+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((record3) => record3?.ref)).size !== input.records.length)
+    throw new InboxContractError("Invalid record deletion batch");
+  for (let record3 of input.records)
+    if (!record3 || Array.isArray(record3) || typeof record3 != "object" || Object.keys(record3).sort().join(",") !== "expectedVersion,ref" || !validRecordRef(record3.ref) || typeof record3.expectedVersion != "string" || !/^record-v1:[0-9a-f]{64}$/.test(record3.expectedVersion))
+      throw new InboxContractError("Invalid record deletion");
+  return structuredClone(input);
 }
-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 invalid3();
-  let distinct = [], seen = /* @__PURE__ */ new Set();
-  for (let name of names) {
-    if (typeof name != "string" || !safeEnrichmentName(name)) throw invalid3();
-    if (!seen.has(name)) {
-      if (seen.size === 16) throw invalid3();
-      seen.add(name), distinct.push(name);
-    }
+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((record3) => record3?.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 record3 of input.records) {
+    if (!record3 || typeof record3 != "object" || Array.isArray(record3))
+      throw new InboxContractError("Invalid record change");
+    "set" in record3 || "fields" in record3 ? writes.push(record3) : deletes.push(record3);
   }
-  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;
-    }
-  });
+  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));
+}
+
+var sources = /* @__PURE__ */ new WeakMap();
+function registerBrowserAuth(handle2, source) {
+  sources.set(handle2, source);
+}
+function browserAuthSource(handle2) {
+  return sources.get(handle2);
 }
-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 invalid3();
-    let blob = input.file instanceof Blob, array2 = input.file instanceof Uint8Array, stream = input.file instanceof ReadableStream;
-    if (!blob && !array2 && !stream) throw invalid3();
-    let intrinsic = blob ? input.file.size : array2 ? input.file.byteLength : void 0;
-    if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid3();
-    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 invalid3();
-    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 invalid3();
-        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 invalid3();
-    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 invalid3();
-      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", responseChecks = /* @__PURE__ */ new WeakMap(), AppResponseReadError = class extends Error {
 }, AppContextDenied = class extends Error {
@@ -1850,8 +2095,15 @@ function validBinding(value) {
 }
 
 var installedDispose;
-function init({ auth }) {
+function init({ auth: input }) {
   installedDispose?.();
+  let registered = browserAuthSource(input), auth2 = registered ?? input;
+  if (!registered && input && "getState" in input || typeof auth2?.getSession != "function" || typeof auth2?.onAuthStateChange != "function") {
+    installedDispose = installMemberContext(async () => {
+      throw new Error("Hosted Data context unavailable.");
+    });
+    return;
+  }
   let endpoint, workspace, localOrigin;
   try {
     let url = new URL(globalThis.location.origin);
@@ -1860,13 +2112,13 @@ function init({ auth }) {
     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 active2 = !0, revision = 0, person, token, local = localOrigin ? appContext(localOrigin, () => active2) : void 0, { data: { subscription } } = auth2.onAuthStateChange((event2, session) => {
     let next = session?.user.id ?? null;
-    (event2 === "SIGNED_OUT" || person !== void 0 && next !== person) && (revision++, local?.invalidate()), person = next;
+    (event2 === "SIGNED_OUT" || person !== void 0 && next !== person || registered && person !== void 0 && event2 === "SIGNED_IN" && token !== session?.access_token) && (revision++, local?.invalidate()), person = next, token = session?.access_token;
   }), 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();
+    let started = revision, { data: { session }, error } = await auth2.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;
@@ -1886,6 +2138,403 @@ function init({ auth }) {
 }
 var os = { init };
 
+var CLI_CALLBACK = "http://127.0.0.1:53682/oauth/callback";
+function authorizationConfiguration(value) {
+  let setup = value;
+  if (!setup || typeof setup.clientId != "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(setup.clientId) || setup.redirectUri !== CLI_CALLBACK || !Array.isArray(setup.scopes) || setup.scopes.length !== 1 || setup.scopes[0] !== "email") throw new Error("Unavailable");
+  return { clientId: setup.clientId, redirectUri: CLI_CALLBACK, scopes: ["email"] };
+}
+function authorizationDetails(value, id2, setup, userId, account) {
+  let details = value;
+  return !details || details.authorization_id !== id2 || details.redirect_uri !== setup.redirectUri || details.client?.id !== setup.clientId || typeof details.client.name != "string" || !details.client.name.trim() || details.client.name.length > 128 || /[\x00-\x1f\x7f]/.test(details.client.name) || details.user?.id !== userId || details.user.email !== account.email || typeof details.scope != "string" || details.scope.trim() !== "email" ? Object.freeze({ status: "invalid" }) : Object.freeze({
+    status: "consent",
+    clientName: details.client.name.trim(),
+    account,
+    scopes: Object.freeze([...setup.scopes]),
+    callbackAddress: new URL(setup.redirectUri).host
+  });
+}
+function authorizationReturn(value, decision) {
+  let returnUrl = value?.redirect_url;
+  if (typeof returnUrl != "string" || returnUrl.length > 8192 || !returnUrl.startsWith(`${CLI_CALLBACK}?`) || /[\x00-\x20\x7f]/.test(returnUrl)) return Object.freeze({ status: "invalid" });
+  try {
+    let url = new URL(returnUrl);
+    if (url.origin + url.pathname !== CLI_CALLBACK || url.username || url.password || url.hash) return Object.freeze({ status: "invalid" });
+    let parameters = url.searchParams, allowed = ["code", "state", "error", "error_description", "error_uri"];
+    for (let key of parameters.keys())
+      if (!allowed.includes(key) || parameters.getAll(key).length !== 1) return Object.freeze({ status: "invalid" });
+    let code = parameters.get("code"), error = parameters.get("error");
+    return !parameters.get("state") || !!code == !!error || decision === "deny" && !error || decision === "approve" && !code || parameters.has("code") && !code || parameters.has("error") && !error || code && (parameters.has("error_description") || parameters.has("error_uri")) ? Object.freeze({ status: "invalid" }) : Object.freeze({ status: "return", returnUrl });
+  } catch {
+    return Object.freeze({ status: "invalid" });
+  }
+}
+function authorizationFailure(error) {
+  let status = error?.status;
+  return Object.freeze({ status: status === 404 || status === 410 || status === 400 ? "expired" : status === 401 ? "signed_out" : status === 403 || status === 422 ? "invalid" : "unavailable" });
+}
+
+function createBrowserAuth(runtime) {
+  let coordinators = /* @__PURE__ */ new Map();
+  function publish(c, state) {
+    c.state = Object.freeze(state);
+    for (let listener of c.listeners)
+      try {
+        listener(c.state);
+      } catch {
+      }
+  }
+  function notify(c, event2) {
+    for (let listener of c.sessions)
+      try {
+        listener(event2, event2 === "SIGNED_OUT" ? null : c.session);
+      } catch {
+      }
+  }
+  function expire(c) {
+    !c.active || !c.session && c.state.status === "expired" || (c.revision++, c.timer && clearTimeout(c.timer), c.session = null, publish(c, { status: "expired" }), notify(c, "SIGNED_OUT"));
+  }
+  function accept(c, event2, session) {
+    if (!c.active || event2 === "INITIAL_SESSION" && c.state.status !== "initializing" || event2 === "TOKEN_REFRESHED" && !c.session && c.state.status !== "initializing") return;
+    (c.session?.user?.id !== session?.user?.id || event2 === "SIGNED_OUT" || event2 === "SIGNED_IN" && c.session && session?.access_token !== c.session.access_token) && c.revision++, c.timer && clearTimeout(c.timer);
+    let pending = c.state.pending;
+    if (!session) {
+      c.session = null, publish(c, { status: c.state.status === "expired" ? "expired" : "signed_out", ...pending ? { pending } : {} }), notify(c, "SIGNED_OUT");
+      return;
+    }
+    if (!validSession(session)) {
+      c.session = session, expire(c);
+      return;
+    }
+    c.session = session;
+    let email = typeof session.user.email == "string" ? session.user.email.trim() : "", metadata = session.user.user_metadata, displayName = ["name", "full_name", "first_name"].map((key) => metadata?.[key]).find((value) => typeof value == "string" && value.trim());
+    publish(c, { status: "signed_in", account: Object.freeze({ email, displayName: displayName?.trim() || email }), ...pending ? { pending } : {} }), notify(c, event2);
+    let checkExpiry = () => {
+      if (!c.active || !c.session) return;
+      let remaining = c.session.expires_at * 1e3 - Date.now();
+      remaining <= 0 ? expire(c) : c.timer = setTimeout(checkExpiry, Math.min(remaining, 2147483647));
+    };
+    checkExpiry();
+  }
+  function validSession(session) {
+    return typeof session.access_token == "string" && /^[^\s]{1,8192}$/.test(session.access_token) && typeof session.user?.id == "string" && !!session.user.id && Number.isFinite(session.expires_at) && session.expires_at * 1e3 > Date.now();
+  }
+  function createCoordinator(origin) {
+    let c = {
+      state: Object.freeze({ status: "initializing" }),
+      session: null,
+      revision: 0,
+      active: !0,
+      refs: 0,
+      listeners: /* @__PURE__ */ new Set(),
+      sessions: /* @__PURE__ */ new Set(),
+      ready: Promise.resolve()
+    };
+    return c.ready = (async () => {
+      let revision = c.revision;
+      try {
+        if (!allowedOrigin(origin)) throw runtime.failure("unavailable");
+        let response = await fetch(`${origin}/api/auth/browser-configuration`, { method: "GET", credentials: "same-origin", redirect: "error", cache: "no-store" });
+        if (!response.ok) throw runtime.failure("unavailable");
+        let configuration = validateConfiguration(await response.json());
+        if (configuration.authorization && origin !== "https://auth.oddington.ai" && origin !== "http://127.0.0.1:5176") throw runtime.failure("unavailable");
+        if (c.authorization = configuration.authorization, !c.active || globalThis.location?.origin !== origin) return;
+        if (c.provider = await runtime.provider(configuration, {
+          revision: () => c.revision,
+          current: (revision2) => current2(c, origin, revision2),
+          canPersistSession: () => c.active && (c.state.status === "initializing" || !!c.session || c.state.pending === "verify_code"),
+          canAuthorize: (accessToken) => current2(c, origin, c.revision) && !!c.session && c.session.access_token === accessToken && c.state.pending !== "sign_out"
+        }), !c.active || globalThis.location?.origin !== origin) {
+          c.provider.dispose();
+          return;
+        }
+        let subscription = c.provider.onAuthStateChange((event2, session) => {
+          c.state.status === "initializing" && c.state.pending === "sign_out" || accept(c, event2, session);
+        }).data.subscription;
+        c.unsubscribe = () => subscription.unsubscribe();
+        let started = c.revision, { data: data3, error } = await c.provider.getSession();
+        if (!current2(c, origin, started)) return;
+        error ? terminalSessionFailure(error) ? expire(c) : (!c.session || !validSession(c.session)) && publish(c, { status: "unavailable", error: "unavailable" }) : c.state.pending !== "sign_out" && accept(c, "INITIAL_SESSION", data3.session);
+      } catch {
+        current2(c, origin, revision) && publish(c, { status: "unavailable", error: "unavailable" });
+      }
+    })(), c;
+  }
+  function current2(c, origin, revision) {
+    return c.session && !validSession(c.session) && expire(c), c.active && c.revision === revision && globalThis.location?.origin === origin;
+  }
+  return { create() {
+    let origin = globalThis.location?.origin ?? "", c = coordinators.get(origin);
+    c || (c = createCoordinator(origin), coordinators.set(origin, c));
+    let coordinator = c;
+    coordinator.refs++;
+    let active2 = !0, ownedAction, authorizationId, authorizationGeneration = 0, inspected, observers = /* @__PURE__ */ new Set(), sessionObservers = /* @__PURE__ */ new Set(), lastState = coordinator.state, observation = (state) => {
+      lastState = state;
+      for (let listener of observers)
+        try {
+          listener(state);
+        } catch {
+        }
+    };
+    coordinator.listeners.add(observation);
+    let assertActive = () => {
+      if (!active2) throw runtime.failure("disposed");
+    };
+    async function action(kind, work) {
+      if (assertActive(), coordinator.action && kind !== "sign_out" || kind === "sign_out" && coordinator.state.pending === "sign_out") throw runtime.failure("busy");
+      kind === "sign_out" && (coordinator.revision++, notify(coordinator, "SIGNED_OUT"));
+      let marker = {};
+      coordinator.action = marker, ownedAction = marker;
+      let revision = coordinator.revision;
+      publish(coordinator, { ...coordinator.state, error: void 0, pending: kind });
+      try {
+        if (await coordinator.ready, assertActive(), !coordinator.provider || !coordinator.active || globalThis.location?.origin !== origin) throw runtime.failure("unavailable");
+        if (!current2(coordinator, origin, revision) || coordinator.action !== marker || (await work(coordinator.provider), assertActive(), coordinator.action !== marker) || !current2(coordinator, origin, revision) && kind !== "verify_code" && kind !== "sign_out") throw runtime.failure("stale");
+      } catch (error) {
+        let reason = active2 ? current2(coordinator, origin, revision) ? safeReason(error) ?? "unavailable" : "stale" : "disposed";
+        throw active2 && current2(coordinator, origin, revision) && publish(coordinator, { ...coordinator.state, error: reason }), runtime.failure(reason);
+      } finally {
+        coordinator.action === marker && (coordinator.action = void 0, coordinator.active && (publish(coordinator, { ...coordinator.state, pending: void 0 }), kind === "sign_out" && coordinator.session && notify(coordinator, "TOKEN_REFRESHED"))), ownedAction === marker && (ownedAction = void 0);
+      }
+    }
+    async function authorize(kind, id2) {
+      if (!active2) return Object.freeze({ status: "disposed" });
+      if (id2 !== authorizationId && (authorizationId = id2, authorizationGeneration++, inspected = void 0), !id2) return Object.freeze({ status: "missing" });
+      if (typeof id2 != "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(id2)) return Object.freeze({ status: "invalid" });
+      let generation = authorizationGeneration;
+      if (await coordinator.ready, !active2) return Object.freeze({ status: "disposed" });
+      if (generation !== authorizationGeneration) return Object.freeze({ status: "stale" });
+      let revision = coordinator.revision;
+      if (!current2(coordinator, origin, revision)) return Object.freeze({ status: "stale" });
+      if (!coordinator.session || coordinator.state.pending === "sign_out") return Object.freeze({ status: coordinator.state.status === "expired" ? "expired" : coordinator.state.status === "unavailable" ? "unavailable" : "signed_out" });
+      if (!coordinator.authorization || !coordinator.provider) return Object.freeze({ status: "unavailable" });
+      if (coordinator.action) return Object.freeze({ status: "busy" });
+      if (kind !== "get" && (!inspected || inspected.id !== id2 || inspected.revision !== revision)) return Object.freeze({ status: "stale" });
+      if (kind !== "get" && inspected?.result.status !== "consent") return inspected.result;
+      let marker = {};
+      coordinator.action = marker, ownedAction = marker;
+      let requestCurrent = () => active2 && generation === authorizationGeneration && current2(coordinator, origin, revision) && coordinator.action === marker && !!coordinator.session && coordinator.state.pending !== "sign_out", stale = () => Object.freeze({ status: active2 ? "stale" : "disposed" });
+      try {
+        let provider2 = coordinator.provider, response = await provider2.authorization.get(id2, requestCurrent);
+        if (!requestCurrent()) return stale();
+        if (response.error) {
+          inspected = void 0;
+          let failure = authorizationFailure(response.error);
+          return failure.status === "signed_out" && expire(coordinator), failure;
+        }
+        let account = coordinator.state.account, result2 = response.data && typeof response.data == "object" && "redirect_url" in response.data ? authorizationReturn(response.data) : authorizationDetails(response.data, id2, coordinator.authorization, coordinator.session.user.id, account);
+        if (inspected = { id: id2, revision, result: result2 }, kind === "get" || result2.status !== "consent") return result2;
+        if (!requestCurrent()) return stale();
+        let decision = await provider2.authorization[kind](id2, requestCurrent);
+        if (!requestCurrent()) return stale();
+        let returned = decision.error ? authorizationFailure(decision.error) : authorizationReturn(decision.data, kind);
+        return returned.status === "signed_out" && expire(coordinator), inspected = { id: id2, revision, result: returned }, returned;
+      } catch (error) {
+        return !requestCurrent() || (inspected = void 0, safeReason(error) === "stale") ? stale() : Object.freeze({ status: "unavailable" });
+      } finally {
+        coordinator.action === marker && (coordinator.action = void 0), ownedAction === marker && (ownedAction = void 0);
+      }
+    }
+    let handle2 = Object.freeze({
+      authorization: Object.freeze({
+        get: (id2) => authorize("get", id2),
+        approve: (id2) => authorize("approve", id2),
+        deny: (id2) => authorize("deny", id2)
+      }),
+      getState() {
+        return active2 && coordinator.session && !validSession(coordinator.session) && expire(coordinator), lastState;
+      },
+      subscribe(listener) {
+        return assertActive(), observers.add(listener), () => {
+          observers.delete(listener);
+        };
+      },
+      async sendCode(email) {
+        if (assertActive(), !validEmail(email)) throw runtime.failure("invalid_input");
+        await action("send_code", async (provider2) => {
+          let { error } = await provider2.signInWithOtp({ email: email.trim(), options: { shouldCreateUser: !1 } });
+          if (error && !accountRefusal(error)) throw runtime.failure("unavailable");
+        });
+      },
+      async verifyCode(email, code) {
+        if (assertActive(), !validEmail(email) || typeof code != "string" || !/^\d{6}$/.test(code)) throw runtime.failure("invalid_input");
+        await action("verify_code", async (provider2) => {
+          let revision = coordinator.revision, { data: data3, error } = await provider2.verifyOtp({ email: email.trim(), token: code, type: "email" });
+          if (error) throw runtime.failure(accountRefusal(error) ? "invalid_code" : "unavailable");
+          if (!data3.session || !validSession(data3.session)) throw runtime.failure("invalid_code");
+          if (!current2(coordinator, origin, revision) && (coordinator.session?.access_token !== data3.session.access_token || coordinator.revision !== revision + 1 || coordinator.state.pending !== "verify_code")) throw runtime.failure("stale");
+          accept(coordinator, "SIGNED_IN", data3.session);
+        });
+      },
+      async signOut() {
+        assertActive(), await action("sign_out", async (provider2) => {
+          let revision = coordinator.revision, { error } = await provider2.signOut({ scope: "local" });
+          if (error) throw runtime.failure("unavailable");
+          if (!current2(coordinator, origin, revision) && coordinator.session) throw runtime.failure("stale");
+          accept(coordinator, "SIGNED_OUT", null);
+        });
+      },
+      dispose() {
+        if (active2) {
+          active2 = !1, authorizationGeneration++, inspected = void 0, ownedAction && coordinator.action === ownedAction && coordinator.revision++, observers.clear(), coordinator.listeners.delete(observation);
+          for (let listener of sessionObservers)
+            coordinator.sessions.delete(listener), listener("SIGNED_OUT", null);
+          sessionObservers.clear(), --coordinator.refs === 0 && (coordinator.active = !1, coordinator.revision++, coordinator.timer && clearTimeout(coordinator.timer), coordinator.unsubscribe?.(), coordinator.provider?.dispose(), coordinator.provider = void 0, coordinator.session = null, coordinator.listeners.clear(), coordinator.sessions.clear(), coordinators.delete(origin));
+        }
+      }
+    });
+    return registerBrowserAuth(handle2, {
+      async getSession() {
+        assertActive(), await coordinator.ready, assertActive();
+        let revision = coordinator.revision;
+        if (!current2(coordinator, origin, revision) || !coordinator.provider || !coordinator.session || coordinator.state.pending === "sign_out") return { data: { session: null }, error: null };
+        let result2;
+        try {
+          result2 = await coordinator.provider.getSession();
+        } catch {
+          result2 = { data: { session: null }, error: runtime.failure("unavailable") };
+        }
+        return !active2 || !current2(coordinator, origin, revision) ? { data: { session: null }, error: runtime.failure("stale") } : result2.error ? !terminalSessionFailure(result2.error) && coordinator.session && validSession(coordinator.session) ? { data: { session: coordinator.session }, error: null } : (expire(coordinator), { data: { session: null }, error: runtime.failure("unavailable") }) : (accept(coordinator, "TOKEN_REFRESHED", result2.data.session), { data: { session: coordinator.session }, error: null });
+      },
+      onAuthStateChange(callback) {
+        if (!active2)
+          return callback("SIGNED_OUT", null), { data: { subscription: { unsubscribe() {
+          } } } };
+        let listener = (event2, session) => callback(event2, session);
+        return coordinator.sessions.add(listener), sessionObservers.add(listener), callback("INITIAL_SESSION", coordinator.session), { data: { subscription: { unsubscribe() {
+          coordinator.sessions.delete(listener), sessionObservers.delete(listener);
+        } } } };
+      }
+    }), handle2;
+  } };
+}
+function safeReason(error) {
+  let reason = error?.reason;
+  return ["invalid_input", "invalid_code", "unavailable", "busy", "stale", "disposed"].includes(reason) ? reason : void 0;
+}
+function accountRefusal(error) {
+  return [400, 401, 403, 404, 422].includes(error?.status ?? 0);
+}
+function terminalSessionFailure(error) {
+  return [400, 401, 403, 404, 422].includes(error?.status ?? 0);
+}
+function validEmail(email) {
+  return typeof email == "string" && email.length <= 320 && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email.trim());
+}
+function allowedOrigin(origin) {
+  if (origin === "http://127.0.0.1:5176" || origin === "https://auth.oddington.ai") return !0;
+  try {
+    let url = new URL(origin), slug = url.hostname.endsWith(".oddington.ai") ? url.hostname.slice(0, -13) : "";
+    return slug.length <= 63 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug) && !["auth", "api", "os", "www"].includes(slug) && origin === `https://${slug}.oddington.ai`;
+  } catch {
+    return !1;
+  }
+}
+function validateConfiguration(value) {
+  let configuration = value;
+  if (!configuration || typeof configuration.providerUrl != "string" || typeof configuration.publishableKey != "string") throw new Error("Unavailable");
+  let url = new URL(configuration.providerUrl);
+  if (url.origin !== configuration.providerUrl || url.protocol !== "https:" || url.username || url.password || url.port || !configuration.publishableKey) throw new Error("Unavailable");
+  return {
+    providerUrl: url.origin,
+    publishableKey: configuration.publishableKey,
+    ...configuration.authorization === void 0 ? {} : { authorization: authorizationConfiguration(configuration.authorization) }
+  };
+}
+
+var BrowserAuthError = class extends Error {
+  constructor(reason) {
+    super(`Browser authentication failed: ${reason}`);
+    this.reason = reason;
+    this.name = "BrowserAuthError";
+  }
+  reason;
+};
+async function provider(configuration, guard) {
+  let { AuthClient } = await import("./auth-provider.js");
+  if (!guard.current(guard.revision())) throw new BrowserAuthError("stale");
+  let provenance = /* @__PURE__ */ new Map(), removalRevision, authorizationRequest, authorizationQueue = Promise.resolve(), storage = globalThis.localStorage, client = new AuthClient({
+    url: `${configuration.providerUrl}/auth/v1`,
+    headers: { apikey: configuration.publishableKey, Authorization: `Bearer ${configuration.publishableKey}` },
+    storageKey: `sb-${new URL(configuration.providerUrl).hostname.split(".")[0]}-auth-token`,
+    persistSession: !0,
+    autoRefreshToken: !0,
+    detectSessionInUrl: !1,
+    storage: {
+      getItem: (key) => storage.getItem(key),
+      removeItem(key) {
+        if (!guard.current(removalRevision ?? guard.revision())) throw new BrowserAuthError("stale");
+        storage.removeItem(key);
+      },
+      setItem(key, value) {
+        let token = JSON.parse(value).access_token, revision = token ? provenance.get(token) : void 0;
+        if (!guard.current(revision ?? guard.revision()) || token && !guard.canPersistSession()) throw new BrowserAuthError("stale");
+        storage.setItem(key, value);
+      }
+    },
+    fetch: Object.assign(async (input, init2) => {
+      let revision = guard.revision(), request = String(input).startsWith(`${configuration.providerUrl}/auth/v1/oauth/authorizations/`) ? authorizationRequest : void 0, rejectStale = () => {
+        throw request && (request.rejected = !0), new BrowserAuthError("stale");
+      };
+      request && (!request.current() || !guard.canAuthorize(new Headers(init2?.headers).get("authorization")?.replace(/^Bearer /, "") ?? "")) && rejectStale();
+      let response = await fetch(input, { ...init2, redirect: "error" }), body2 = await response.arrayBuffer();
+      (!guard.current(revision) || request && !request.current()) && rejectStale();
+      let result2 = new Response(
+        [204, 205, 304].includes(response.status) ? null : body2,
+        { status: response.status, statusText: response.statusText, headers: response.headers }
+      ), json2 = result2.json.bind(result2);
+      return result2.json = async () => {
+        let value = await json2();
+        return (!guard.current(revision) || request && !request.current()) && rejectStale(), value && typeof value.access_token == "string" && provenance.set(value.access_token, revision), value;
+      }, result2;
+    }, { preconnect: fetch.preconnect })
+  });
+  async function authorization(kind, id2, current2) {
+    let previous = authorizationQueue, release;
+    authorizationQueue = new Promise((resolve) => {
+      release = resolve;
+    }), await previous;
+    let request = { current: current2, rejected: !1 };
+    authorizationRequest = request;
+    try {
+      if (!current2()) throw new BrowserAuthError("stale");
+      let result2 = await (kind === "get" ? client.oauth.getAuthorizationDetails(id2) : kind === "approve" ? client.oauth.approveAuthorization(id2, { skipBrowserRedirect: !0 }) : client.oauth.denyAuthorization(id2, { skipBrowserRedirect: !0 }));
+      if (request.rejected || !current2()) throw new BrowserAuthError("stale");
+      return result2;
+    } catch (error) {
+      throw request.rejected || !current2() ? new BrowserAuthError("stale") : error;
+    } finally {
+      authorizationRequest = void 0, release();
+    }
+  }
+  return {
+    authorization: {
+      get: (id2, current2) => authorization("get", id2, current2),
+      approve: (id2, current2) => authorization("approve", id2, current2),
+      deny: (id2, current2) => authorization("deny", id2, current2)
+    },
+    getSession: () => client.getSession(),
+    onAuthStateChange: (callback) => client.onAuthStateChange((event2, session) => {
+      let revision = session ? provenance.get(session.access_token) : void 0;
+      revision !== void 0 && !guard.current(revision) || (callback(event2, session), session && provenance.delete(session.access_token));
+    }),
+    signInWithOtp: (input) => client.signInWithOtp(input),
+    verifyOtp: (input) => client.verifyOtp(input),
+    async signOut(input) {
+      removalRevision = guard.revision();
+      try {
+        return await client.signOut(input);
+      } finally {
+        removalRevision = void 0;
+      }
+    },
+    dispose() {
+      provenance.clear(), client.dispose();
+    }
+  };
+}
+var auth = /* @__PURE__ */ createBrowserAuth({ provider, failure: (reason) => new BrowserAuthError(reason) });
+
 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);
@@ -2069,7 +2718,7 @@ var app = Object.freeze({ routines: new Proxy(/* @__PURE__ */ Object.create(null
   deleteProperty: () => !1
 }) });
 
-var LIMIT = 16 * 1024, context;
+var LIMIT2 = 16 * 1024, context;
 var appRun = {
   current() {
     return context;
@@ -2090,7 +2739,7 @@ function validateCsvHints(value) {
   return v;
 }
 
-function routinePublicationClient(options = {}) {
+function routinePublicationClient2(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");
@@ -2158,6 +2807,7 @@ function routinePublicationClient(options = {}) {
 export {
   AirtableOperationError,
   AppRoutineError,
+  BrowserAuthError,
   DataOperationError,
   FileOperationError,
   InboxContractError,
@@ -2165,10 +2815,13 @@ export {
   app,
   appRun,
   asksBlock,
+  auth,
   connections,
   continueAsk,
   data,
   defineHandler,
+  defineRoutine,
+  file,
   fileBlock,
   files,
   os,
@@ -2178,6 +2831,7 @@ export {
   resolveAsk,
   respond,
   richTextBlock,
-  routinePublicationClient,
+  routinePublicationClient2 as routinePublicationClient,
+  schema,
   selection
 };