@oddington/sdk 0.1.22 → 0.1.24

package/dist/browser.js

@@ -285,7 +285,7 @@ function validatePublication(value) {
     "views",
     "body",
     "notifyImmediately",
-    ...source.kind === "ask" ? ["questions"] : []
+    ...source.kind === "ask" ? ["questions", "tags", "recordRefs"] : []
   ], "publication"), source.notifyImmediately !== void 0 && typeof source.notifyImmediately != "boolean" && fail("notifyImmediately must be a boolean");
   let itemPresentation = { ...presentation(source), ...source.notifyImmediately === void 0 ? {} : { notifyImmediately: source.notifyImmediately } }, linkedAsks = (itemPresentation.body ?? []).flatMap((block2) => block2.kind === "asks" ? block2.asks : []);
   if (new Set(linkedAsks).size !== linkedAsks.length && fail("Ask belongs to more than one problem"), source.kind === "digest") return {
@@ -297,10 +297,24 @@ function validatePublication(value) {
   let questions = array(source.questions === void 0 ? [] : source.questions, "questions").map((value2) => question(value2));
   new Set(questions.map((entry) => entry.id)).size !== questions.length && fail("Duplicate question ID");
   let extra = source.recipients === void 0 ? [] : distinctPeople(source.recipients, "recipients", !1);
-  return !questions.length && !extra.length && fail("Ask requires at least one recipient"), {
+  !questions.length && !extra.length && fail("Ask requires at least one recipient");
+  let tags = array(source.tags === void 0 ? [] : source.tags, "Ask tags").map((value2) => {
+    let tag = text(value2, "Ask tag");
+    return new TextEncoder().encode(tag).byteLength > 64 && fail("Ask tag exceeds 64 UTF-8 bytes"), tag;
+  });
+  (tags.length > 32 || new Set(tags).size !== tags.length) && fail("Ask tags exceed bounds or contain duplicates");
+  let recordRefs = array(source.recordRefs === void 0 ? [] : source.recordRefs, "Ask Record references").map((value2) => {
+    let row = object(value2, "Ask Record reference");
+    keys(row, ["repository", "id"], "Ask Record reference");
+    let { repository, ref } = validateRecordReference({ repository: row.repository, ref: row.id });
+    return { repository, id: ref };
+  });
+  return new Set(recordRefs.map((ref) => JSON.stringify([ref.repository, ref.id]))).size !== recordRefs.length && fail("Ask Record references contain duplicates"), {
     kind: "ask",
     ...itemPresentation,
     questions,
+    tags,
+    recordRefs,
     recipients: [.../* @__PURE__ */ new Set([...extra, ...questions.flatMap((entry) => [entry.to, ...entry.allowedResponders])])]
   };
 }
@@ -335,7 +349,7 @@ function createInboxPublisher(transport) {
   return {
     async publishAsk(value, options) {
       let source = object(value, "ask");
-      keys(source, ["title", "description", "recipients", "views", "body", "questions", "notifyImmediately"], "ask");
+      keys(source, ["title", "description", "recipients", "views", "body", "questions", "notifyImmediately", "tags", "recordRefs"], "ask");
       let result2 = await transport.publish({
         requestKey: publicationRequestKey(options),
         item: validatePublication({ ...source, kind: "ask" })
@@ -391,44 +405,44 @@ var FileOperationError = class extends Error {
   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 invalid7 = () => {
+  let invalid8 = () => {
     throw new FileOperationError("unavailable", 503, !0);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid8();
   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 invalid7();
+  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 invalid8();
   let d = f.details;
   if (d.kind === "other") {
-    if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream") return invalid7();
+    if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream") return invalid8();
   } 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 invalid7();
+    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 invalid8();
   } 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 invalid7();
-  } else return invalid7();
+    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 invalid8();
+  } else return invalid8();
   for (let [name, descriptor] of Object.entries(f.enrichments)) {
-    if (!safeEnrichmentName(name)) return invalid7();
+    if (!safeEnrichmentName(name)) return invalid8();
     parseEnrichmentDescriptor(descriptor);
   }
-  return new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024 ? invalid7() : f;
+  return new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024 ? invalid8() : f;
 }
 function parseEnrichmentDescriptor(value) {
-  let invalid7 = () => {
+  let invalid8 = () => {
     throw new FileOperationError("unavailable", 503, !0);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid8();
   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) ? invalid7() : d;
+  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) ? invalid8() : d;
 }
 function safeEnrichmentName(value) {
   return safeFileName(value) && !/^original(?:\.|$)/i.test(value);
 }
 function parseFileEnrichMetadata(value, maxBytes) {
-  let invalid7 = () => {
+  let invalid8 = () => {
     throw new FileOperationError("invalid_input", 400);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid8();
   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 invalid7();
+  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 invalid8();
   if (d.size > maxBytes) throw new FileOperationError("request_too_large", 413);
   return d;
 }
@@ -439,23 +453,23 @@ function safeFilePath(value) {
   return typeof value == "string" && value.length <= 1024 && value.split("/").every(safeFileName);
 }
 function parseFileCreateMetadata(value, maxBytes) {
-  let invalid7 = () => {
+  let invalid8 = () => {
     throw new FileOperationError("invalid_input", 400);
   };
-  if (!value || typeof value != "object" || Array.isArray(value)) return invalid7();
+  if (!value || typeof value != "object" || Array.isArray(value)) return invalid8();
   let input = value;
-  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "inputMediaType", "size", "requestKey"].includes(key))) return invalid7();
+  if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "inputMediaType", "size", "requestKey"].includes(key))) return invalid8();
   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 invalid7();
+  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 invalid8();
   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 invalid7();
+  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 invalid8();
   let csv;
   if (input.csv !== void 0) {
-    if (!input.csv || typeof input.csv != "object" || Array.isArray(input.csv)) return invalid7();
+    if (!input.csv || typeof input.csv != "object" || Array.isArray(input.csv)) return invalid8();
     let hints = input.csv;
-    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key))) return invalid7();
+    if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key))) return invalid8();
     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 invalid7();
+    if (encoding !== "utf-8" && encoding !== "windows-1252" || ![",", ";", "	"].includes(delimiter) || !Number.isSafeInteger(headerRow) || headerRow < 1 || headerRow > 1e5) return invalid8();
     csv = { encoding, delimiter, headerRow };
   }
   return {
@@ -517,8 +531,9 @@ function parseAppRoutineContract(value) {
       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 "file":
+        return !fields2(value2, ["type"], ["storage"]) || owns(value2, "storage") && value2.storage !== "local" && value2.storage !== "remote" ? invalidContract() : { type: "file", ...owns(value2, "storage") ? { storage: value2.storage } : {} };
       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":
@@ -716,7 +731,7 @@ var schema = {
   boolean() {
     return declaration({ type: "boolean" });
   }
-}, file = () => declaration({ type: "file" }), definitions = /* @__PURE__ */ new WeakMap(), defineRoutine = (definition) => {
+}, file = (options = {}) => (assertRoutineFields(options, ["storage"]), declaration({ type: "file", ...options })), definitions = /* @__PURE__ */ new WeakMap(), defineRoutine = (definition) => {
   if (assertRoutineFields(definition, ["id", "title", "input", "steps", "result", "access", "responses", "run"]), !isAppRoutineName(definition.id) || definition.title !== void 0 && !routineTitle(definition.title) || typeof definition.run != "function") return invalidContract3();
   let input = definition.input === void 0 ? { schema: empty, default: {} } : schemaMetadata(definition.input), result2 = definition.result === void 0 ? void 0 : schemaMetadata(definition.result).schema, access = parseRoutineAccess(definition.access);
   assertRoutineFields(definition.steps ?? {});
@@ -795,6 +810,12 @@ async function executeRoutineDefinition(definition, input, runtime) {
     ...guarded({
       ...runtime,
       run: freezeRoutineMetadata({ ...runtime.run }),
+      connections: { ...runtime.connections, get: async (identity) => {
+        if (!active2 || broken || !contract.access.connections?.includes(identity)) throw new Error("Connection unavailable");
+        let value = await runtime.connections.get(identity);
+        if (!active2 || broken) throw new Error("Run authority ended");
+        return value;
+      } },
       inbox: { ...runtime.inbox, publishAsk: (value, options) => runtime.inbox.publishAsk(qualify(value), options) }
     }),
     step(id3, ...input2) {
@@ -936,6 +957,15 @@ function captureRecordsSearchInput(query, options) {
   return { query, options: captured };
 }
 
+function captureRecordsReadRefs(value) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > 100)
+    throw new DataOperationError("invalid_query");
+  let refs = historyArray(value);
+  if (!refs.every((ref) => validRecordRef(ref) && !/[\r\n]/.test(ref)) || new Set(refs).size !== refs.length)
+    throw new DataOperationError("invalid_query");
+  return refs;
+}
+
 var DATA_REQUEST_LIMIT = 256 * 1024, invalidChange = () => {
   throw new DataOperationError("invalid_change", !1, "unapplied");
 };
@@ -1029,16 +1059,16 @@ function routineTransport() {
   return installed;
 }
 
-var memberContext;
-function installMemberContext(resolve) {
-  return memberContext = resolve, () => {
-    memberContext === resolve && (memberContext = void 0);
+var memberContext, retainedContext;
+function installMemberContext(resolve, retained = resolve) {
+  return memberContext = resolve, retainedContext = retained, () => {
+    memberContext === resolve && (memberContext = void 0, retainedContext = void 0);
   };
 }
-async function resolveAppContext() {
+async function resolveAppContext(retained = !1) {
   let host = memberContext;
   if (!host) throw new Error("App context unavailable.");
-  let context2 = await host();
+  let context2 = await (retained ? retainedContext : 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;
@@ -1063,13 +1093,22 @@ async function resolveFilesContext() {
     let environment = {}, host = memberContext;
     if (host) {
       let context2 = await host();
-      if (context2.kind === "local") throw new Error();
+      if (host !== memberContext || !context2.isCurrent() || context2.expiresAt <= Date.now()) throw new Error();
+      if (context2.kind === "local") return {
+        url: `private:app:${context2.workspace}/${context2.memberId}`,
+        headers: {},
+        isCurrent: context2.isCurrent,
+        signal: context2.signal,
+        local: void 0,
+        localFiles: context2.requestFiles
+      };
       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
+        localFiles: void 0,
+        signal: void 0
       };
     }
     throw new Error();
@@ -1079,14 +1118,102 @@ async function resolveFilesContext() {
 }
 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 };
+  return { url: `${endpoint}/api/files`, headers: { ...headers, "x-os-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 } };
+  return { url: `${origin.origin}/api/data`, headers: { ...headers, "x-os-workspace": workspace } };
+}
+
+var invalid6 = () => {
+  throw new DataOperationError("invalid_query");
+}, unavailable = () => {
+  throw new DataOperationError("unavailable");
+}, text2 = (value) => typeof value == "string" && value.length > 0;
+function capture2(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 invalid6();
+  ancestors.add(value);
+  try {
+    return Array.isArray(value) ? historyArray(value).map((item) => capture2(item, ancestors, depth + 1)) : Object.fromEntries(Object.entries(historyProperties(value)).map(([key, descriptor]) => [key, capture2(descriptor.value, ancestors, depth + 1)]));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function recordPagination(select) {
+  function pages(query) {
+    let captured = capture2(query), names = Object.keys(historyProperties(captured));
+    for (let name of names) {
+      let selection2 = historyProperties(captured[name]);
+      if (Object.hasOwn(selection2, "$")) {
+        let options = historyProperties(selection2.$.value);
+        if (Object.hasOwn(options, "after")) return invalid6();
+      }
+    }
+    return iterate();
+    async function* iterate() {
+      let state = new Map(names.map((name) => [name, {
+        seen: /* @__PURE__ */ new Set(),
+        total: 0,
+        count: void 0,
+        next: void 0
+      }])), active2 = names, version;
+      do {
+        let request2 = Object.fromEntries(active2.map((name) => {
+          let selection2 = captured[name], next = state.get(name).next;
+          return [name, next === void 0 ? selection2 : { ...selection2, $: { ...selection2.$, after: next } }];
+        })), response2 = await select(request2), page;
+        try {
+          page = capture2(response2);
+          let keys4 = Object.keys(historyProperties(page));
+          (keys4.length !== active2.length + 1 || keys4.some((key) => key !== "$meta" && !active2.includes(key))) && unavailable();
+          let meta = page.$meta;
+          (Object.keys(historyProperties(meta)).sort().join(",") !== "collections,version" || !text2(meta.version) || version !== void 0 && version !== meta.version) && unavailable(), version = meta.version, Object.keys(historyProperties(meta.collections)).some((key) => !active2.includes(key)) && unavailable();
+          for (let name of active2) {
+            let records = historyArray(page[name]), metadata = Object.hasOwn(meta.collections, name) ? meta.collections[name] : {};
+            (Object.keys(historyProperties(metadata)).some((key) => key !== "count" && key !== "next") || Object.hasOwn(metadata, "next") && !text2(metadata.next)) && unavailable();
+            for (let record3 of records) {
+              historyProperties(record3);
+              let row = record3;
+              (!validRecordRef(row.$ref) || !text2(row.$version)) && unavailable();
+            }
+            let current2 = state.get(name);
+            captured[name].$?.count === !0 ? ((!Number.isSafeInteger(metadata.count) || metadata.count < 0 || current2.count !== void 0 && current2.count !== metadata.count) && unavailable(), current2.count = metadata.count) : Object.hasOwn(metadata, "count") && unavailable(), current2.total += records.length, (!Number.isSafeInteger(current2.total) || current2.count !== void 0 && (current2.total > current2.count || metadata.next === void 0 && current2.total !== current2.count)) && unavailable(), metadata.next !== void 0 && (current2.seen.has(metadata.next) && unavailable(), current2.seen.add(metadata.next)), current2.next = metadata.next;
+          }
+        } catch {
+          return unavailable();
+        }
+        let collections = Object.fromEntries(names.map((name) => {
+          let current2 = state.get(name);
+          return [name, {
+            ...current2.count === void 0 ? {} : { count: current2.count },
+            ...current2.next === void 0 ? {} : { next: current2.next }
+          }];
+        })), output = Object.fromEntries(names.map((name) => [name, active2.includes(name) ? page[name] : []]));
+        active2 = active2.filter((name) => state.get(name).next !== void 0), yield { ...output, $meta: { version, collections } };
+      } while (active2.length);
+    }
+  }
+  async function all(query, options) {
+    let properties = historyProperties(options), maxRecords = properties.maxRecords?.value;
+    (Object.keys(properties).join(",") !== "maxRecords" || !Number.isSafeInteger(maxRecords) || maxRecords < 1) && invalid6();
+    let result2, total = 0;
+    for await (let page of pages(query)) {
+      let names = Object.keys(page.$meta.collections), size = names.reduce((sum, name) => sum + page[name].length, 0);
+      if (size > maxRecords - total) throw new DataOperationError("capacity");
+      total += size, result2 ??= { ...Object.fromEntries(names.map((name) => [name, []])), $meta: page.$meta };
+      for (let name of names) {
+        let target = result2[name];
+        for (let record3 of page[name]) target.push(record3);
+      }
+      result2.$meta = page.$meta;
+    }
+    return result2;
+  }
+  return { pages, all };
 }
 
 var data = {
@@ -1109,13 +1236,20 @@ var data = {
         throw error instanceof DataOperationError ? error : new DataOperationError("unavailable", !0);
       }
     }
+    async function read2(input) {
+      let refs = captureRecordsReadRefs(typeof input == "string" ? [input] : input), result2 = await send3({ operation: "records.read", refs });
+      return typeof input == "string" ? result2.records[0] : result2;
+    }
+    let select = (query) => send3({ operation: "records.select", query });
     return {
       collections: {
         list: () => send3({ operation: "collections.list" }),
         schema: (name) => send3({ operation: "collections.schema", name })
       },
       records: {
-        select: (query) => send3({ operation: "records.select", query }),
+        read: read2,
+        select,
+        ...recordPagination(select),
         search: async (query, options) => send3({ operation: "records.search", ...captureRecordsSearchInput(query, options) })
       },
       history: {
@@ -1182,7 +1316,65 @@ var data = {
   }
 };
 
-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, invalid6 = () => new FileOperationError("invalid_input", 400), unavailable = () => new FileOperationError("unavailable", 503, !0), failures = {
+async function hostedContent(url, init2, parent, upstream = fetch, check = async () => {
+}, failure) {
+  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 response2 = await upstream(url, { ...init2, signal: delivery.signal });
+    try {
+      if (await check(), delivery.signal.aborted) throw failure?.() ?? new FileOperationError("unavailable", 503, !0);
+    } catch (error) {
+      throw response2.body?.cancel().catch(() => {
+      }), error;
+    }
+    if (!response2.body)
+      return detach(), response2;
+    let source = response2.body, reader, settled = !1, output, cancel = async (reason) => {
+      if (!settled) {
+        settled = !0, detach(), delivery.signal.removeEventListener("abort", stop), 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();
+        }
+      }
+    }, stop = () => {
+      if (settled) return;
+      let error = failure?.() ?? delivery.signal.reason;
+      cancel(error).catch(() => {
+      }), output.error(error);
+    }, body = new ReadableStream({
+      start(controller) {
+        output = controller, delivery.signal.addEventListener("abort", stop, { once: !0 }), delivery.signal.aborted && stop();
+      },
+      async pull(controller) {
+        try {
+          if (await check(), settled) return;
+          reader ??= source.getReader();
+          let { done, value } = await reader.read();
+          if (await check(), settled) return;
+          done ? (settled = !0, detach(), delivery.signal.removeEventListener("abort", stop), reader.releaseLock(), controller.close()) : controller.enqueue(value);
+        } catch (error) {
+          if (settled) return;
+          controller.error(failure?.() ?? error), await cancel(error).catch(() => {
+          });
+        }
+      },
+      cancel
+    }, { highWaterMark: 0 }), wrapped = new Response(body, { status: response2.status, statusText: response2.statusText, headers: response2.headers });
+    for (let key of ["url", "redirected", "type"])
+      Object.defineProperty(wrapped, key, { value: response2[key] });
+    return wrapped;
+  } catch (error) {
+    throw detach(), delivery.abort(error), error;
+  }
+}
+
+var MAX_BYTES = 16 * 1024 * 1024, PART_BYTES = 8 * 1024 * 1024, METADATA_BYTES = 4096, RESULT_BYTES = 16 * 1024, CONTROL_RESULT_BYTES = 128 * 1024, TIMEOUT_MS = 3e4, MAX_ACTIVE = 4, ATTEMPTS = 2, active = 0, invalid7 = () => new FileOperationError("invalid_input", 400), unavailable2 = () => new FileOperationError("unavailable", 503, !0), failures = {
   400: ["invalid_input", "unsupported_context"],
   401: ["unauthenticated"],
   403: ["access_denied"],
@@ -1192,26 +1384,33 @@ var MAX_BYTES = 16 * 1024 * 1024, PART_BYTES = 8 * 1024 * 1024, METADATA_BYTES =
   429: ["capacity"],
   503: ["integrity", "unavailable"]
 };
-async function boundedBytes(stream, limit) {
+async function boundedBytes(stream, limit, signal) {
   if (!stream) return new Uint8Array();
-  let reader = stream.getReader(), bytes = new Uint8Array(limit), size = 0;
+  let reader = stream.getReader(), bytes = new Uint8Array(limit), size = 0, cancel = () => {
+    reader.cancel().catch(() => {
+    });
+  };
+  signal?.addEventListener("abort", cancel, { once: !0 }), signal?.aborted && cancel();
   try {
     for (; ; ) {
       let { done, value } = await reader.read();
+      if (signal?.aborted) throw unavailable2();
       if (done) break;
-      if (!(value instanceof Uint8Array)) throw invalid6();
+      if (!(value instanceof Uint8Array)) throw invalid7();
       if (size += value.byteLength, size > limit) throw new FileOperationError("request_too_large", 413);
       bytes.set(value, size - value.byteLength);
     }
+  } catch (error) {
+    throw cancel(), error;
   } finally {
-    reader.releaseLock();
+    signal?.removeEventListener("abort", cancel), reader.releaseLock();
   }
   return bytes.slice(0, size);
 }
 async function timed(work, parent, timeout = TIMEOUT_MS) {
   let controller = new AbortController(), timer, abort, expiry = new Promise((_, reject) => {
     abort = () => {
-      controller.abort(), reject(unavailable());
+      controller.abort(), reject(unavailable2());
     }, timer = setTimeout(abort, timeout), parent?.addEventListener("abort", abort, { once: !0 }), parent?.aborted && abort();
   });
   try {
@@ -1225,56 +1424,12 @@ async function result(response2, maximum = RESULT_BYTES) {
     let bytes = await boundedBytes(response2.body, maximum);
     return JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(bytes));
   } catch {
-    throw unavailable();
-  }
-}
-async function hostedContent(url, init2, parent, upstream = fetch) {
-  let delivery = new AbortController(), abort = () => delivery.abort(parent.reason);
-  parent.addEventListener("abort", abort, { once: !0 }), parent.aborted && abort();
-  let detach = () => parent.removeEventListener("abort", abort);
-  try {
-    let response2 = await upstream(url, { ...init2, signal: delivery.signal });
-    if (delivery.signal.aborted)
-      throw response2.body?.cancel().catch(() => {
-      }), unavailable();
-    if (!response2.body)
-      return detach(), response2;
-    let source = response2.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();
-        }
-      }
-    }, body = 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(body, { status: response2.status, statusText: response2.statusText, headers: response2.headers });
-    for (let key of ["url", "redirected", "type"])
-      Object.defineProperty(wrapped, key, { value: response2[key] });
-    return wrapped;
-  } catch (error) {
-    throw detach(), delivery.abort(error), error;
+    throw unavailable2();
   }
 }
 async function send(suffix, init2, descriptor, initial, parent) {
   let original = initial, checkCurrent = (context2 = original) => {
-    if (parent?.aborted) throw unavailable();
+    if (parent?.aborted) throw unavailable2();
     if (!original.isCurrent() || context2.url !== original.url) throw new FileOperationError("unsupported_context", 400);
   };
   for (let attempt = 0; attempt < ATTEMPTS; attempt++) {
@@ -1282,7 +1437,7 @@ async function send(suffix, init2, descriptor, initial, parent) {
     let context2 = await resolveFilesContext();
     checkCurrent(context2);
     try {
-      let response2 = await (async () => {
+      let response2 = context2.localFiles ? await context2.localFiles(suffix, init2, parent) : await (async () => {
         let url = `${context2.url}${suffix}`, request2 = {
           ...init2,
           signal: parent,
@@ -1294,11 +1449,11 @@ async function send(suffix, init2, descriptor, initial, parent) {
       })();
       if (!response2.ok) {
         let value2 = await result(response2), 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[response2.status]?.find((code2) => code2 === received);
-        throw code ? new FileOperationError(code, response2.status, code === "capacity" || code === "unavailable") : unavailable();
+        throw code ? new FileOperationError(code, response2.status, code === "capacity" || code === "unavailable") : unavailable2();
       }
       if (response2.status !== (descriptor === 204 ? 204 : 200) || descriptor === 204 && response2.body !== null)
         throw response2.body?.cancel().catch(() => {
-        }), unavailable();
+        }), unavailable2();
       try {
         checkCurrent();
       } catch (error) {
@@ -1312,21 +1467,21 @@ async function send(suffix, init2, descriptor, initial, parent) {
         return checkCurrent(), value;
       let parsed;
       if (descriptor === "enrichment") {
-        if (!value || typeof value != "object" || Array.isArray(value)) throw unavailable();
+        if (!value || typeof value != "object" || Array.isArray(value)) throw unavailable2();
         let { name, ...metadata } = value;
-        if (!safeEnrichmentName(name)) throw unavailable();
+        if (!safeEnrichmentName(name)) throw unavailable2();
         parsed = { name, ...parseEnrichmentDescriptor(metadata) };
       } else parsed = parseFileDescriptor(value);
       return checkCurrent(), parsed;
     } catch (error) {
-      let failure = error instanceof FileOperationError ? error : unavailable();
+      let failure = error instanceof FileOperationError ? error : unavailable2();
       if (init2.body instanceof ReadableStream || !failure.retryable || attempt + 1 === ATTEMPTS) throw failure;
     }
   }
-  throw unavailable();
+  throw unavailable2();
 }
 function idPath(id3) {
-  if (typeof id3 != "string" || !FILE_ID_PATTERN.test(id3)) throw invalid6();
+  if (typeof id3 != "string" || !FILE_ID_PATTERN.test(id3)) throw invalid7();
   return `/${id3}`;
 }
 async function multipartCreate(input, metadata, exchange, release = () => {
@@ -1337,18 +1492,18 @@ async function multipartCreate(input, metadata, exchange, release = () => {
     return pending.add(task), task.then(() => pending.delete(task), () => pending.delete(task)), task;
   }, void 0, timeout), control = (body) => ({
     method: "POST",
-    headers: { "content-type": "application/json", ...ticket ? { "x-oddington-transfer": ticket } : {} },
+    headers: { "content-type": "application/json", ...ticket ? { "x-os-transfer": ticket } : {} },
     body: JSON.stringify(body)
   });
   try {
     let start = await request2((signal) => exchange(`${route}/start`, control(upload?.file ?? metadata), "control", signal));
-    if (!start || typeof start != "object" || Array.isArray(start)) throw unavailable();
+    if (!start || typeof start != "object" || Array.isArray(start)) throw unavailable2();
     let session = start;
-    if (Object.keys(session).sort().join(",") !== "partBytes,ticket" || session.partBytes !== PART_BYTES || typeof session.ticket != "string" || !session.ticket || session.ticket.length > 64 * 1024) throw unavailable();
+    if (Object.keys(session).sort().join(",") !== "partBytes,ticket" || session.partBytes !== PART_BYTES || typeof session.ticket != "string" || !session.ticket || session.ticket.length > 64 * 1024) throw unavailable2();
     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();
+        if (Date.now() - lastProgress >= TIMEOUT_MS) throw unavailable2();
         let value = await request2(() => reader.read(), Math.max(1, TIMEOUT_MS - (Date.now() - lastProgress)));
         return value.value?.byteLength && (lastProgress = Date.now()), value;
       } catch (error) {
@@ -1369,41 +1524,41 @@ async function multipartCreate(input, metadata, exchange, release = () => {
           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 invalid6();
+            if (value2.done || !(value2.value instanceof Uint8Array) || (chunk = value2.value, chunk.byteLength > metadata.size - sent - filled)) throw invalid7();
           }
           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 invalid6();
+      if (part.byteLength !== length) throw invalid7();
       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 invalid6();
+          if (!(value2.value instanceof Uint8Array) || value2.value.byteLength) throw invalid7();
         }
       let value = await request2((signal) => exchange(`${route}/part`, {
         method: "POST",
-        headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket, "x-oddington-part": String(partNumber) },
+        headers: { "content-type": "application/octet-stream", "x-os-transfer": ticket, "x-os-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();
+      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 unavailable2();
       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 request2(() => upload.enrichment(name));
-      if (bytes.byteLength !== upload.file.enrichments[name].size || bytes.byteLength > MAX_BYTES) throw invalid6();
+      if (bytes.byteLength !== upload.file.enrichments[name].size || bytes.byteLength > MAX_BYTES) throw invalid7();
       await request2((signal) => exchange(`${route}/enrichments/${encodeURIComponent(name)}`, {
         method: "POST",
-        headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket },
+        headers: { "content-type": "application/octet-stream", "x-os-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();
+    if (new TextEncoder().encode(completion.body).byteLength > 128 * 1024) throw unavailable2();
     return parseFileDescriptor(await request2(
       (signal) => exchange(`${route}/complete`, completion, !0, signal),
       TIMEOUT_MS + Math.ceil(metadata.size / (1024 * 1024)) * 1e3
@@ -1411,7 +1566,7 @@ async function multipartCreate(input, metadata, exchange, release = () => {
   } catch (error) {
     throw reader && await reader.cancel(error).catch(() => {
     }), ticket && await request2((signal) => exchange(`${route}/abort`, control({}), "control", signal)).catch(() => {
-    }), error instanceof FileOperationError ? error : unavailable();
+    }), error instanceof FileOperationError ? error : unavailable2();
   } finally {
     chunk = void 0, reader?.releaseLock(), pending.size ? Promise.allSettled([...pending]).then(release) : release();
   }
@@ -1419,20 +1574,22 @@ async function multipartCreate(input, metadata, exchange, release = () => {
 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) => {
+  active++;
+  let execute = async (signal2) => {
     try {
-      return await work(context2, signal);
+      return await work(context2, signal2);
     } finally {
       active--;
     }
-  }, parent).catch((error) => {
-    throw error instanceof FileOperationError ? error : unavailable();
+  }, signal = context2.signal && parent ? AbortSignal.any([context2.signal, parent]) : context2.signal ?? parent;
+  return context2.localFiles ? execute(signal ?? new AbortController().signal) : timed(execute, signal).catch((error) => {
+    throw error instanceof FileOperationError ? error : unavailable2();
   });
 }
 function contentPath(id3, name) {
   let path = idPath(id3);
   if (name === void 0) return `${path}/content`;
-  if (!safeEnrichmentName(name)) throw invalid6();
+  if (!safeEnrichmentName(name)) throw invalid7();
   return `${path}/enrichments/${encodeURIComponent(name)}/content`;
 }
 async function read(id3, names) {
@@ -1441,12 +1598,12 @@ async function read(id3, names) {
     let path = contentPath(id3, names);
     return operation((context3, signal) => send(path, { method: "GET" }, !1, context3, signal), context2);
   }
-  if (!Array.isArray(names)) throw invalid6();
+  if (!Array.isArray(names)) throw invalid7();
   let distinct = [], seen = /* @__PURE__ */ new Set();
   for (let name of names) {
-    if (typeof name != "string" || !safeEnrichmentName(name)) throw invalid6();
+    if (typeof name != "string" || !safeEnrichmentName(name)) throw invalid7();
     if (!seen.has(name)) {
-      if (seen.size === 16) throw invalid6();
+      if (seen.size === 16) throw invalid7();
       seen.add(name), distinct.push(name);
     }
   }
@@ -1474,18 +1631,18 @@ var files = {
   async upload(id3) {
     return operation(async (context2, signal) => {
       let file2 = await send(`${idPath(id3)}/upload`, { method: "POST" }, !0, context2, signal);
-      if (file2.id !== id3) throw unavailable();
+      if (file2.id !== id3) throw unavailable2();
       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 invalid6();
+      throw invalid7();
     let blob = input.file instanceof Blob, array3 = input.file instanceof Uint8Array, stream = input.file instanceof ReadableStream;
-    if (!blob && !array3 && !stream) throw invalid6();
+    if (!blob && !array3 && !stream) throw invalid7();
     let intrinsic = blob ? input.file.size : array3 ? input.file.byteLength : void 0;
-    if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid6();
+    if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid7();
     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({
@@ -1497,33 +1654,54 @@ var files = {
       ...blob && input.file.type === "application/pdf" ? { inputMediaType: "application/pdf" } : {},
       requestKey: options?.requestKey === void 0 ? routineTransport()?.key("files") ?? crypto.randomUUID() : options.requestKey
     }, FILE_ORIGINAL_MAX_BYTES);
-    if (!context2.local && metadata.storage === "local") throw new FileOperationError("unsupported_context", 400);
+    if (!context2.local && !context2.localFiles && metadata.storage === "local") throw new FileOperationError("unsupported_context", 400);
     let header = encodeURIComponent(JSON.stringify(metadata));
-    if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid6();
+    if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid7();
     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) => {
+    if (active++, context2.localFiles && !routineTransport() && metadata.size > MAX_BYTES) {
+      let signal = context2.signal ?? new AbortController().signal, file2 = input.file, offset = 0, body = file2 instanceof Blob ? context2.signal ? file2 : file2.stream() : file2 instanceof ReadableStream ? file2 : new ReadableStream({
+        pull(controller) {
+          if (offset === file2.byteLength) {
+            controller.close();
+            return;
+          }
+          let end = Math.min(offset + 256 * 1024, file2.byteLength);
+          controller.enqueue(file2.subarray(offset, end)), offset = end;
+        }
+      }, { highWaterMark: 0 });
+      try {
+        return await send("", { method: "POST", headers: {
+          "content-type": "application/octet-stream",
+          "x-os-file": header
+        }, body }, !0, context2, 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 = array3 ? input.file.slice() : await boundedBytes(
           blob ? input.file.stream() : input.file,
-          metadata.size
+          metadata.size,
+          signal
         );
-        if (bytes.byteLength !== metadata.size) throw invalid6();
-        if (signal.aborted) throw unavailable();
+        if (bytes.byteLength !== metadata.size) throw invalid7();
+        if (signal.aborted) throw unavailable2();
         return await send("", {
           method: "POST",
-          headers: { "content-type": "application/octet-stream", "x-oddington-file": header },
+          headers: { "content-type": "application/octet-stream", "x-os-file": header },
           body: bytes.buffer
         }, !0, context2, signal);
       } finally {
         active--;
       }
-    }).catch((error) => {
-      throw error instanceof FileOperationError ? error : unavailable();
+    }, context2.signal).catch((error) => {
+      throw error instanceof FileOperationError ? error : unavailable2();
     });
   },
   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 invalid6();
+    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 invalid7();
     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);
@@ -1540,12 +1718,12 @@ var files = {
         ...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 invalid6();
+      if (new TextEncoder().encode(header).byteLength > METADATA_BYTES) throw invalid7();
       let result2 = await send(path, { method: "POST", headers: {
         "content-type": "application/octet-stream",
-        "x-oddington-enrichment": header
+        "x-os-enrichment": header
       }, body: bytes.buffer }, "enrichment", context3, signal);
-      if (result2.name !== metadata.name) throw unavailable();
+      if (result2.name !== metadata.name) throw unavailable2();
       return result2;
     }, context2);
   },
@@ -1559,8 +1737,26 @@ function validGoogleScopes(value) {
   return Array.isArray(value) && value.length > 0 && value.length <= 32 && value.every((scope) => typeof scope == "string" && scope.length <= 256 && /^(https:\/\/www\.googleapis\.com\/auth\/[A-Za-z0-9._-]+|https:\/\/mail\.google\.com\/|openid|email|profile)$/.test(scope)) && new Set(value).size === value.length;
 }
 
-var ROUTINE_CONNECTION_CREDENTIALS_ENV = "ODDINGTON_ROUTINE_CONNECTION_CREDENTIALS";
+var ROUTINE_CONNECTION_CREDENTIALS_ENV = "OS_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 runtimeConnection(lease) {
+  return lease.provider === "gmail" ? {
+    id: `gmail/${lease.name}`,
+    provider: lease.provider,
+    name: lease.name,
+    accountEmail: lease.accountEmail,
+    scopes: [...lease.scopes],
+    accessToken: lease.accessToken,
+    expiresAt: lease.expiresAt
+  } : {
+    id: `airtable/${lease.name}`,
+    provider: lease.provider,
+    name: lease.name,
+    baseId: lease.baseId,
+    accessToken: lease.accessToken,
+    runExpiresAt: lease.runExpiresAt
+  };
+}
 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))
@@ -1596,12 +1792,12 @@ function object3(v) {
 function keys2(v, allowed, required = allowed) {
   (Object.keys(v).some((k) => !allowed.includes(k)) || required.some((k) => !Object.hasOwn(v, k))) && fail2("Invalid Airtable input");
 }
-function text2(v) {
+function text3(v) {
   return typeof v == "string" && v.length > 0 && v.length <= 1024;
 }
 function fields3(v, nonempty = !1) {
   let result2 = object3(v);
-  (nonempty && !Object.keys(result2).length || Object.keys(result2).some((k) => !text2(k))) && fail2("Invalid Airtable fields");
+  (nonempty && !Object.keys(result2).length || Object.keys(result2).some((k) => !text3(k))) && fail2("Invalid Airtable fields");
   try {
     return serializable(result2);
   } catch {
@@ -1622,7 +1818,9 @@ function equal(a, b) {
   ));
 }
 function createConnections(transport) {
-  return { airtable(name) {
+  return { async get() {
+    throw new Error("Connection unavailable");
+  }, 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 {
@@ -1686,10 +1884,10 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
       Array.isArray(page.tables) || fail2("Malformed Airtable tables");
       for (let value of page.tables) {
         let t = object3(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");
+        (!tableId(t.id) || !text3(t.name) || !text3(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 = object3(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) } };
+          return (typeof f.id != "string" || !/^fld[A-Za-z0-9]+$/.test(f.id) || !text3(f.name) || !text3(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 });
       }
@@ -1697,7 +1895,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
     } 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");
+  (!text3(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");
@@ -1705,7 +1903,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
     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");
+    keys2(input, ["table", "fields"], ["table"]), input.fields !== void 0 && (!Array.isArray(input.fields) || !input.fields.length || input.fields.some((f) => !text3(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();
@@ -1762,10 +1960,10 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
 }
 function nextOffset(value, seen) {
   if (value !== void 0)
-    return (!text2(value) || seen.has(value)) && fail2("Malformed Airtable pagination"), seen.add(value), value;
+    return (!text3(value) || seen.has(value)) && fail2("Malformed Airtable pagination"), seen.add(value), value;
 }
 
-var MANAGED_CONNECTION_CAPABILITY_ENV = "ODDINGTON_MANAGED_CONNECTION_CAPABILITY";
+var MANAGED_CONNECTION_CAPABILITY_ENV = "OS_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");
@@ -1804,46 +2002,19 @@ async function reportLocalRoutineEffect(value) {
   await observer?.(value);
 }
 
-var connections = /* @__PURE__ */ createConnections(async (name, operation2, input) => {
-  try {
-    let installed2 = routineTransport();
-    if (installed2) return await installed2.request("airtable", { name, operation: operation2, input: serializable(input) });
-    let managed = process.env[MANAGED_CONNECTION_CAPABILITY_ENV];
-    if (managed) {
-      let client = managedConnections(JSON.parse(managed)).airtable(name);
-      return operation2 === "tables.list" ? await client.tables.list() : await client.records[operation2.slice(8)](input);
-    }
-    let raw = JSON.parse(process.env[ROUTINE_CONNECTION_CREDENTIALS_ENV] ?? "[]");
-    if (!Array.isArray(raw)) throw new Error();
-    let leases = raw.map((value) => parseConnectionLease(value));
-    if (leases.some((lease2) => lease2.provider !== "airtable") || new Set(leases.map((lease2) => lease2.name)).size !== leases.length) throw new Error();
-    let lease = leases.find((lease2) => lease2.name === name);
-    if (!lease || lease.provider !== "airtable") throw new Error();
-    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;
-    }
-    return writing && await reportLocalRoutineEffect({
-      type: "effect",
-      connection: `airtable/${name}`,
-      operation: operation2,
-      input: captured,
-      effect: "confirmed",
-      receipts: [result2.receipt]
-    }), result2;
-  } catch (error) {
-    throw error instanceof AirtableOperationError ? error : new AirtableOperationError("Airtable connection unavailable");
-  }
+var local;
+var airtable = /* @__PURE__ */ createConnections(async (name, operation2, input) => {
+  throw new AirtableOperationError("Airtable connection unavailable");
 });
+function runtimeConnections() {
+  return {
+    ...airtable,
+    async get(identity) {
+      throw new Error("Connection unavailable");
+    }
+  };
+}
+var connections = /* @__PURE__ */ runtimeConnections();
 
 var LOCAL_ROUTINE_VALUE_BYTES = 256 * 1024;
 
@@ -1948,7 +2119,7 @@ function object4(value) {
 function keys3(value, allowed, required = allowed) {
   assert(Object.keys(value).every((key) => allowed.includes(key)) && required.every((key) => Object.hasOwn(value, key)));
 }
-function text3(value, empty2 = !1) {
+function text4(value, empty2 = !1) {
   return typeof value == "string" && (empty2 || !!value.trim());
 }
 function id2(value) {
@@ -1958,7 +2129,7 @@ function integer(value, minimum = 1) {
   return Number.isSafeInteger(value) && Number(value) >= minimum;
 }
 function date(value) {
-  return text3(value) && Number.isFinite(Date.parse(value));
+  return text4(value) && Number.isFinite(Date.parse(value));
 }
 function optionalDate(value) {
   return value === null || date(value);
@@ -1980,7 +2151,7 @@ function json(value, ancestors = /* @__PURE__ */ new Set()) {
 }
 function recordReference(value) {
   let record3 = object4(value);
-  return keys3(record3, ["repository", "ref"]), assert(text3(record3.repository) && record3.repository === record3.repository.trim() && /^[a-z0-9][a-z0-9._/-]{0,127}$/.test(record3.repository) && !/\.\.|\/\//.test(record3.repository) && text3(record3.ref) && record3.ref === record3.ref.trim() && record3.ref.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)+$/.test(record3.ref)), record3;
+  return keys3(record3, ["repository", "ref"]), assert(text4(record3.repository) && record3.repository === record3.repository.trim() && /^[a-z0-9][a-z0-9._/-]{0,127}$/.test(record3.repository) && !/\.\.|\/\//.test(record3.repository) && text4(record3.ref) && record3.ref === record3.ref.trim() && record3.ref.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)+$/.test(record3.ref)), record3;
 }
 function responseDefinition(value) {
   let definition = object4(value);
@@ -1992,75 +2163,75 @@ function responseDefinition(value) {
     assert(options.length > 0);
     let values = options.map((value2) => {
       let option = object4(value2);
-      if (keys3(option, ["value", "label", "description", "note"], ["value", "label"]), assert(text3(option.value) && option.value === option.value.trim() && text3(option.label)), "description" in option && assert(text3(option.description)), "note" in option) {
+      if (keys3(option, ["value", "label", "description", "note"], ["value", "label"]), assert(text4(option.value) && option.value === option.value.trim() && text4(option.label)), "description" in option && assert(text4(option.description)), "note" in option) {
         let note = object4(option.note);
-        keys3(note, ["placeholder"]), assert(text3(note.placeholder));
+        keys3(note, ["placeholder"]), assert(text4(note.placeholder));
       }
       return option.value;
     });
     if (assert(new Set(values).size === values.length), "search" in source || "suggestions" in source) {
       let search = object4(source.search);
-      keys3(search, ["triggerLabel", "placeholder", "emptyLabel"]), assert(text3(search.triggerLabel) && text3(search.placeholder) && text3(search.emptyLabel));
+      keys3(search, ["triggerLabel", "placeholder", "emptyLabel"]), assert(text4(search.triggerLabel) && text4(search.placeholder) && text4(search.emptyLabel));
       let suggestions2 = array2(source.suggestions);
-      assert(suggestions2.length <= 8 && suggestions2.every((value2) => text3(value2) && values.includes(value2)) && new Set(suggestions2).size === suggestions2.length);
+      assert(suggestions2.length <= 8 && suggestions2.every((value2) => text4(value2) && values.includes(value2)) && new Set(suggestions2).size === suggestions2.length);
     } else assert(options.length <= 9);
     return;
   }
   assert(source.type === "records"), keys3(source, ["type", "collection", "refPrefix", "where", "display", "suggestions"], ["type", "collection", "display"]);
   let collection = object4(source.collection);
-  keys3(collection, ["repository", "name"]), recordReference({ repository: collection.repository, ref: "records/example" }), assert(text3(collection.name) && /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*$/.test(collection.name)), "refPrefix" in source && assert(text3(source.refPrefix) && source.refPrefix.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)*\/$/.test(source.refPrefix));
+  keys3(collection, ["repository", "name"]), recordReference({ repository: collection.repository, ref: "records/example" }), assert(text4(collection.name) && /^[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_-]+)*$/.test(collection.name)), "refPrefix" in source && assert(text4(source.refPrefix) && source.refPrefix.length <= 512 && /^[_a-zA-Z0-9][a-zA-Z0-9_-]*(\/[_a-zA-Z0-9][a-zA-Z0-9_-]*)*\/$/.test(source.refPrefix));
   let where = object4(source.where ?? {});
   assert(Object.entries(where).every(([name, value2]) => /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name) && !["constructor", "prototype"].includes(name) && (value2 === null || typeof value2 == "string" || typeof value2 == "boolean" || typeof value2 == "number" && Number.isFinite(value2))));
   let display = object4(source.display);
   keys3(display, ["labelFields"]);
   let labels = array2(display.labelFields);
-  assert(labels.length > 0 && labels.length <= 2 && new Set(labels).size === labels.length && labels.every((value2) => text3(value2) && /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value2)));
+  assert(labels.length > 0 && labels.length <= 2 && new Set(labels).size === labels.length && labels.every((value2) => text4(value2) && /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value2)));
   let suggestions = array2(source.suggestions ?? []), refs = suggestions.map((value2) => {
     let suggestion = object4(value2);
     keys3(suggestion, ["record", "reason"], ["record"]);
     let record3 = recordReference(suggestion.record);
-    return assert(record3.repository === collection.repository), "reason" in suggestion && assert(text3(suggestion.reason)), record3.ref;
+    return assert(record3.repository === collection.repository), "reason" in suggestion && assert(text4(suggestion.reason)), record3.ref;
   });
   assert(suggestions.length <= 8 && new Set(refs).size === refs.length);
 }
 function inboxFile(value) {
   let file2 = object4(value);
-  keys3(file2, ["id", "name", "mediaType", "size", "sha256", "details"]), assert(id2(file2.id) && text3(file2.name) && !/[\x00-\x1f\x7f/\\]/.test(file2.name) && text3(file2.mediaType) && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(file2.mediaType) && integer(file2.size, 0) && file2.size <= 25 * 1024 * 1024 && typeof file2.sha256 == "string" && /^[0-9a-f]{64}$/.test(file2.sha256));
+  keys3(file2, ["id", "name", "mediaType", "size", "sha256", "details"]), assert(id2(file2.id) && text4(file2.name) && !/[\x00-\x1f\x7f/\\]/.test(file2.name) && text4(file2.mediaType) && /^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+$/.test(file2.mediaType) && integer(file2.size, 0) && file2.size <= 25 * 1024 * 1024 && typeof file2.sha256 == "string" && /^[0-9a-f]{64}$/.test(file2.sha256));
   let details = object4(file2.details);
   details.kind === "csv" ? (keys3(details, ["kind", "encoding", "delimiter", "headerRow", "dataRows"]), assert(file2.mediaType === "text/csv" && ["utf-8", "windows-1252"].includes(String(details.encoding)) && [",", ";", "	"].includes(String(details.delimiter)) && integer(details.headerRow, 0) && integer(details.dataRows, 0))) : details.kind === "pdf" ? (keys3(details, ["kind", "pages"], ["kind"]), assert(file2.mediaType === "application/pdf" && (!("pages" in details) || integer(details.pages)))) : (keys3(details, ["kind"]), assert(details.kind === "other" && !["text/csv", "application/pdf"].includes(file2.mediaType)));
 }
 function fields4(value) {
   let labels = array2(value).map((value2) => {
     let field = object4(value2);
-    return keys3(field, ["label", "value"]), assert(text3(field.label) && text3(field.value)), field.label;
+    return keys3(field, ["label", "value"]), assert(text4(field.label) && text4(field.value)), field.label;
   });
   assert(new Set(labels).size === labels.length);
 }
 function block(value) {
   let entry = object4(value);
   if (entry.kind === "rich-text") {
-    keys3(entry, ["kind", "markdown"]), assert(text3(entry.markdown));
+    keys3(entry, ["kind", "markdown"]), assert(text4(entry.markdown));
     return;
   }
   if (entry.kind === "asks") {
     keys3(entry, ["kind", "problem", "asks"]);
     let asks = array2(entry.asks);
-    assert(text3(entry.problem) && asks.length > 0 && asks.every(id2) && new Set(asks).size === asks.length);
+    assert(text4(entry.problem) && asks.length > 0 && asks.every(id2) && new Set(asks).size === asks.length);
     return;
   }
   if (assert(["record", "records", "files"].includes(String(entry.kind))), keys3(
     entry,
     ["kind", "label", "initiallyExpanded", ...entry.kind === "record" ? ["record", "view"] : entry.kind === "records" ? ["records", "view"] : ["files"]],
     ["kind", "label", entry.kind === "record" ? "record" : entry.kind === "records" ? "records" : "files"]
-  ), assert(text3(entry.label) && (!("initiallyExpanded" in entry) || typeof entry.initiallyExpanded == "boolean") && (!("view" in entry) || text3(entry.view) && entry.view === entry.view.trim())), entry.kind === "record") {
+  ), assert(text4(entry.label) && (!("initiallyExpanded" in entry) || typeof entry.initiallyExpanded == "boolean") && (!("view" in entry) || text4(entry.view) && entry.view === entry.view.trim())), entry.kind === "record") {
     let record3 = object4(entry.record);
-    keys3(record3, ["ref", "title", "fields"]), assert(text3(record3.ref) && record3.ref === record3.ref.trim() && text3(record3.title)), fields4(record3.fields);
+    keys3(record3, ["ref", "title", "fields"]), assert(text4(record3.ref) && record3.ref === record3.ref.trim() && text4(record3.title)), fields4(record3.fields);
     return;
   }
   if (entry.kind === "records") {
     let records = array2(entry.records), refs = records.map((value2) => {
       let record3 = object4(value2);
-      return keys3(record3, ["ref", "title", "description", "facts", "view"], ["ref", "title"]), assert(text3(record3.ref) && record3.ref === record3.ref.trim() && text3(record3.title)), "description" in record3 && assert(text3(record3.description)), "facts" in record3 && fields4(record3.facts), "view" in record3 && assert(text3(record3.view) && record3.view === record3.view.trim()), record3.ref;
+      return keys3(record3, ["ref", "title", "description", "facts", "view"], ["ref", "title"]), assert(text4(record3.ref) && record3.ref === record3.ref.trim() && text4(record3.title)), "description" in record3 && assert(text4(record3.description)), "facts" in record3 && fields4(record3.facts), "view" in record3 && assert(text4(record3.view) && record3.view === record3.view.trim()), record3.ref;
     });
     assert(records.length > 0 && new Set(refs).size === refs.length);
     return;
@@ -2070,7 +2241,7 @@ function block(value) {
 }
 function response(value) {
   let answer = object4(value);
-  return assert(Object.keys(answer).every((key) => ["selection", "note"].includes(key))), typeof answer.selection == "string" ? assert(text3(answer.selection) && answer.selection === answer.selection.trim()) : recordReference(answer.selection), Object.hasOwn(answer, "note") && assert(text3(answer.note)), answer;
+  return assert(Object.keys(answer).every((key) => ["selection", "note"].includes(key))), typeof answer.selection == "string" ? assert(text4(answer.selection) && answer.selection === answer.selection.trim()) : recordReference(answer.selection), Object.hasOwn(answer, "note") && assert(text4(answer.note)), answer;
 }
 function parseInboxRequest(value) {
   try {
@@ -2079,78 +2250,82 @@ function parseInboxRequest(value) {
     let operation2 = envelope.operation, input = { ...object4(envelope.input) }, required = operations[operation2];
     assert(required.every((key) => Object.hasOwn(input, key)) && Object.keys(input).every((key) => required.includes(key) || operation2 === "questions.searchRecords" && key === "selected" || (operation2 === "items.list" || operation2 === "questions.list") && key === "beforeNumber" || operation2 === "questions.list" && key === "routines")), operation2 === "questions.list" && (assert(Object.hasOwn(input, "routines")), assert(array2(input.routines).every(isAppRoutineName)));
     for (let key of ["itemId", "personId", "fileId"]) key in input && assert(id2(input[key]));
-    return "revision" in input && assert(integer(input.revision)), "beforeNumber" in input && assert(integer(input.beforeNumber)), "questionId" in input && assert(text3(input.questionId) && input.questionId === input.questionId.trim()), "title" in input && assert(text3(input.title)), "lifecycle" in input && assert(input.lifecycle === "open" || input.lifecycle === "closed"), "query" in input && assert(text3(input.query, !0) && input.query.length <= 256), "selected" in input && recordReference(input.selected), "response" in input && response(input.response), assert(new TextEncoder().encode(JSON.stringify(envelope)).byteLength <= INBOX_INPUT_BYTES), "routines" in input && (input.routines = [...new Set(input.routines)]), { operation: operation2, input };
+    return "revision" in input && assert(integer(input.revision)), "beforeNumber" in input && assert(integer(input.beforeNumber)), "questionId" in input && assert(text4(input.questionId) && input.questionId === input.questionId.trim()), "title" in input && assert(text4(input.title)), "lifecycle" in input && assert(input.lifecycle === "open" || input.lifecycle === "closed"), "query" in input && assert(text4(input.query, !0) && input.query.length <= 256), "selected" in input && recordReference(input.selected), "response" in input && response(input.response), assert(new TextEncoder().encode(JSON.stringify(envelope)).byteLength <= INBOX_INPUT_BYTES), "routines" in input && (input.routines = [...new Set(input.routines)]), { operation: operation2, input };
   } catch {
     throw new InboxOperationError(400, "invalid_input");
   }
 }
 function parseInboxCurrent(value) {
   let current2 = object4(value), workspace = object4(current2.workspace), viewer = object4(current2.viewer);
-  return assert(id2(workspace.id) && text3(workspace.slug) && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(workspace.slug) && text3(workspace.name) && text3(workspace.locale) && text3(workspace.timezone)), assert(id2(viewer.id) && text3(viewer.name) && text3(viewer.email)), {
+  return assert(id2(workspace.id) && text4(workspace.slug) && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(workspace.slug) && text4(workspace.name) && text4(workspace.locale) && text4(workspace.timezone)), assert(id2(viewer.id) && text4(viewer.name) && text4(viewer.email)), {
     workspace: { id: workspace.id, slug: workspace.slug, name: workspace.name, locale: workspace.locale, timezone: workspace.timezone },
     viewer: { id: viewer.id, name: viewer.name, email: viewer.email }
   };
 }
 function parseInboxItem(value) {
   let item = object4(json(value));
-  return assert(id2(item.id) && id2(item.workspaceId) && integer(item.number) && integer(item.revision) && integer(item.activityVersion, 0) && ["ask", "digest"].includes(String(item.kind)) && ["open", "closed"].includes(String(item.lifecycle)) && text3(item.title) && text3(item.description, !0) && text3(item.author) && date(item.publishedAt) && optionalDate(item.seenAt) && optionalDate(item.digestReadAt)), item.outcome !== null && assert(text3(object4(item.outcome).outcome)), "canonicalRoutineId" in item && assert(item.canonicalRoutineId === null || isAppRoutineName(item.canonicalRoutineId)), array2(item.body).forEach(block), array2(item.views).forEach((value2) => {
+  return assert(id2(item.id) && id2(item.workspaceId) && integer(item.number) && integer(item.revision) && integer(item.activityVersion, 0) && ["ask", "digest"].includes(String(item.kind)) && ["open", "closed"].includes(String(item.lifecycle)) && text4(item.title) && text4(item.description, !0) && text4(item.author) && date(item.publishedAt) && optionalDate(item.seenAt) && optionalDate(item.digestReadAt)), item.outcome !== null && assert(text4(object4(item.outcome).outcome)), "canonicalRoutineId" in item && assert(item.canonicalRoutineId === null || isAppRoutineName(item.canonicalRoutineId)), item.kind === "ask" ? askMetadata(item) : assert(!("tags" in item) && !("recordRefs" in item)), array2(item.body).forEach(block), array2(item.views).forEach((value2) => {
     let view = object4(value2);
-    assert(text3(view.id) && text3(view.view) && text3(view.implementation)), json(view.input);
+    assert(text4(view.id) && text4(view.view) && text4(view.implementation)), json(view.input);
   }), array2(item.people).forEach((value2) => {
     let person = object4(value2);
-    assert(id2(person.id) && text3(person.name));
+    assert(id2(person.id) && text4(person.name));
   }), array2(item.questions).forEach((value2) => {
     let question2 = object4(value2);
-    if (assert(text3(question2.id) && id2(question2.to) && text3(question2.prompt) && (question2.instructions === null || text3(question2.instructions, !0)) && typeof question2.available == "boolean"), responseDefinition(question2.response), assert(array2(question2.allowedResponders).every(id2)), question2.acceptedResponse !== null) {
+    if (assert(text4(question2.id) && id2(question2.to) && text4(question2.prompt) && (question2.instructions === null || text4(question2.instructions, !0)) && typeof question2.available == "boolean"), responseDefinition(question2.response), assert(array2(question2.allowedResponders).every(id2)), question2.acceptedResponse !== null) {
       let accepted = object4(question2.acceptedResponse);
-      assert(id2(accepted.id) && id2(accepted.userId) && date(accepted.acceptedAt)), response(accepted.response), accepted.label === null ? delete accepted.label : "label" in accepted && assert(text3(accepted.label)), "acceptanceOrder" in accepted && assert(integer(accepted.acceptanceOrder));
+      assert(id2(accepted.id) && id2(accepted.userId) && date(accepted.acceptedAt)), response(accepted.response), accepted.label === null ? delete accepted.label : "label" in accepted && assert(text4(accepted.label)), "acceptanceOrder" in accepted && assert(integer(accepted.acceptanceOrder));
     }
     if (question2.execution !== null) {
       let execution = object4(question2.execution);
       if (assert(id2(execution.id) && ["pending", "running", "completed", "failed"].includes(String(execution.state)) && integer(execution.attempt, 0)), "consequence" in execution) {
         let consequence = object4(execution.consequence);
-        assert(["pending", "running", "applied", "no-write", "stopped", "partial", "uncertain"].includes(String(consequence.state)) && (consequence.phase === null || ["loading", "invoking", "committing"].includes(String(consequence.phase))) && date(consequence.updatedAt) && typeof consequence.needsReconciliation == "boolean" && (consequence.reason === null || text3(consequence.reason, !0))), array2(consequence.evidence).forEach((value3) => {
+        assert(["pending", "running", "applied", "no-write", "stopped", "partial", "uncertain"].includes(String(consequence.state)) && (consequence.phase === null || ["loading", "invoking", "committing"].includes(String(consequence.phase))) && date(consequence.updatedAt) && typeof consequence.needsReconciliation == "boolean" && (consequence.reason === null || text4(consequence.reason, !0))), array2(consequence.evidence).forEach((value3) => {
           let receipt = object4(value3);
-          assert(text3(receipt.repository) && text3(receipt.commit) && text3(receipt.diff, !0));
+          assert(text4(receipt.repository) && text4(receipt.commit) && text4(receipt.diff, !0));
         });
       }
     }
   }), array2(item.linkedAsks).forEach((value2) => {
     let linked = object4(value2);
     if (assert(id2(linked.id)), linked.state === "unavailable") assert(typeof linked.done == "boolean");
-    else if (assert(["yours", "done", "open", "theirs"].includes(String(linked.state)) && text3(linked.title)), linked.state === "theirs") {
+    else if (assert(["yours", "done", "open", "theirs"].includes(String(linked.state)) && text4(linked.title)), linked.state === "theirs") {
       let assignee = object4(linked.assignee);
-      assert(id2(assignee.id) && text3(assignee.name));
+      assert(id2(assignee.id) && text4(assignee.name));
     }
   }), array2(item.activity).forEach((value2) => {
     let event = object4(value2);
-    assert(integer(event.id) && text3(event.type) && (event.actorId === null || id2(event.actorId)) && (event.questionId === null || text3(event.questionId)) && integer(event.revision) && date(event.createdAt)), object4(event.data);
+    assert(integer(event.id) && text4(event.type) && (event.actorId === null || id2(event.actorId)) && (event.questionId === null || text4(event.questionId)) && integer(event.revision) && date(event.createdAt)), object4(event.data);
   }), array2(item.work).forEach((value2) => {
     let work = object4(value2);
-    assert(id2(work.id) && text3(work.questionId) && text3(work.reason) && optionalDate(work.settledAt));
+    assert(id2(work.id) && text4(work.questionId) && text4(work.reason) && optionalDate(work.settledAt));
   }), item;
 }
 function parseAnswerableQuestion(value) {
   let entry = object4(json(value));
   keys3(
     entry,
-    ["itemId", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable", "recordRefs", "instructions"],
-    ["itemId", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable", "recordRefs"]
-  ), assert(id2(entry.itemId) && integer(entry.revision) && text3(entry.title) && text3(entry.inboxUrl));
+    ["itemId", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable", "tags", "recordRefs", "instructions"],
+    ["itemId", "revision", "title", "inboxUrl", "questionId", "routine", "prompt", "response", "answerable"]
+  ), assert(id2(entry.itemId) && integer(entry.revision) && text4(entry.title) && text4(entry.inboxUrl));
   let link = new URL(entry.inboxUrl), slug = link.hostname.slice(0, -13);
-  assert(link.hostname.endsWith(".oddington.ai") && slug.length <= 63 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug) && !["auth", "www", "api", "os"].includes(slug) && entry.inboxUrl === `https://${slug}.oddington.ai/inbox/${entry.itemId}`), assert(isAppRoutineName(entry.routine) && text3(entry.questionId) && entry.questionId === entry.questionId.trim() && text3(entry.prompt) && (!("instructions" in entry) || text3(entry.instructions, !0)) && typeof entry.answerable == "boolean"), responseDefinition(entry.response);
-  let refs = array2(entry.recordRefs);
-  return refs.forEach((value2) => {
-    let ref = object4(value2);
-    keys3(ref, ["repository", "id"]), assert(validRepositoryAlias(ref.repository) && text3(ref.id) && /^[a-zA-Z0-9][a-zA-Z0-9._/-]*$/.test(ref.id) && !ref.id.split("/").some((part) => !part || part === "." || part === ".."));
-  }), assert(new Set(refs.map((value2) => {
-    let ref = object4(value2);
+  return assert(link.hostname.endsWith(".oddington.ai") && slug.length <= 63 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug) && !["auth", "www", "api", "os"].includes(slug) && entry.inboxUrl === `https://${slug}.oddington.ai/inbox/${entry.itemId}`), assert(isAppRoutineName(entry.routine) && text4(entry.questionId) && entry.questionId === entry.questionId.trim() && text4(entry.prompt) && (!("instructions" in entry) || text4(entry.instructions, !0)) && typeof entry.answerable == "boolean"), responseDefinition(entry.response), askMetadata(entry), entry;
+}
+function askMetadata(entry) {
+  let tags = array2(entry.tags === void 0 ? [] : entry.tags);
+  assert(tags.length <= 32 && tags.every((tag) => text4(tag) && new TextEncoder().encode(tag).byteLength <= 64)), assert(new Set(tags).size === tags.length);
+  let refs = array2(entry.recordRefs === void 0 ? [] : entry.recordRefs);
+  refs.forEach((value) => {
+    let ref = object4(value);
+    keys3(ref, ["repository", "id"]), recordReference({ repository: ref.repository, ref: ref.id });
+  }), assert(new Set(refs.map((value) => {
+    let ref = object4(value);
     return JSON.stringify([ref.repository, ref.id]);
-  })).size === refs.length), entry;
+  })).size === refs.length), entry.tags = tags, entry.recordRefs = refs;
 }
 function parseInboxAcceptance(value) {
   let accepted = object4(value);
-  return assert(id2(accepted.responseId) && date(accepted.acceptedAt)), "executionId" in accepted && assert(id2(accepted.executionId)), "acceptanceOrder" in accepted && assert(integer(accepted.acceptanceOrder)), "label" in accepted && assert(text3(accepted.label)), accepted;
+  return assert(id2(accepted.responseId) && date(accepted.acceptedAt)), "executionId" in accepted && assert(id2(accepted.executionId)), "acceptanceOrder" in accepted && assert(integer(accepted.acceptanceOrder)), "label" in accepted && assert(text4(accepted.label)), accepted;
 }
 function parseInboxResult(operation2, value) {
   if (operation2 === "current") return parseInboxCurrent(value);
@@ -2181,7 +2356,7 @@ function parseInboxResult(operation2, value) {
     let candidates = array2(value);
     return candidates.forEach((value2) => {
       let person = object4(value2);
-      assert(id2(person.id) && text3(person.name) && text3(person.email));
+      assert(id2(person.id) && text4(person.name) && text4(person.email));
     }), assert(new Set(candidates.map((value2) => object4(value2).id)).size === candidates.length), candidates;
   }
   if (operation2 === "items.addRecipient") {
@@ -2191,10 +2366,10 @@ function parseInboxResult(operation2, value) {
   if (operation2 === "questions.answer") return parseInboxAcceptance(value);
   if (operation2 === "questions.searchRecords") {
     let result2 = object4(value);
-    assert(text3(result2.recordType) && integer(result2.eligibleCount, 0) && integer(result2.matchCount, 0) && Number(result2.matchCount) <= Number(result2.eligibleCount));
+    assert(text4(result2.recordType) && integer(result2.eligibleCount, 0) && integer(result2.matchCount, 0) && Number(result2.matchCount) <= Number(result2.eligibleCount));
     let labeled = (value2) => {
       let record3 = object4(value2);
-      recordReference({ repository: record3.repository, ref: record3.ref }), assert(text3(record3.label)), "reason" in record3 && assert(text3(record3.reason));
+      recordReference({ repository: record3.repository, ref: record3.ref }), assert(text4(record3.label)), "reason" in record3 && assert(text4(record3.reason));
     };
     return array2(result2.matches).forEach(labeled), array2(result2.suggestions).forEach(labeled), "selected" in result2 && labeled(result2.selected), result2;
   }
@@ -2308,7 +2483,7 @@ async function appResponse(response2, maximum, signal) {
     });
   };
   signal.addEventListener("abort", abort, { once: !0 });
-  let bytes = 0, text4 = "", decoder = new TextDecoder("utf-8", { fatal: !0 });
+  let bytes = 0, text5 = "", decoder = new TextDecoder("utf-8", { fatal: !0 });
   try {
     for (; ; ) {
       let chunk;
@@ -2319,13 +2494,13 @@ async function appResponse(response2, maximum, signal) {
       }
       if (signal.aborted) throw new Error();
       if (chunk.done) {
-        let value = JSON.parse(text4 + decoder.decode());
+        let value = JSON.parse(text5 + decoder.decode());
         if (await responseChecks.get(response2)?.(value), signal.aborted) throw new Error();
         return value;
       }
       if (bytes += chunk.value.byteLength, bytes > maximum)
         throw abort(), new Error();
-      text4 += decoder.decode(chunk.value, { stream: !0 });
+      text5 += decoder.decode(chunk.value, { stream: !0 });
     }
   } finally {
     signal.removeEventListener("abort", abort), reader.releaseLock();
@@ -2376,10 +2551,12 @@ function appContext(origin, active2) {
         credentials: "omit",
         redirect: "error",
         cache: "no-store",
+        ...init2.body instanceof ReadableStream ? { duplex: "half" } : {},
         referrerPolicy: "no-referrer",
         signal,
         headers: {
           ...init2.body === void 0 ? {} : { "content-type": "application/json" },
+          ...Object.fromEntries(new Headers(init2.headers)),
           authorization: `Bearer ${candidate}`
         }
       });
@@ -2545,11 +2722,37 @@ function appContext(origin, active2) {
   async function requestRoutine(key, suffix, init2 = {}) {
     return requestChecked(`routines/${encodeURIComponent(key)}/${suffix}`, init2);
   }
-  async function requestChecked(path, init2, inbox2 = !1) {
+  async function requestRetainedRoutine(key, suffix) {
+    return requestChecked(`routines/${encodeURIComponent(key)}/${suffix}`, {}, !1, !0);
+  }
+  async function requestFiles(suffix, init2, parent) {
+    let unavailable4 = () => new FileOperationError("unsupported_context", 400);
+    if (!current2() || !/^(?:|\/[0-9a-f-]{36}(?:\/(?:content|upload|enrichments(?:\/[^/?#]+\/content)?))?)$/i.test(suffix))
+      throw unavailable4();
+    let admitted = credential, signal = parent ? AbortSignal.any([access.signal, parent]) : access.signal, failure = () => current2() && !signal.aborted ? new FileOperationError("unavailable", 503, !0) : unavailable4();
+    try {
+      return await hostedContent("", init2, signal, (_url, request2) => untilAborted(
+        send3(`files${suffix}`, admitted, signal, request2).then((value) => {
+          if (signal.aborted)
+            throw value.body?.cancel().catch(() => {
+            }), unavailable4();
+          return value;
+        }),
+        signal
+      ), () => settledAccess(signal), failure);
+    } catch {
+      throw failure();
+    }
+  }
+  async function requestChecked(path, init2, inbox2 = !1, retained2 = !1) {
     if (!current2()) throw new Error("Local app context unavailable.");
-    let admitted = credential, signal = access.signal, response2 = await send3(path, credential, signal, init2);
-    return await settledAccess(signal), (response2.status === 401 || !inbox2 && response2.status === 403) && admitted === credential && current2() && invalidate(), responseChecks.set(response2, async (value) => {
-      await settledAccess(signal), admitted === credential && current2() && value && typeof value == "object" && "error" in value && value.error === "authority_unavailable" && invalidate();
+    let admitted = credential, signal = access.signal, response2 = await send3(path, credential, signal, init2), check = async () => {
+      if (retained2) {
+        if (signal.aborted || !current2()) throw new Error("Local app context unavailable.");
+      } else await settledAccess(signal);
+    };
+    return await check(), (response2.status === 401 || !inbox2 && response2.status === 403) && admitted === credential && current2() && invalidate(), responseChecks.set(response2, async (value) => {
+      await check(), admitted === credential && current2() && value && typeof value == "object" && "error" in value && value.error === "authority_unavailable" && invalidate();
     }), response2;
   }
   function context2() {
@@ -2566,8 +2769,10 @@ function appContext(origin, active2) {
         issued === credential && current2() && invalidate();
       },
       requestRoutine,
+      requestRetainedRoutine,
       requestData,
       requestInbox,
+      requestFiles,
       requestAvailability: (key) => requestRoutine(key, "availability", { method: "GET" })
     };
   }
@@ -2576,22 +2781,22 @@ function appContext(origin, active2) {
     try {
       if (!alive()) throw new Error();
       if (!pair) {
-        let candidate2 = stored(), retained2 = readPair(candidate2);
-        pair = retained2, binding = { ...retained2.context }, credential = retained2.credential, serialized = candidate2;
+        let candidate2 = stored(), retained3 = readPair(candidate2);
+        pair = retained3, binding = { ...retained3.context }, credential = retained3.credential, serialized = candidate2;
       }
       if (expireAccess(), binding.expiresAt <= Date.now()) {
         if (await renew(), !current2()) throw new AppRenewalUnavailable();
         return context2();
       }
       await synchronize();
-      let candidate = stored(), retained = readPair(candidate);
+      let candidate = stored(), retained2 = readPair(candidate);
       if (attempted = candidate ?? void 0, !current2()) throw new AppRenewalUnavailable();
-      let value = await proof(retained.credential);
+      let value = await proof(retained2.credential);
       if (stored() !== candidate || serialized !== candidate)
         return await synchronize(), context2();
       if (!current2()) throw new Error();
       if (expiry && binding && value.expiresAt > binding.expiresAt) throw new Error();
-      return (!expiry || value.expiresAt !== binding.expiresAt) && install(value, retained, candidate), context2();
+      return (!expiry || value.expiresAt !== binding.expiresAt) && install(value, retained2, candidate), context2();
     } catch (error) {
       if (alive() && error instanceof AppRenewalUnavailable)
         throw new Error();
@@ -2606,7 +2811,12 @@ function appContext(origin, active2) {
   }, resolve = () => resolution2 || (resolution2 = resolveOnce().finally(() => {
     resolution2 = void 0;
   }), resolution2);
-  return { resolve, start: () => {
+  return { resolve, retained: async () => {
+    if (!expiry && alive() && (binding ? current2() && resolution2 : readPair(stored()).context.expiresAt > Date.now()))
+      return resolve();
+    if (!expiry || !current2()) throw new Error("Local app context unavailable.");
+    return context2();
+  }, start: () => {
     startup = setTimeout(() => {
       alive() && !resolution2 && !binding && resolve().catch(() => {
       });
@@ -2627,9 +2837,9 @@ function validPair(value) {
   return validProof(pair.credential) && validProof(pair.renewalCredential) && pair.credential !== pair.renewalCredential && validBinding(pair.context);
 }
 
-var unavailable2 = () => new InboxOperationError(503, "unavailable"), stale = () => new InboxOperationError(401, "authority_unavailable");
+var unavailable3 = () => new InboxOperationError(503, "unavailable"), stale = () => new InboxOperationError(401, "authority_unavailable");
 function hostFailure(error, context2) {
-  return !context2.isCurrent() || context2.expiresAt <= Date.now() || error instanceof InboxContextError && error.status === 401 ? stale() : error instanceof InboxContextError && error.status === 403 ? new InboxOperationError(403, "access_denied") : unavailable2();
+  return !context2.isCurrent() || context2.expiresAt <= Date.now() || error instanceof InboxContextError && error.status === 401 ? stale() : error instanceof InboxContextError && error.status === 403 ? new InboxOperationError(403, "access_denied") : unavailable3();
 }
 async function send2(operation2, input) {
   let envelope = parseInboxRequest({ operation: operation2, input }), context2;
@@ -2649,12 +2859,12 @@ async function send2(operation2, input) {
         [400, 401, 403, 409].includes(response2.status) ? response2.status : 503,
         response2.status === 400 ? "invalid_input" : response2.status === 401 ? "authority_unavailable" : response2.status === 403 ? "access_denied" : response2.status === 409 ? "conflict" : "unavailable"
       );
-      if (response2.status !== 200) throw unavailable2();
+      if (response2.status !== 200) throw unavailable3();
       let parsed = parseInboxResult(operation2, value);
-      if (check2(), operation2 === "questions.answer" && typeof envelope.input.response.selection == "object" && !parsed.label?.trim()) throw unavailable2();
+      if (check2(), operation2 === "questions.answer" && typeof envelope.input.response.selection == "object" && !parsed.label?.trim()) throw unavailable3();
       return parsed;
     } catch (error) {
-      throw check2(), error instanceof InboxOperationError ? error : unavailable2();
+      throw check2(), error instanceof InboxOperationError ? error : unavailable3();
     }
   }
   if (context2.endpoint !== `https://${context2.workspace}.oddington.ai` || ["auth", "www", "api", "os"].includes(context2.workspace)) throw stale();
@@ -2665,7 +2875,7 @@ async function send2(operation2, input) {
     } catch (error) {
       throw hostFailure(error, context2);
     }
-    if (!host) throw unavailable2();
+    if (!host) throw unavailable3();
   }
   let check = () => {
     if (!context2.isCurrent() || host && !host.isCurrent() || !Number.isFinite(context2.expiresAt) || context2.expiresAt <= Date.now()) throw stale();
@@ -2695,9 +2905,9 @@ async function send2(operation2, input) {
       );
     if (response2.status !== 200)
       throw response2.body?.cancel().catch(() => {
-      }), unavailable2();
+      }), unavailable3();
     if (operation2 === "files.read") {
-      if (!response2.body) throw unavailable2();
+      if (!response2.body) throw unavailable3();
       let source = response2.body, reader, size = 0, cancel = async (reason) => {
         try {
           await (reader ? reader.cancel(reason) : source.cancel(reason));
@@ -2713,7 +2923,7 @@ async function send2(operation2, input) {
               reader.releaseLock(), controller.close();
               return;
             }
-            if (size += next.value.byteLength, size > 25 * 1024 * 1024) throw unavailable2();
+            if (size += next.value.byteLength, size > 25 * 1024 * 1024) throw unavailable3();
             controller.enqueue(next.value);
           } catch (error) {
             controller.error(error), await cancel(error).catch(() => {
@@ -2725,16 +2935,16 @@ async function send2(operation2, input) {
       return new Response(body, { status: response2.status, headers: response2.headers });
     }
     let bytes = await limitedBody(response2, INBOX_RESULT_BYTES);
-    if (check(), !bytes) throw unavailable2();
+    if (check(), !bytes) throw unavailable3();
     let value = JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(bytes)), parsed = parseInboxResult(operation2, value);
-    if (check(), operation2 === "current" && parsed.workspace.slug !== context2.workspace) throw unavailable2();
+    if (check(), operation2 === "current" && parsed.workspace.slug !== context2.workspace) throw unavailable3();
     if ("itemId" in envelope.input) {
       let item = operation2 === "items.read" ? parsed : operation2 === "items.rename" || operation2 === "items.setLifecycle" || operation2 === "items.addRecipient" ? parsed.item : void 0;
-      if (item && (item.id !== envelope.input.itemId || "revision" in envelope.input && item.revision !== envelope.input.revision) || operation2 === "items.addRecipient" && parsed.addedPersonId !== envelope.input.personId || operation2 === "questions.answer" && typeof envelope.input.response.selection == "object" && !parsed.label?.trim()) throw unavailable2();
+      if (item && (item.id !== envelope.input.itemId || "revision" in envelope.input && item.revision !== envelope.input.revision) || operation2 === "items.addRecipient" && parsed.addedPersonId !== envelope.input.personId || operation2 === "questions.answer" && typeof envelope.input.response.selection == "object" && !parsed.label?.trim()) throw unavailable3();
     }
     return parsed;
   } catch (error) {
-    throw check(), error instanceof InboxOperationError ? error : unavailable2();
+    throw check(), error instanceof InboxOperationError ? error : unavailable3();
   }
 }
 var inbox = {
@@ -2754,14 +2964,14 @@ var inbox = {
         throw hostFailure(error, initial);
       }
       if (initial.kind === "local") throw new InboxOperationError(403, "access_denied");
-      if (!host) throw unavailable2();
+      if (!host) throw unavailable3();
       let check = () => {
         if (!initial.isCurrent() || !host.isCurrent() || initial.expiresAt <= Date.now()) throw stale();
       };
       do {
         check();
         let page = await send2("items.list", beforeNumber === void 0 ? {} : { beforeNumber });
-        if (check(), beforeNumber !== void 0 && (page.items.some((item) => item.number >= beforeNumber) || page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber)) throw unavailable2();
+        if (check(), beforeNumber !== void 0 && (page.items.some((item) => item.number >= beforeNumber) || page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber)) throw unavailable3();
         if (items.push(...page.items), page.nextBeforeNumber === null) return items;
         beforeNumber = page.nextBeforeNumber;
       } while (!0);
@@ -2795,7 +3005,7 @@ var inbox = {
           routines,
           ...beforeNumber === void 0 ? {} : { beforeNumber }
         });
-        if (check(), page.questions.some((question2) => question2.inboxUrl !== `https://${initial.workspace}.oddington.ai/inbox/${question2.itemId}` || !routines.includes(question2.routine)) || beforeNumber !== void 0 && page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber) throw unavailable2();
+        if (check(), page.questions.some((question2) => question2.inboxUrl !== `https://${initial.workspace}.oddington.ai/inbox/${question2.itemId}` || !routines.includes(question2.routine)) || beforeNumber !== void 0 && page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber) throw unavailable3();
         if (questions.push(...page.questions), page.nextBeforeNumber === null) return questions;
         beforeNumber = page.nextBeforeNumber;
       } while (!0);
@@ -2832,8 +3042,8 @@ function init({ auth: input }) {
     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, token, binding = {}, local2 = localOrigin ? appContext(localOrigin, () => active2) : void 0, subscription, stopDisposal, uninstall = installMemberContext(async () => {
-    if (local2) return local2.resolve();
+  let active2 = !0, revision = 0, person, token, binding = {}, local3 = localOrigin ? appContext(localOrigin, () => active2) : void 0, subscription, stopDisposal, resolve = async () => {
+    if (local3) return local3.resolve();
     if (!active2 || !endpoint || !workspace || globalThis.location.origin !== endpoint) throw new Error("Hosted Data context unavailable.");
     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)
@@ -2852,13 +3062,13 @@ function init({ auth: input }) {
       memberId: session.user.id,
       binding
     };
-  }), dispose = () => {
-    active2 && (active2 = !1, local2?.dispose(), revision++, subscription?.unsubscribe(), stopDisposal?.(), uninstall(), installedDispose === dispose && (installedDispose = void 0));
+  }, uninstall = installMemberContext(resolve, local3 ? local3.retained : resolve), dispose = () => {
+    active2 && (active2 = !1, local3?.dispose(), revision++, subscription?.unsubscribe(), stopDisposal?.(), uninstall(), installedDispose === dispose && (installedDispose = void 0));
   };
   installedDispose = dispose, stopDisposal = registered?.onDispose(dispose), active2 && (subscription = auth2.onAuthStateChange((event, session) => {
     let next = session?.user.id ?? null;
-    (event === "SIGNED_OUT" || person !== void 0 && next !== person || registered && person !== void 0 && event === "SIGNED_IN" && token !== session?.access_token) && (revision++, local2?.invalidate()), person = next, token = session?.access_token;
-  }).data.subscription, local2?.start());
+    (event === "SIGNED_OUT" || person !== void 0 && next !== person || registered && person !== void 0 && event === "SIGNED_IN" && token !== session?.access_token) && (revision++, local3?.invalidate()), person = next, token = session?.access_token;
+  }).data.subscription, local3?.start());
 }
 var os = { init };
 
@@ -3303,16 +3513,16 @@ function current(context2) {
 function appDescriptors() {
   return globalThis[/* @__PURE__ */ Symbol.for("oddington.app.descriptor")]?.routines ?? [];
 }
-async function local() {
-  let context2 = await resolveAppContext().catch(() => fail3("authority_unavailable"));
+async function local2(retained = !1) {
+  let context2 = await resolveAppContext(retained).catch(() => fail3("authority_unavailable"));
   return context2.kind !== "local" ? fail3("execution_unavailable") : (current(context2), context2);
 }
-async function request(key, suffix, init2, maximum = SUMMARY_BYTES, retained) {
+async function request(key, suffix, init2, maximum = SUMMARY_BYTES, retained, read2 = !1) {
   (!identifier.test(key) || !appDescriptors().some((item) => item.id === key)) && fail3("authority_unavailable");
-  let context2 = retained ?? await local();
+  let context2 = retained ?? await local2(read2);
   current(context2);
   try {
-    let response2 = await context2.requestRoutine(key, suffix, init2), value = await appResponse(response2, maximum, context2.signal);
+    let response2 = await (read2 ? context2.requestRetainedRoutine(key, suffix) : context2.requestRoutine(key, suffix, init2)), value = await appResponse(response2, maximum, context2.signal);
     if (current(context2), !response2.ok) {
       let reason = value?.error;
       reason === "authority_unavailable" && (context2.invalidate(), fail3(reason)), (reason === "invalid_input" || reason === "execution_unavailable") && fail3(reason), fail3("execution_unavailable");
@@ -3358,11 +3568,15 @@ function structure(value) {
   return JSON.stringify(value, (_key, item) => item && typeof item == "object" && !Array.isArray(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]])) : item);
 }
 function handle(key, id3, context2) {
-  return (typeof id3 != "string" || !uuid.test(id3)) && fail3("invalid_input"), routineRunHandle({
-    current: async () => summary(await request(key, `runs/${id3}`, void 0, SUMMARY_BYTES, context2), key, id3),
+  (!identifier.test(key) || !appDescriptors().some((item) => item.id === key)) && fail3("authority_unavailable"), (typeof id3 != "string" || !uuid.test(id3)) && fail3("invalid_input");
+  let read2 = async () => summary(await request(key, `runs/${id3}`, void 0, SUMMARY_BYTES, context2, !0), key, id3);
+  return routineRunHandle({
+    async current() {
+      return current(context2), read2();
+    },
     async step(step) {
       (typeof step != "string" || !identifier.test(step)) && fail3("invalid_input");
-      let value = await request(key, `runs/${id3}/steps/${step}`, void 0, 514 * 1024, context2);
+      let value = await request(key, `runs/${id3}/steps/${step}`, void 0, 514 * 1024, context2, !0);
       return (!only(value, "id,title,status,startedAt,finishedAt,summary,data") || value.id !== step || !validStep(value)) && fail3("execution_unavailable"), value;
     },
     async publish() {
@@ -3373,7 +3587,7 @@ function handle(key, id3, context2) {
 async function describeAppRoutine(key) {
   let descriptor = appDescriptors().find((item) => item.id === key);
   if (!descriptor) return fail3("authority_unavailable");
-  let unavailable3 = () => ({
+  let unavailable4 = () => ({
     ...structuredClone(descriptor),
     connections: descriptor.connections.map((connection) => ({ ...connection, available: !1 })),
     readiness: { state: "unavailable", reason: "capability_unavailable", message: "Routine capability unavailable." }
@@ -3382,11 +3596,11 @@ async function describeAppRoutine(key) {
     let value = await request(key, "describe", void 0, 1048576);
     return (!only(value, "id,title,input,connections,steps,readiness") || !value.readiness || !Array.isArray(value.connections) || structure({ ...value, readiness: void 0, connections: value.connections.map(({ available, ...item }) => item) }) !== structure(descriptor) || value.connections.some((item) => typeof item.available != "boolean") || !(value.readiness.state === "ready" && only(value.readiness, "state,placement") && value.readiness.placement === "local" || value.readiness.state === "unavailable" && only(value.readiness, "state,reason,message") && ["not_deployed", "definition_invalid", "capability_unavailable"].includes(value.readiness.reason) && message(value.readiness.message))) && fail3("execution_unavailable"), value;
   } catch {
-    return unavailable3();
+    return unavailable4();
   }
 }
 function appRoutineBinding(key) {
-  return Object.freeze({
+  return (typeof key != "string" || !identifier.test(key) || !appDescriptors().some((item) => item.id === key)) && fail3("authority_unavailable"), Object.freeze({
     describe: () => describeAppRoutine(key),
     async run(...args) {
       args.length > 1 && fail3("invalid_input");
@@ -3401,19 +3615,18 @@ function appRoutineBinding(key) {
       } catch {
         return fail3("invalid_input");
       }
-      let context2 = await local(), run = summary(await request(key, "runs", { method: "POST", body: encoded }, SUMMARY_BYTES, context2), key);
+      let context2 = await local2(), run = summary(await request(key, "runs", { method: "POST", body: encoded }, SUMMARY_BYTES, context2), key);
       return handle(key, run.id, context2);
     },
     runs: Object.freeze({
       async list() {
-        let value = await request(key, "runs", void 0, 20 * SUMMARY_BYTES);
+        let value = await request(key, "runs", void 0, 20 * SUMMARY_BYTES, void 0, !0);
         if (!Array.isArray(value) || value.length > 20) return fail3("execution_unavailable");
         let runs = value.map((run) => summary(run, key));
         return new Set(runs.map((run) => run.id)).size !== runs.length && fail3("execution_unavailable"), runs;
       },
       async get(id3) {
-        let run = handle(key, id3, await local());
-        return await run.current(), run;
+        return (typeof id3 != "string" || !uuid.test(id3)) && fail3("invalid_input"), (!identifier.test(key) || !appDescriptors().some((item) => item.id === key)) && fail3("authority_unavailable"), handle(key, id3, await local2(!0));
       }
     })
   });
@@ -3421,6 +3634,7 @@ function appRoutineBinding(key) {
 
 var app = Object.freeze({
   listRoutines: () => Promise.all(appDescriptors().map(({ id: id3 }) => describeAppRoutine(id3))),
+  routine: appRoutineBinding,
   routines: new Proxy(/* @__PURE__ */ Object.create(null), {
     get(_target, key) {
       if (!(typeof key != "string" || !appDescriptors().some((item) => item.id === key)))
@@ -3460,10 +3674,10 @@ function routineDataEnvelope(command) {
 }
 
 function routinePublicationClient2(options = {}) {
-  let environment = {}, installed2 = routineTransport(), local2 = installed2?.request ?? void 0, workspace = installed2 ? "installed" : options.workspace ?? environment.ODDINGTON_ROUTINE_WORKSPACE, capability = options.capability ?? environment.ODDINGTON_ROUTINE_RUN;
+  let environment = {}, installed2 = routineTransport(), local3 = installed2?.request ?? void 0, workspace = installed2 ? "installed" : options.workspace ?? environment.OS_ROUTINE_WORKSPACE, capability = options.capability ?? environment.OS_ROUTINE_RUN;
   if (!workspace || !/^[a-z0-9][a-z0-9-]*$/.test(workspace) || capability !== void 0 && !/^[0-9a-f]{64}$/.test(capability))
     throw new Error("A workspace and valid optional routine capability are required");
-  let workingRoot = options.workingRoot ?? environment.ODDINGTON_INBOX_WORKING_ROOT ?? void 0, headers = capability ? { "x-oddington-run": capability } : {}, request2 = options.request ?? (capability ? async (path, init2) => {
+  let workingRoot = options.workingRoot ?? environment.OS_INBOX_WORKING_ROOT ?? void 0, headers = capability ? { "x-os-run": capability } : {}, request2 = options.request ?? (capability ? async (path, init2) => {
     if (path === "/api/data") return fetch(`https://${workspace}.oddington.ai/api/data`, { ...init2, redirect: "error" });
     let origin = `https://${workspace}.oddington.ai`, target = new URL(path, `${origin}/`);
     if (workspace.length > 63 || ["auth", "www", "api", "os"].includes(workspace) || target.origin !== origin || target.search || target.hash || target.username || target.password || !/^\/api\/inbox\/(check|publish|resolve|files)$/.test(path) || init2?.method !== "POST")
@@ -3473,13 +3687,13 @@ function routinePublicationClient2(options = {}) {
     throw new Error("Member publication requires a host-supplied request");
   });
   async function send3(operation2, body) {
-    if (local2) return await local2(operation2, body);
+    if (local3) return await local3(operation2, body);
     let writing = operation2 === "records/update", reading = operation2 === "records/read", response2 = await request2(writing || reading ? "/api/data" : `/api/inbox/${operation2}`, {
       method: "POST",
       headers: {
         "content-type": "application/json",
         ...headers,
-        ...writing || reading ? { "x-oddington-workspace": workspace, "x-oddington-captured-records": "1" } : {}
+        ...writing || reading ? { "x-os-workspace": workspace, "x-os-captured-records": "1" } : {}
       },
       body: JSON.stringify(writing ? routineDataEnvelope(validateRoutineRecordWrite(body)) : reading ? { operation: "records.select", request: validateRecordRead(body) } : body)
     }), result2 = await response2.json();
@@ -3520,7 +3734,7 @@ function routinePublicationClient2(options = {}) {
     files: {
       async add(value) {
         let input = validateFileAddOptions(value);
-        if (local2) return validateInboxFile(await local2("files/add", input));
+        if (local3) return validateInboxFile(await local3("files/add", input));
         throw workingRoot ? new Error("Inbox file reads require a Node working root") : new Error("Inbox file reads require a working root");
       }
     },