@oddington/sdk 0.1.12 → 0.1.14

package/dist/browser.js

@@ -269,8 +269,8 @@ function presentation(source) {
   });
   new Set(views.map((view) => view.id)).size !== views.length && fail("Duplicate view ID");
   let body2 = source.body === void 0 ? [] : array(source.body, "body").map(validateBlock);
-  for (let block of body2) {
-    let targets = block.kind === "record" ? [block.view] : block.kind === "records" ? [block.view, ...block.records.map((record3) => record3.view)] : [];
+  for (let block2 of body2) {
+    let targets = block2.kind === "record" ? [block2.view] : block2.kind === "records" ? [block2.view, ...block2.records.map((record3) => record3.view)] : [];
     for (let target of targets) target !== void 0 && !views.some((view) => view.id === target) && fail(`Unknown Block View target: ${target}`);
   }
   return { title: text(source.title, "title"), description: text(source.description, "description"), views, body: body2 };
@@ -287,13 +287,13 @@ function validatePublication(value) {
     "notifyImmediately",
     ...source.kind === "ask" ? ["questions"] : []
   ], "publication"), source.notifyImmediately !== void 0 && typeof source.notifyImmediately != "boolean" && fail("notifyImmediately must be a boolean");
-  let itemPresentation = { ...presentation(source), ...source.notifyImmediately === void 0 ? {} : { notifyImmediately: source.notifyImmediately } }, linkedAsks = (itemPresentation.body ?? []).flatMap((block) => block.kind === "asks" ? block.asks : []);
+  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 {
     kind: "digest",
     ...itemPresentation,
     recipients: distinctPeople(source.recipients, "digest recipients")
   };
-  itemPresentation.body?.some((block) => block.kind === "asks") && fail("Asks Blocks belong to Digests");
+  itemPresentation.body?.some((block2) => block2.kind === "asks") && fail("Asks Blocks belong to Digests");
   let questions = array(source.questions === void 0 ? [] : source.questions, "questions").map((value2) => question(value2));
   new Set(questions.map((entry) => entry.id)).size !== questions.length && fail("Duplicate question ID");
   let extra = source.recipients === void 0 ? [] : distinctPeople(source.recipients, "recipients", !1);
@@ -583,13 +583,13 @@ function freeze(value) {
 function json(value, ancestors = /* @__PURE__ */ new Set()) {
   if (value === null || typeof value == "string" || typeof value == "boolean" || typeof value == "number" && Number.isFinite(value)) return;
   if (!value || typeof value != "object" || ancestors.has(value)) return invalid();
-  let array2 = Array.isArray(value);
-  if (!array2 && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return invalid();
-  let keys4 = Reflect.ownKeys(value);
-  if (array2 && (keys4.length !== value.length + 1 || !Array.from({ length: value.length }, (_, index) => Object.hasOwn(value, index)).every(Boolean))) return invalid();
+  let array3 = Array.isArray(value);
+  if (!array3 && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return invalid();
+  let keys5 = Reflect.ownKeys(value);
+  if (array3 && (keys5.length !== value.length + 1 || !Array.from({ length: value.length }, (_, index) => Object.hasOwn(value, index)).every(Boolean))) return invalid();
   ancestors.add(value);
-  for (let key of keys4) {
-    if (array2 && key === "length") continue;
+  for (let key of keys5) {
+    if (array3 && key === "length") continue;
     if (typeof key != "string") return invalid();
     let descriptor2 = Object.getOwnPropertyDescriptor(value, key);
     if (!descriptor2.enumerable || !Object.hasOwn(descriptor2, "value")) return invalid();
@@ -638,7 +638,7 @@ var schema = {
     return invalidContract2();
   }
   if (definition.steps !== void 0 && (!definition.steps || typeof definition.steps != "object" || Array.isArray(definition.steps))) return invalidContract2();
-  let steps = definition.steps === void 0 ? [] : Object.entries(definition.steps).map(([id2, summary]) => ({ id: id2, ...summary === null ? {} : { summary } })), parsed = parseAppRoutineContract({
+  let steps = definition.steps === void 0 ? [] : Object.entries(definition.steps).map(([id3, summary]) => ({ id: id3, ...summary === null ? {} : { summary } })), parsed = parseAppRoutineContract({
     routine: "definition",
     input: definition.input === void 0 ? empty : definition.input,
     steps: steps.length ? steps : [{ id: "inspect" }],
@@ -669,12 +669,12 @@ async function executeRoutineDefinition(definition, input, runtime) {
   let captured = captureRoutineInput(definition, input), { contract, run } = definitions.get(definition), active2 = !0, broken = !1, reports = Promise.resolve(), os2 = Object.freeze({
     ...runtime,
     run: freeze({ ...runtime.run }),
-    step(id2, ...summary) {
+    step(id3, ...summary) {
       if (!active2 || broken || summary.length > 1)
         return broken = !0, Promise.reject(new AppRoutineContractError("invalid_value"));
       let value;
       try {
-        let step = contract.steps.find((step2) => step2.id === id2);
+        let step = contract.steps.find((step2) => step2.id === id3);
         if (!step) return invalid();
         if (step.summary === void 0) {
           if (summary.length) return invalid();
@@ -682,7 +682,7 @@ async function executeRoutineDefinition(definition, input, runtime) {
       } catch (error) {
         return broken = !0, Promise.reject(error);
       }
-      let report = reports.then(() => broken ? invalid() : runtime.step(id2, value));
+      let report = reports.then(() => broken ? invalid() : runtime.step(id3, value));
       return reports = report.catch(() => {
         broken = !0;
       }), report;
@@ -821,8 +821,8 @@ function captureDataDelete(record3) {
   return !validRecordRef(identity.$ref) || typeof identity.$version != "string" || !identity.$version.length || identity.$version.length > 512 ? invalidChange() : { ref: identity.$ref, expectedVersion: identity.$version };
 }
 function captureDataUpdate(record3, set) {
-  let identity = captureDataDelete(record3), fields4 = mapping(set);
-  return !Object.keys(fields4).length || Object.keys(fields4).some((key) => key.startsWith("$") || ["id", "type"].includes(key)) ? invalidChange() : { ...identity, set: captureValue(fields4) };
+  let identity = captureDataDelete(record3), fields5 = mapping(set);
+  return !Object.keys(fields5).length || Object.keys(fields5).some((key) => key.startsWith("$") || ["id", "type"].includes(key)) ? invalidChange() : { ...identity, set: captureValue(fields5) };
 }
 function captureIdentities(value, update, allowEmpty = !0) {
   if (!Array.isArray(value) || !allowEmpty && !value.length || value.length > 1e4) return invalidChange();
@@ -841,14 +841,14 @@ function captureDataCreate(value) {
   let row = mapping(value);
   if (!validRecordRef(row.$ref) || Object.keys(row).some((key) => key.startsWith("$") && !["$ref", "$filing"].includes(key)))
     return invalidChange();
-  let { $ref: ref, $filing, ...fields4 } = row, filing;
+  let { $ref: ref, $filing, ...fields5 } = row, filing;
   if ($filing !== void 0) {
     let components = mapping($filing);
     if (Object.entries(components).some(([name, value2]) => !/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name) || ["constructor", "prototype"].includes(name) || typeof value2 != "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value2)))
       return invalidChange();
     filing = { ...components };
   }
-  return { ref, fields: captureValue(fields4), ...filing ? { filing } : {} };
+  return { ref, fields: captureValue(fields5), ...filing ? { filing } : {} };
 }
 function captureDataChanges(updatesValue, createsValue = [], deletesValue = []) {
   let updates = captureDataUpdates(updatesValue, !0);
@@ -856,8 +856,8 @@ function captureDataChanges(updatesValue, createsValue = [], deletesValue = [])
   let creates = createsValue.map((item) => {
     let row = mapping(item);
     if (Object.keys(row).some((key) => !["ref", "fields", "filing"].includes(key)) || !Object.hasOwn(row, "ref") || !Object.hasOwn(row, "fields")) return invalidChange();
-    let fields4 = mapping(row.fields);
-    return Object.keys(fields4).some((key) => key.startsWith("$")) ? invalidChange() : captureDataCreate({ ...fields4, $ref: row.ref, ...Object.hasOwn(row, "filing") ? { $filing: row.filing } : {} });
+    let fields5 = mapping(row.fields);
+    return Object.keys(fields5).some((key) => key.startsWith("$")) ? invalidChange() : captureDataCreate({ ...fields5, $ref: row.ref, ...Object.hasOwn(row, "filing") ? { $filing: row.filing } : {} });
   }), deletes = captureIdentities(deletesValue, !1), refs = [...updates, ...creates, ...deletes].map((item) => item.ref);
   return !refs.length || refs.length > 1e4 || new Set(refs).size !== refs.length ? invalidChange() : { updates, creates, deletes };
 }
@@ -953,20 +953,20 @@ function checked(workspace, endpoint, headers) {
 
 var data = {
   repository(repository) {
-    async function send2(input) {
+    async function send3(input) {
       let context2 = await resolveDataContext();
       try {
         let envelope = { repository, ...input };
         if (checkDataRequestSize(envelope), "local" in context2) return await context2.local("data/query", envelope);
-        let response = await fetch(context2.url, {
+        let response2 = await fetch(context2.url, {
           method: "POST",
           redirect: "error",
           cache: "no-store",
           headers: { "content-type": "application/json", ...context2.headers },
           body: JSON.stringify(envelope)
-        }), result2 = await response.json();
-        if (!response.ok)
-          throw dataTransportError(response.status, result2);
+        }), result2 = await response2.json();
+        if (!response2.ok)
+          throw dataTransportError(response2.status, result2);
         return result2;
       } catch (error) {
         throw error instanceof DataOperationError ? error : new DataOperationError("unavailable", !0);
@@ -974,17 +974,17 @@ var data = {
     }
     return {
       collections: {
-        list: () => send2({ operation: "collections.list" }),
-        schema: (name) => send2({ operation: "collections.schema", name })
+        list: () => send3({ operation: "collections.list" }),
+        schema: (name) => send3({ operation: "collections.schema", name })
       },
       records: {
-        select: (query) => send2({ operation: "records.select", query }),
-        search: async (query, options) => send2({ operation: "records.search", ...captureRecordsSearchInput(query, options) })
+        select: (query) => send3({ operation: "records.select", query }),
+        search: async (query, options) => send3({ operation: "records.search", ...captureRecordsSearchInput(query, options) })
       },
       history: {
-        list: async (options) => send2({ operation: "history.list", options: captureHistoryListOptions(options) }),
-        at: async (instant) => send2({ operation: "history.at", instant: captureHistoryInstant(instant) }),
-        changes: async (options) => send2({ operation: "history.changes", options: captureHistoryChangesOptions(options) })
+        list: async (options) => send3({ operation: "history.list", options: captureHistoryListOptions(options) }),
+        at: async (instant) => send3({ operation: "history.at", instant: captureHistoryInstant(instant) }),
+        changes: async (options) => send3({ operation: "history.changes", options: captureHistoryChangesOptions(options) })
       },
       changes() {
         let updates = [], creates = [], deletes = [], publicationId, pending, confirmed, assertMutable = () => {
@@ -1015,7 +1015,7 @@ var data = {
             snapshot(updates, creates, next), deletes = next;
           },
           async validate() {
-            await send2({ operation: "changes.validate", ...snapshot() });
+            await send3({ operation: "changes.validate", ...snapshot() });
           },
           publish() {
             if (confirmed) return Promise.resolve(structuredClone(confirmed));
@@ -1026,7 +1026,7 @@ var data = {
               } catch (error) {
                 return Promise.reject(error);
               }
-              publicationId ??= crypto.randomUUID(), pending = send2({ operation: "changes.publish", ...captured, publicationId }).then((result2) => (confirmed = structuredClone(result2), result2)).catch((error) => {
+              publicationId ??= crypto.randomUUID(), pending = send3({ operation: "changes.publish", ...captured, publicationId }).then((result2) => (confirmed = structuredClone(result2), result2)).catch((error) => {
                 throw error instanceof DataOperationError ? new DataOperationError(
                   error.code,
                   error.retryable,
@@ -1083,9 +1083,9 @@ async function timed(work, parent, timeout = TIMEOUT_MS) {
     clearTimeout(timer), parent?.removeEventListener("abort", abort);
   }
 }
-async function result(response, maximum = RESULT_BYTES) {
+async function result(response2, maximum = RESULT_BYTES) {
   try {
-    let bytes = await boundedBytes(response.body, maximum);
+    let bytes = await boundedBytes(response2.body, maximum);
     return JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(bytes));
   } catch {
     throw unavailable();
@@ -1096,13 +1096,13 @@ async function hostedContent(url, init2, parent, upstream = fetch) {
   parent.addEventListener("abort", abort, { once: !0 }), parent.aborted && abort();
   let detach = () => parent.removeEventListener("abort", abort);
   try {
-    let response = await upstream(url, { ...init2, signal: delivery.signal });
+    let response2 = await upstream(url, { ...init2, signal: delivery.signal });
     if (delivery.signal.aborted)
-      throw response.body?.cancel().catch(() => {
+      throw response2.body?.cancel().catch(() => {
       }), unavailable();
-    if (!response.body)
-      return detach(), response;
-    let source = response.body, reader, settled = !1, cancel = async (reason) => {
+    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 {
@@ -1127,9 +1127,9 @@ async function hostedContent(url, init2, parent, upstream = fetch) {
         }
       },
       cancel
-    }, { highWaterMark: 0 }), wrapped = new Response(body2, { status: response.status, statusText: response.statusText, headers: response.headers });
+    }, { highWaterMark: 0 }), wrapped = new Response(body2, { status: response2.status, statusText: response2.statusText, headers: response2.headers });
     for (let key of ["url", "redirected", "type"])
-      Object.defineProperty(wrapped, key, { value: response[key] });
+      Object.defineProperty(wrapped, key, { value: response2[key] });
     return wrapped;
   } catch (error) {
     throw detach(), delivery.abort(error), error;
@@ -1145,7 +1145,7 @@ async function send(suffix, init2, descriptor2, initial, parent) {
     let context2 = await resolveFilesContext();
     checkCurrent(context2);
     try {
-      let response = await (async () => {
+      let response2 = await (async () => {
         let url = `${context2.url}${suffix}`, request = {
           ...init2,
           signal: parent,
@@ -1155,22 +1155,22 @@ async function send(suffix, init2, descriptor2, initial, parent) {
         };
         return descriptor2 ? fetch(url, request) : hostedContent(url, request, parent);
       })();
-      if (!response.ok) {
-        let value2 = await result(response), error = value2 && typeof value2 == "object" && "error" in value2 ? value2.error : void 0, received = error && typeof error == "object" && "code" in error ? error.code : void 0, code = failures[response.status]?.find((code2) => code2 === received);
-        throw code ? new FileOperationError(code, response.status, code === "capacity" || code === "unavailable") : unavailable();
+      if (!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();
       }
-      if (response.status !== (descriptor2 === 204 ? 204 : 200) || descriptor2 === 204 && response.body !== null)
-        throw response.body?.cancel().catch(() => {
+      if (response2.status !== (descriptor2 === 204 ? 204 : 200) || descriptor2 === 204 && response2.body !== null)
+        throw response2.body?.cancel().catch(() => {
         }), unavailable();
       try {
         checkCurrent();
       } catch (error) {
-        throw response.body?.cancel().catch(() => {
+        throw response2.body?.cancel().catch(() => {
         }), error;
       }
       if (descriptor2 === 204) return;
-      if (!descriptor2) return response;
-      let value = await result(response, descriptor2 === "control" ? CONTROL_RESULT_BYTES : RESULT_BYTES);
+      if (!descriptor2) return response2;
+      let value = await result(response2, descriptor2 === "control" ? CONTROL_RESULT_BYTES : RESULT_BYTES);
       if (descriptor2 === "control")
         return checkCurrent(), value;
       let parsed;
@@ -1188,9 +1188,9 @@ async function send(suffix, init2, descriptor2, initial, parent) {
   }
   throw unavailable();
 }
-function idPath(id2) {
-  if (typeof id2 != "string" || !FILE_ID_PATTERN.test(id2)) throw invalid4();
-  return `/${id2}`;
+function idPath(id3) {
+  if (typeof id3 != "string" || !FILE_ID_PATTERN.test(id3)) throw invalid4();
+  return `/${id3}`;
 }
 async function multipartCreate(input, metadata, exchange, release = () => {
   active--;
@@ -1292,16 +1292,16 @@ async function operation(work, initial, parent) {
     throw error instanceof FileOperationError ? error : unavailable();
   });
 }
-function contentPath(id2, name) {
-  let path = idPath(id2);
+function contentPath(id3, name) {
+  let path = idPath(id3);
   if (name === void 0) return `${path}/content`;
   if (!safeEnrichmentName(name)) throw invalid4();
   return `${path}/enrichments/${encodeURIComponent(name)}/content`;
 }
-async function read(id2, names) {
+async function read(id3, names) {
   let context2 = await resolveFilesContext();
-  if (idPath(id2), names === void 0 || typeof names == "string") {
-    let path = contentPath(id2, names);
+  if (idPath(id3), names === void 0 || typeof names == "string") {
+    let path = contentPath(id3, names);
     return operation((context3, signal) => send(path, { method: "GET" }, !1, context3, signal), context2);
   }
   if (!Array.isArray(names)) throw invalid4();
@@ -1313,31 +1313,31 @@ async function read(id2, names) {
       seen.add(name), distinct.push(name);
     }
   }
-  let paths = distinct.map((name) => contentPath(id2, name));
+  let paths = distinct.map((name) => contentPath(id3, name));
   return timed(async (parent) => {
     let responses = {};
     try {
       for (let i = 0; i < paths.length; i++) {
-        let response = await operation((context3, signal) => send(paths[i], { method: "GET" }, !1, context3, signal), context2, parent);
-        Object.defineProperty(responses, distinct[i], { value: response, enumerable: !0 });
+        let response2 = await operation((context3, signal) => send(paths[i], { method: "GET" }, !1, context3, signal), context2, parent);
+        Object.defineProperty(responses, distinct[i], { value: response2, enumerable: !0 });
       }
       if (!context2.isCurrent()) throw new FileOperationError("unsupported_context", 400);
       return responses;
     } catch (error) {
-      for (let response of Object.values(responses)) response.body?.cancel().catch(() => {
+      for (let response2 of Object.values(responses)) response2.body?.cancel().catch(() => {
       });
       throw error;
     }
   });
 }
 var files = {
-  delete(id2) {
-    return operation((context2, signal) => send(idPath(id2), { method: "DELETE" }, 204, context2, signal));
+  delete(id3) {
+    return operation((context2, signal) => send(idPath(id3), { method: "DELETE" }, 204, context2, signal));
   },
-  async upload(id2) {
+  async upload(id3) {
     return operation(async (context2, signal) => {
-      let file2 = await send(`${idPath(id2)}/upload`, { method: "POST" }, !0, context2, signal);
-      if (file2.id !== id2) throw unavailable();
+      let file2 = await send(`${idPath(id3)}/upload`, { method: "POST" }, !0, context2, signal);
+      if (file2.id !== id3) throw unavailable();
       return file2;
     });
   },
@@ -1345,9 +1345,9 @@ var files = {
     let context2 = await resolveFilesContext();
     if (!input || typeof input != "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "size", "path", "name", "storage", "csv"].includes(key)) || options !== void 0 && (!options || typeof options != "object" || Array.isArray(options) || Object.keys(options).some((key) => key !== "requestKey")))
       throw invalid4();
-    let blob = input.file instanceof Blob, array2 = input.file instanceof Uint8Array, stream = input.file instanceof ReadableStream;
-    if (!blob && !array2 && !stream) throw invalid4();
-    let intrinsic = blob ? input.file.size : array2 ? input.file.byteLength : void 0;
+    let blob = input.file instanceof Blob, array3 = input.file instanceof Uint8Array, stream = input.file instanceof ReadableStream;
+    if (!blob && !array3 && !stream) throw invalid4();
+    let intrinsic = blob ? input.file.size : array3 ? input.file.byteLength : void 0;
     if (intrinsic !== void 0 && input.size !== void 0 && input.size !== intrinsic) throw invalid4();
     let name = input.name;
     name === void 0 && blob && "name" in input.file && typeof input.file.name == "string" && (name = typeof globalThis.File < "u" && input.file instanceof globalThis.File ? input.file.name : input.file.name.split(/[\\/]/).at(-1));
@@ -1366,7 +1366,7 @@ var files = {
     if (active >= MAX_ACTIVE) throw new FileOperationError("capacity", 429, !0);
     return active++, metadata.size > MAX_BYTES ? multipartCreate(input, metadata, (suffix, init2, kind, signal) => kind === !0 ? send(suffix, init2, !0, context2, signal) : send(suffix, init2, "control", context2, signal)) : timed(async (signal) => {
       try {
-        let bytes = array2 ? input.file.slice() : await boundedBytes(
+        let bytes = array3 ? input.file.slice() : await boundedBytes(
           blob ? input.file.stream() : input.file,
           metadata.size
         );
@@ -1412,8 +1412,8 @@ var files = {
       return result2;
     }, context2);
   },
-  async get(id2) {
-    return operation((context2, signal) => send(idPath(id2), { method: "GET" }, !0, context2, signal));
+  async get(id3) {
+    return operation((context2, signal) => send(idPath(id3), { method: "GET" }, !0, context2, signal));
   },
   read
 };
@@ -1515,12 +1515,12 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
     baseId,
     table: input.table,
     operation: operation2.slice(8),
-    records: ids2.map((id2) => ({ id: id2 }))
+    records: ids2.map((id3) => ({ id: id3 }))
   });
   async function request(path2, init2 = {}, write = !1) {
-    let response;
+    let response2;
     try {
-      response = await (options.fetch ?? fetch)(`https://api.airtable.com/v0/${path2}`, {
+      response2 = await (options.fetch ?? fetch)(`https://api.airtable.com/v0/${path2}`, {
         ...init2,
         headers: { authorization: `Bearer ${accessToken}`, "content-type": "application/json" },
         redirect: "manual",
@@ -1529,12 +1529,12 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
     } catch {
       throw new AirtableOperationError("Airtable request acknowledgment unavailable", write ? "uncertain" : "unapplied");
     }
-    if (!response.ok)
-      throw await response.body?.cancel().catch(() => {
-      }), new AirtableOperationError("Airtable request rejected", write && (response.status >= 500 || response.status === 408 || response.status < 400) ? "uncertain" : "unapplied");
+    if (!response2.ok)
+      throw await response2.body?.cancel().catch(() => {
+      }), new AirtableOperationError("Airtable request rejected", write && (response2.status >= 500 || response2.status === 408 || response2.status < 400) ? "uncertain" : "unapplied");
     try {
-      if (!response.headers.get("content-type")?.toLowerCase().includes("application/json")) throw new Error();
-      let value = object2(await response.json()), safe = serializable(value);
+      if (!response2.headers.get("content-type")?.toLowerCase().includes("application/json")) throw new Error();
+      let value = object2(await response2.json()), safe = serializable(value);
       if (Object.hasOwn(value, "error") || JSON.stringify(safe).includes(accessToken)) throw new Error();
       return value;
     } catch {
@@ -1601,7 +1601,7 @@ async function executeAirtableOperation(authority, operation2, raw, options = {}
   }
   await options.beforeMutation?.();
   let query = new URLSearchParams();
-  if (kind === "delete") for (let id2 of ids) query.append("records[]", id2);
+  if (kind === "delete") for (let id3 of ids) query.append("records[]", id3);
   let result2 = await request(`${path}${kind === "delete" ? `?${query}` : ""}`, {
     method: kind === "create" ? "POST" : kind === "update" ? "PATCH" : "DELETE",
     ...kind === "delete" ? {} : { body: JSON.stringify({ records: records.map((r) => "id" in r ? { id: r.id, fields: r.set } : r) }) }
@@ -1640,14 +1640,14 @@ function managedConnections(capability) {
       safeInput = null;
     }
     try {
-      let response = await fetch(new URL("airtable", endpoint), {
+      let response2 = await fetch(new URL("airtable", endpoint), {
         method: "POST",
         redirect: "error",
         headers: { authorization: `Bearer ${capability.token}`, "content-type": "application/json" },
         body: JSON.stringify({ name, operation: operation2, input: safeInput }),
         signal: AbortSignal.timeout(125e3)
-      }), value = await response.json();
-      if (!response.ok) throw new AirtableOperationError(
+      }), value = await response2.json();
+      if (!response2.ok) throw new AirtableOperationError(
         "Airtable operation failed; the execution retains its evidence",
         value.effect === "partial" || value.effect === "uncertain" ? value.effect : "unapplied",
         value.receipts ?? []
@@ -1770,6 +1770,411 @@ function validCreatePath(value) {
   return value === value.trim() && value.endsWith(".md") && !value.startsWith("/") && value.split("/").every((segment) => !!segment && ![".", ".."].includes(segment) && /^[a-zA-Z0-9_.-]+$/.test(segment));
 }
 
+var InboxOperationError = class extends Error {
+  constructor(status, reason) {
+    super(reason === "conflict" ? "This question already has an accepted answer" : reason === "unavailable" ? "Inbox request unavailable. Retry the same action." : reason === "invalid_input" ? "Invalid Inbox request" : "Inbox access unavailable");
+    this.status = status;
+    this.reason = reason;
+  }
+  status;
+  reason;
+}, INBOX_RESULT_BYTES = 8 * 1024 * 1024, INBOX_INPUT_BYTES = 8192, INBOX_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i, operations = {
+  current: [],
+  "items.list": [],
+  "items.read": ["itemId"],
+  "items.see": ["itemId"],
+  "items.markDigestRead": ["itemId"],
+  "items.rename": ["itemId", "revision", "title"],
+  "items.setLifecycle": ["itemId", "revision", "lifecycle"],
+  "items.listRecipientCandidates": ["itemId"],
+  "items.addRecipient": ["itemId", "personId"],
+  "questions.answer": ["itemId", "revision", "questionId", "response"],
+  "questions.searchRecords": ["itemId", "revision", "questionId", "query"],
+  "files.read": ["itemId", "fileId"]
+};
+function assert(value) {
+  if (!value) throw new Error("Invalid Inbox result");
+}
+function object3(value) {
+  return assert(value && typeof value == "object" && !Array.isArray(value) && [Object.prototype, null].includes(Object.getPrototypeOf(value)) && Reflect.ownKeys(value).every((key) => {
+    let descriptor2 = typeof key == "string" ? Object.getOwnPropertyDescriptor(value, key) : void 0;
+    return !!descriptor2?.enumerable && "value" in descriptor2;
+  })), 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) {
+  return typeof value == "string" && (empty2 || !!value.trim());
+}
+function id2(value) {
+  return typeof value == "string" && INBOX_UUID.test(value);
+}
+function integer(value, minimum = 1) {
+  return Number.isSafeInteger(value) && Number(value) >= minimum;
+}
+function date(value) {
+  return text3(value) && Number.isFinite(Date.parse(value));
+}
+function optionalDate(value) {
+  return value === null || date(value);
+}
+function array2(value) {
+  return assert(Array.isArray(value) && Object.getPrototypeOf(value) === Array.prototype && Reflect.ownKeys(value).length === value.length + 1 && value.every((_entry, index) => {
+    let descriptor2 = Object.getOwnPropertyDescriptor(value, String(index));
+    return !!descriptor2?.enumerable && "value" in descriptor2;
+  })), value;
+}
+function json2(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value == "boolean" || typeof value == "string" || typeof value == "number" && Number.isFinite(value)) return value;
+  assert(value && typeof value == "object" && !ancestors.has(value)), ancestors.add(value);
+  try {
+    return Array.isArray(value) ? array2(value).map((entry) => json2(entry, ancestors)) : Object.fromEntries(Object.entries(object3(value)).map(([key, entry]) => [key, json2(entry, ancestors)]));
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function recordReference(value) {
+  let record3 = object3(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;
+}
+function responseDefinition(value) {
+  let definition = object3(value);
+  keys3(definition, ["type", "source"]), assert(definition.type === "selection");
+  let source = object3(definition.source);
+  if (source.type === "authored") {
+    keys3(source, ["type", "options", "suggestions", "search"], ["type", "options"]);
+    let options = array2(source.options);
+    assert(options.length > 0);
+    let values = options.map((value2) => {
+      let option = object3(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) {
+        let note = object3(option.note);
+        keys3(note, ["placeholder"]), assert(text3(note.placeholder));
+      }
+      return option.value;
+    });
+    if (assert(new Set(values).size === values.length), "search" in source || "suggestions" in source) {
+      let search = object3(source.search);
+      keys3(search, ["triggerLabel", "placeholder", "emptyLabel"]), assert(text3(search.triggerLabel) && text3(search.placeholder) && text3(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);
+    } else assert(options.length <= 9);
+    return;
+  }
+  assert(source.type === "records"), keys3(source, ["type", "collection", "refPrefix", "where", "display", "suggestions"], ["type", "collection", "display"]);
+  let collection = object3(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));
+  let where = object3(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 = object3(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)));
+  let suggestions = array2(source.suggestions ?? []), refs = suggestions.map((value2) => {
+    let suggestion = object3(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;
+  });
+  assert(suggestions.length <= 8 && new Set(refs).size === refs.length);
+}
+function inboxFile(value) {
+  let file2 = object3(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));
+  let details = object3(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 = object3(value2);
+    return keys3(field, ["label", "value"]), assert(text3(field.label) && text3(field.value)), field.label;
+  });
+  assert(new Set(labels).size === labels.length);
+}
+function block(value) {
+  let entry = object3(value);
+  if (entry.kind === "rich-text") {
+    keys3(entry, ["kind", "markdown"]), assert(text3(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);
+    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") {
+    let record3 = object3(entry.record);
+    keys3(record3, ["ref", "title", "fields"]), assert(text3(record3.ref) && record3.ref === record3.ref.trim() && text3(record3.title)), fields4(record3.fields);
+    return;
+  }
+  if (entry.kind === "records") {
+    let records = array2(entry.records), refs = records.map((value2) => {
+      let record3 = object3(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;
+    });
+    assert(records.length > 0 && new Set(refs).size === refs.length);
+    return;
+  }
+  let files3 = array2(entry.files);
+  files3.forEach(inboxFile), assert(files3.length > 0 && new Set(files3.map((value2) => object3(value2).id)).size === files3.length);
+}
+function response(value) {
+  let answer = object3(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;
+}
+function parseInboxRequest(value) {
+  try {
+    let envelope = object3(value);
+    assert(Object.keys(envelope).sort().join(",") === "input,operation"), assert(typeof envelope.operation == "string" && Object.hasOwn(operations, envelope.operation));
+    let operation2 = envelope.operation, input = object3(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" && key === "beforeNumber"));
+    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), { operation: operation2, input };
+  } catch {
+    throw new InboxOperationError(400, "invalid_input");
+  }
+}
+function parseInboxCurrent(value) {
+  let current2 = object3(value), workspace = object3(current2.workspace), viewer = object3(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)), {
+    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 = object3(json2(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(object3(item.outcome).outcome)), array2(item.body).forEach(block), array2(item.views).forEach((value2) => {
+    let view = object3(value2);
+    assert(text3(view.id) && text3(view.view) && text3(view.implementation)), json2(view.input);
+  }), array2(item.people).forEach((value2) => {
+    let person = object3(value2);
+    assert(id2(person.id) && text3(person.name));
+  }), array2(item.questions).forEach((value2) => {
+    let question2 = object3(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) {
+      let accepted = object3(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));
+    }
+    if (question2.execution !== null) {
+      let execution = object3(question2.execution);
+      if (assert(id2(execution.id) && ["pending", "running", "completed", "failed"].includes(String(execution.state)) && integer(execution.attempt, 0)), "consequence" in execution) {
+        let consequence = object3(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) => {
+          let receipt = object3(value3);
+          assert(text3(receipt.repository) && text3(receipt.commit) && text3(receipt.diff, !0));
+        });
+      }
+    }
+  }), array2(item.linkedAsks).forEach((value2) => {
+    let linked = object3(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") {
+      let assignee = object3(linked.assignee);
+      assert(id2(assignee.id) && text3(assignee.name));
+    }
+  }), array2(item.activity).forEach((value2) => {
+    let event2 = object3(value2);
+    assert(integer(event2.id) && text3(event2.type) && (event2.actorId === null || id2(event2.actorId)) && (event2.questionId === null || text3(event2.questionId)) && integer(event2.revision) && date(event2.createdAt)), object3(event2.data);
+  }), array2(item.work).forEach((value2) => {
+    let work = object3(value2);
+    assert(id2(work.id) && text3(work.questionId) && text3(work.reason) && optionalDate(work.settledAt));
+  }), item;
+}
+function parseInboxAcceptance(value) {
+  let accepted = object3(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;
+}
+function parseInboxResult(operation2, value) {
+  if (operation2 === "current") return parseInboxCurrent(value);
+  if (operation2 === "items.read") return parseInboxItem(value);
+  if (operation2 === "items.list") {
+    let page = object3(value), items = array2(page.items).map(parseInboxItem);
+    return assert(items.length <= 100 && (page.nextBeforeNumber === null || integer(page.nextBeforeNumber))), { items, nextBeforeNumber: page.nextBeforeNumber };
+  }
+  if (operation2 === "items.see") {
+    assert(date(value));
+    return;
+  }
+  if (operation2 === "items.markDigestRead") {
+    let read2 = object3(value);
+    return assert(integer(read2.activityId) && date(read2.readAt)), read2;
+  }
+  if (operation2 === "items.rename" || operation2 === "items.setLifecycle") {
+    let update = object3(value), item = parseInboxItem(update.item);
+    return assert((update.activityId === null || integer(update.activityId)) && optionalDate(update.changedAt)), { ...update, item };
+  }
+  if (operation2 === "items.listRecipientCandidates") {
+    let candidates = array2(value);
+    return candidates.forEach((value2) => {
+      let person = object3(value2);
+      assert(id2(person.id) && text3(person.name) && text3(person.email));
+    }), assert(new Set(candidates.map((value2) => object3(value2).id)).size === candidates.length), candidates;
+  }
+  if (operation2 === "items.addRecipient") {
+    let addition = object3(value), item = parseInboxItem(addition.item);
+    return assert(id2(addition.addedPersonId) && item.people.some((person) => person.id === addition.addedPersonId)), { ...addition, item };
+  }
+  if (operation2 === "questions.answer") return parseInboxAcceptance(value);
+  if (operation2 === "questions.searchRecords") {
+    let result2 = object3(value);
+    assert(text3(result2.recordType) && integer(result2.eligibleCount, 0) && integer(result2.matchCount, 0) && Number(result2.matchCount) <= Number(result2.eligibleCount));
+    let labeled = (value2) => {
+      let record3 = object3(value2);
+      recordReference({ repository: record3.repository, ref: record3.ref }), assert(text3(record3.label)), "reason" in record3 && assert(text3(record3.reason));
+    };
+    return array2(result2.matches).forEach(labeled), array2(result2.suggestions).forEach(labeled), "selected" in result2 && labeled(result2.selected), result2;
+  }
+  throw new Error("File content is not a JSON result");
+}
+
+async function limitedBody(request, limit, timeoutMs) {
+  if (!request.body) return new Uint8Array();
+  let reader = request.body.getReader(), expired = !1, timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+    expired = !0, reader.cancel().catch(() => {
+    });
+  }, timeoutMs), chunks = [], length = 0;
+  try {
+    for (; ; ) {
+      let { done, value } = await reader.read();
+      if (done) break;
+      if (length += value.byteLength, length > limit) {
+        await reader.cancel();
+        return;
+      }
+      chunks.push(value);
+    }
+    if (expired) return;
+    let contents = new Uint8Array(length), offset = 0;
+    for (let chunk of chunks)
+      contents.set(chunk, offset), offset += chunk.byteLength;
+    return contents;
+  } finally {
+    timer !== void 0 && clearTimeout(timer);
+  }
+}
+
+var unavailable2 = () => new InboxOperationError(503, "unavailable"), stale = () => new InboxOperationError(401, "authority_unavailable");
+async function send2(operation2, input) {
+  let envelope = parseInboxRequest({ operation: operation2, input }), context2;
+  try {
+    context2 = await resolveAppContext();
+  } catch {
+    throw stale();
+  }
+  if (context2.kind === "local" || context2.endpoint !== `https://${context2.workspace}.oddington.ai` || ["auth", "www", "api", "os"].includes(context2.workspace)) throw stale();
+  let check = () => {
+    if (!context2.isCurrent() || !Number.isFinite(context2.expiresAt) || context2.expiresAt <= Date.now()) throw stale();
+  };
+  check();
+  try {
+    let response2 = await fetch(`${context2.endpoint}/api/inbox`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${context2.accessToken}`, "content-type": "application/json" },
+      body: JSON.stringify(envelope),
+      redirect: "error",
+      cache: "no-store",
+      signal: AbortSignal.timeout(3e4)
+    });
+    try {
+      check();
+    } catch (error) {
+      throw response2.body?.cancel().catch(() => {
+      }), error;
+    }
+    if (!response2.ok)
+      throw response2.body?.cancel().catch(() => {
+      }), new InboxOperationError(
+        [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 response2.body?.cancel().catch(() => {
+      }), unavailable2();
+    if (operation2 === "files.read") {
+      if (!response2.body) throw unavailable2();
+      let source = response2.body, reader, size = 0, cancel = async (reason) => {
+        try {
+          await (reader ? reader.cancel(reason) : source.cancel(reason));
+        } finally {
+          reader?.releaseLock();
+        }
+      }, body2 = new ReadableStream({
+        async pull(controller) {
+          try {
+            check(), reader ??= source.getReader();
+            let next = await reader.read();
+            if (check(), next.done) {
+              reader.releaseLock(), controller.close();
+              return;
+            }
+            if (size += next.value.byteLength, size > 25 * 1024 * 1024) throw unavailable2();
+            controller.enqueue(next.value);
+          } catch (error) {
+            controller.error(error), await cancel(error).catch(() => {
+            });
+          }
+        },
+        cancel
+      }, { highWaterMark: 0 });
+      return new Response(body2, { status: response2.status, headers: response2.headers });
+    }
+    let bytes = await limitedBody(response2, INBOX_RESULT_BYTES);
+    if (check(), !bytes) throw unavailable2();
+    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 ("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();
+    }
+    return parsed;
+  } catch (error) {
+    throw check(), error instanceof InboxOperationError ? error : unavailable2();
+  }
+}
+var inbox = {
+  current: async () => await send2("current", {}),
+  items: {
+    async list() {
+      let items = [], beforeNumber, initial;
+      try {
+        initial = await resolveAppContext();
+      } catch {
+        throw stale();
+      }
+      let check = () => {
+        if (!initial.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 (items.push(...page.items), page.nextBeforeNumber === null) return items;
+        beforeNumber = page.nextBeforeNumber;
+      } while (!0);
+    },
+    read: async (itemId) => await send2("items.read", { itemId }),
+    see: async (itemId) => {
+      await send2("items.see", { itemId });
+    },
+    markDigestRead: async (itemId) => await send2("items.markDigestRead", { itemId }),
+    rename: async (input) => await send2("items.rename", input),
+    setLifecycle: async (input) => await send2("items.setLifecycle", input),
+    listRecipientCandidates: async (itemId) => await send2("items.listRecipientCandidates", { itemId }),
+    addRecipient: async (input) => await send2("items.addRecipient", input)
+  },
+  questions: {
+    answer: async (input) => await send2("questions.answer", input),
+    searchRecords: async (input) => await send2("questions.searchRecords", input)
+  },
+  files: { read: async (input) => await send2("files.read", input) }
+};
+
 var sources = /* @__PURE__ */ new WeakMap();
 function registerBrowserAuth(handle2, source) {
   sources.set(handle2, source);
@@ -1782,14 +2187,14 @@ var sessionKey = "_os.app.session", responseChecks = /* @__PURE__ */ new WeakMap
 }, AppContextDenied = class extends Error {
 }, AppRenewalUnavailable = class extends Error {
 };
-async function appResponse(response, maximum, signal) {
-  if (signal.aborted || !response.body || response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json") throw new Error();
-  let reader = response.body.getReader(), abort = () => {
+async function appResponse(response2, maximum, signal) {
+  if (signal.aborted || !response2.body || response2.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json") throw new Error();
+  let reader = response2.body.getReader(), abort = () => {
     reader.cancel().catch(() => {
     });
   };
   signal.addEventListener("abort", abort, { once: !0 });
-  let bytes = 0, text3 = "", decoder = new TextDecoder("utf-8", { fatal: !0 });
+  let bytes = 0, text4 = "", decoder = new TextDecoder("utf-8", { fatal: !0 });
   try {
     for (; ; ) {
       let chunk;
@@ -1800,13 +2205,13 @@ async function appResponse(response, maximum, signal) {
       }
       if (signal.aborted) throw new Error();
       if (chunk.done) {
-        let value = JSON.parse(text3 + decoder.decode());
-        if (await responseChecks.get(response)?.(value), signal.aborted) throw new Error();
+        let value = JSON.parse(text4 + 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();
-      text3 += decoder.decode(chunk.value, { stream: !0 });
+      text4 += decoder.decode(chunk.value, { stream: !0 });
     }
   } finally {
     signal.removeEventListener("abort", abort), reader.releaseLock();
@@ -1844,7 +2249,7 @@ function appContext(origin, active2) {
   }, sameSession = (value) => !binding || value.appId === binding.appId && value.memberId === binding.memberId && value.workspace === binding.workspace && value.sessionId === binding.sessionId, bounded = (value) => validBinding(value) && value.expiresAt > Date.now() && value.expiresAt <= Date.now() + 6e5 && sameSession(value);
   async function proof(candidate, signal = controller.signal) {
     if (!alive() || !/^[A-Za-z0-9_-]{43}$/.test(candidate)) throw new Error();
-    let url = `${origin}/_os/app/context`, response = await fetch(url, {
+    let url = `${origin}/_os/app/context`, response2 = await fetch(url, {
       credentials: "omit",
       redirect: "error",
       cache: "no-store",
@@ -1852,10 +2257,10 @@ function appContext(origin, active2) {
       headers: { authorization: `Bearer ${candidate}` },
       signal
     });
-    if (response.redirected || response.url && response.url !== url) throw new Error();
-    if (response.status === 401 || response.status === 403) throw new AppContextDenied();
-    if (!response.ok) throw new Error();
-    let value = await appResponse(response, 4096, signal);
+    if (response2.redirected || response2.url && response2.url !== url) throw new Error();
+    if (response2.status === 401 || response2.status === 403) throw new AppContextDenied();
+    if (!response2.ok) throw new Error();
+    let value = await appResponse(response2, 4096, signal);
     if (!alive() || !bounded(value)) throw new Error();
     return value;
   }
@@ -1906,9 +2311,9 @@ function appContext(origin, active2) {
         let timeout = setTimeout(abort, Math.min(2e4, deadline - Date.now())), previous = credential;
         try {
           if (await synchronize(), credential !== previous) return;
-          let url = `${origin}/_os/app/renew`, response;
+          let url = `${origin}/_os/app/renew`, response2;
           try {
-            response = await fetch(url, {
+            response2 = await fetch(url, {
               method: "POST",
               credentials: "omit",
               redirect: "error",
@@ -1920,11 +2325,11 @@ function appContext(origin, active2) {
           } catch {
             throw new AppRenewalUnavailable();
           }
-          if (response.redirected || response.url && response.url !== url) throw new Error();
-          let value = await appResponse(response, 4096, requestController.signal);
-          if (response.status === 503 && value && typeof value == "object" && !Array.isArray(value) && Object.keys(value).join(",") === "error" && "error" in value && value.error === "renewal_unavailable")
+          if (response2.redirected || response2.url && response2.url !== url) throw new Error();
+          let value = await appResponse(response2, 4096, requestController.signal);
+          if (response2.status === 503 && value && typeof value == "object" && !Array.isArray(value) && Object.keys(value).join(",") === "error" && "error" in value && value.error === "renewal_unavailable")
             throw new AppRenewalUnavailable();
-          if (response.status === 403 && value && typeof value == "object" && !Array.isArray(value) && Object.keys(value).join(",") === "error" && "error" in value && value.error === "renewal_conflict") {
+          if (response2.status === 403 && value && typeof value == "object" && !Array.isArray(value) && Object.keys(value).join(",") === "error" && "error" in value && value.error === "renewal_conflict") {
             for (; alive() && stored() === previous && !requestController.signal.aborted; )
               await new Promise((resolve2, reject) => {
                 let abortWait = () => {
@@ -1938,7 +2343,7 @@ function appContext(origin, active2) {
             await synchronize();
             return;
           }
-          if (!response.ok) throw new Error();
+          if (!response2.ok) throw new Error();
           if (!alive() || Date.now() >= deadline || !value || typeof value != "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "context,credential") throw new Error();
           let result2 = value;
           if (!bounded(result2.context) || typeof result2.credential != "string" || !/^[A-Za-z0-9_-]{43}$/.test(result2.credential) || result2.credential === previous) throw new Error();
@@ -1994,7 +2399,7 @@ function appContext(origin, active2) {
   async function requestData(operation2, input) {
     try {
       if (operation2 !== "data/query" || !current2()) throw new Error();
-      let url = `${origin}/_os/app/data`, admitted = credential, response = await fetch(url, {
+      let url = `${origin}/_os/app/data`, admitted = credential, response2 = await fetch(url, {
         method: "POST",
         credentials: "omit",
         redirect: "error",
@@ -2005,13 +2410,13 @@ function appContext(origin, active2) {
         body: JSON.stringify(input)
       });
       for (await synchronize(); alive() && stored() !== credential; ) await synchronize();
-      if (!current2() || response.redirected || response.url && response.url !== url) throw new Error();
-      if (response.status === 401 || response.status === 403)
+      if (!current2() || response2.redirected || response2.url && response2.url !== url) throw new Error();
+      if (response2.status === 401 || response2.status === 403)
         throw admitted === credential && invalidate(), new DataOperationError("access_denied");
-      let result2 = await appResponse(response, Number.MAX_SAFE_INTEGER, controller.signal);
+      let result2 = await appResponse(response2, Number.MAX_SAFE_INTEGER, controller.signal);
       for (await synchronize(); alive() && stored() !== credential; ) await synchronize();
       if (!current2()) throw new Error();
-      if (!response.ok) throw dataTransportError(response.status, result2);
+      if (!response2.ok) throw dataTransportError(response2.status, result2);
       return result2;
     } catch (error) {
       throw error instanceof DataOperationError ? error : !current2() || controller.signal.aborted ? new DataOperationError("context_unavailable") : new DataOperationError("unavailable", !0);
@@ -2020,7 +2425,7 @@ function appContext(origin, active2) {
   async function requestRoutine(key, suffix, init2 = {}) {
     if (!current2())
       throw invalidate(), new Error("Local app context unavailable.");
-    let url = `${origin}/_os/app/routines/${encodeURIComponent(key)}/${suffix}`, admitted = credential, response = await fetch(url, {
+    let url = `${origin}/_os/app/routines/${encodeURIComponent(key)}/${suffix}`, admitted = credential, response2 = await fetch(url, {
       ...init2,
       credentials: "omit",
       redirect: "error",
@@ -2030,12 +2435,12 @@ function appContext(origin, active2) {
       headers: { ...init2.body === void 0 ? {} : { "content-type": "application/json" }, authorization: `Bearer ${credential}` }
     });
     for (await synchronize(); alive() && stored() !== credential; ) await synchronize();
-    if (!current2() || response.redirected || response.url && response.url !== url)
+    if (!current2() || response2.redirected || response2.url && response2.url !== url)
       throw invalidate(), new Error("Local app context unavailable.");
-    return (response.status === 401 || response.status === 403) && admitted === credential && invalidate(), responseChecks.set(response, async (value) => {
+    return (response2.status === 401 || response2.status === 403) && admitted === credential && invalidate(), responseChecks.set(response2, async (value) => {
       for (await synchronize(); alive() && stored() !== credential; ) await synchronize();
       admitted === credential && value && typeof value == "object" && "error" in value && value.error === "authority_unavailable" && invalidate();
-    }), response;
+    }), response2;
   }
   function context2() {
     let issued = credential;
@@ -2144,9 +2549,9 @@ function authorizationConfiguration(value) {
   if (!setup || typeof setup.clientId != "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(setup.clientId) || setup.redirectUri !== CLI_CALLBACK || !Array.isArray(setup.scopes) || setup.scopes.length !== 1 || setup.scopes[0] !== "email") throw new Error("Unavailable");
   return { clientId: setup.clientId, redirectUri: CLI_CALLBACK, scopes: ["email"] };
 }
-function authorizationDetails(value, id2, setup, userId, account) {
+function authorizationDetails(value, id3, setup, userId, account) {
   let details = value;
-  return !details || details.authorization_id !== id2 || details.redirect_uri !== setup.redirectUri || details.client?.id !== setup.clientId || typeof details.client.name != "string" || !details.client.name.trim() || details.client.name.length > 128 || /[\x00-\x1f\x7f]/.test(details.client.name) || details.user?.id !== userId || details.user.email !== account.email || typeof details.scope != "string" || details.scope.trim() !== "email" ? Object.freeze({ status: "invalid" }) : Object.freeze({
+  return !details || details.authorization_id !== id3 || details.redirect_uri !== setup.redirectUri || details.client?.id !== setup.clientId || typeof details.client.name != "string" || !details.client.name.trim() || details.client.name.length > 128 || /[\x00-\x1f\x7f]/.test(details.client.name) || details.user?.id !== userId || details.user.email !== account.email || typeof details.scope != "string" || details.scope.trim() !== "email" ? Object.freeze({ status: "invalid" }) : Object.freeze({
     status: "consent",
     clientName: details.client.name.trim(),
     account,
@@ -2196,7 +2601,8 @@ function createBrowserAuth(runtime) {
   }
   function accept(c, event2, session) {
     if (!c.active || event2 === "INITIAL_SESSION" && c.state.status !== "initializing" || event2 === "TOKEN_REFRESHED" && !c.session && c.state.status !== "initializing") return;
-    (c.session?.user?.id !== session?.user?.id || event2 === "SIGNED_OUT" || event2 === "SIGNED_IN" && c.session && session?.access_token !== c.session.access_token) && c.revision++, c.timer && clearTimeout(c.timer);
+    let replaced = c.session?.user?.id !== session?.user?.id || event2 === "SIGNED_OUT" || !!(event2 === "SIGNED_IN" && c.session && session?.access_token !== c.session.access_token);
+    replaced && c.revision++, c.timer && clearTimeout(c.timer);
     let pending = c.state.pending;
     if (!session) {
       c.session = null, publish(c, { status: c.state.status === "expired" ? "expired" : "signed_out", ...pending ? { pending } : {} }), notify(c, "SIGNED_OUT");
@@ -2207,8 +2613,8 @@ function createBrowserAuth(runtime) {
       return;
     }
     c.session = session;
-    let email = typeof session.user.email == "string" ? session.user.email.trim() : "", metadata = session.user.user_metadata, displayName = ["name", "full_name", "first_name"].map((key) => metadata?.[key]).find((value) => typeof value == "string" && value.trim());
-    publish(c, { status: "signed_in", account: Object.freeze({ email, displayName: displayName?.trim() || email }), ...pending ? { pending } : {} }), notify(c, event2);
+    let email = typeof session.user.email == "string" ? session.user.email.trim() : "", metadata = session.user.user_metadata, name = ["name", "full_name", "first_name"].map((key) => metadata?.[key]).find((value) => typeof value == "string" && value.trim())?.trim() || email, account = !replaced && c.state.account?.email === email && c.state.account.displayName === name ? c.state.account : Object.freeze({ email, displayName: name });
+    publish(c, { status: "signed_in", account, ...pending ? { pending } : {} }), notify(c, event2);
     let checkExpiry = () => {
       if (!c.active || !c.session) return;
       let remaining = c.session.expires_at * 1e3 - Date.now();
@@ -2234,9 +2640,9 @@ function createBrowserAuth(runtime) {
       let revision = c.revision;
       try {
         if (!allowedOrigin(origin)) throw runtime.failure("unavailable");
-        let response = await fetch(`${origin}/api/auth/browser-configuration`, { method: "GET", credentials: "same-origin", redirect: "error", cache: "no-store" });
-        if (!response.ok) throw runtime.failure("unavailable");
-        let configuration = validateConfiguration(await response.json());
+        let response2 = await fetch(`${origin}/api/auth`, { method: "GET", credentials: "same-origin", redirect: "error", cache: "no-store" });
+        if (!response2.ok) throw runtime.failure("unavailable");
+        let configuration = validateConfiguration(await response2.json());
         if (configuration.authorization && origin !== "https://auth.oddington.ai" && origin !== "http://127.0.0.1:5176") throw runtime.failure("unavailable");
         if (c.authorization = configuration.authorization, !c.active || globalThis.location?.origin !== origin) return;
         if (c.provider = await runtime.provider(configuration, {
@@ -2297,10 +2703,10 @@ function createBrowserAuth(runtime) {
         coordinator.action === marker && (coordinator.action = void 0, coordinator.active && (publish(coordinator, { ...coordinator.state, pending: void 0 }), kind === "sign_out" && coordinator.session && notify(coordinator, "TOKEN_REFRESHED"))), ownedAction === marker && (ownedAction = void 0);
       }
     }
-    async function authorize(kind, id2) {
+    async function authorize(kind, id3) {
       if (!active2) return Object.freeze({ status: "disposed" });
-      if (id2 !== authorizationId && (authorizationId = id2, authorizationGeneration++, inspected = void 0), !id2) return Object.freeze({ status: "missing" });
-      if (typeof id2 != "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(id2)) return Object.freeze({ status: "invalid" });
+      if (id3 !== authorizationId && (authorizationId = id3, authorizationGeneration++, inspected = void 0), !id3) return Object.freeze({ status: "missing" });
+      if (typeof id3 != "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(id3)) return Object.freeze({ status: "invalid" });
       let generation = authorizationGeneration;
       if (await coordinator.ready, !active2) return Object.freeze({ status: "disposed" });
       if (generation !== authorizationGeneration) return Object.freeze({ status: "stale" });
@@ -2309,37 +2715,37 @@ function createBrowserAuth(runtime) {
       if (!coordinator.session || coordinator.state.pending === "sign_out") return Object.freeze({ status: coordinator.state.status === "expired" ? "expired" : coordinator.state.status === "unavailable" ? "unavailable" : "signed_out" });
       if (!coordinator.authorization || !coordinator.provider) return Object.freeze({ status: "unavailable" });
       if (coordinator.action) return Object.freeze({ status: "busy" });
-      if (kind !== "get" && (!inspected || inspected.id !== id2 || inspected.revision !== revision)) return Object.freeze({ status: "stale" });
+      if (kind !== "get" && (!inspected || inspected.id !== id3 || inspected.revision !== revision)) return Object.freeze({ status: "stale" });
       if (kind !== "get" && inspected?.result.status !== "consent") return inspected.result;
       let marker = {};
       coordinator.action = marker, ownedAction = marker;
-      let requestCurrent = () => active2 && generation === authorizationGeneration && current2(coordinator, origin, revision) && coordinator.action === marker && !!coordinator.session && coordinator.state.pending !== "sign_out", stale = () => Object.freeze({ status: active2 ? "stale" : "disposed" });
+      let requestCurrent = () => active2 && generation === authorizationGeneration && current2(coordinator, origin, revision) && coordinator.action === marker && !!coordinator.session && coordinator.state.pending !== "sign_out", stale2 = () => Object.freeze({ status: active2 ? "stale" : "disposed" });
       try {
-        let provider2 = coordinator.provider, response = await provider2.authorization.get(id2, requestCurrent);
-        if (!requestCurrent()) return stale();
-        if (response.error) {
+        let provider2 = coordinator.provider, response2 = await provider2.authorization.get(id3, requestCurrent);
+        if (!requestCurrent()) return stale2();
+        if (response2.error) {
           inspected = void 0;
-          let failure = authorizationFailure(response.error);
+          let failure = authorizationFailure(response2.error);
           return failure.status === "signed_out" && expire(coordinator), failure;
         }
-        let account = coordinator.state.account, result2 = response.data && typeof response.data == "object" && "redirect_url" in response.data ? authorizationReturn(response.data) : authorizationDetails(response.data, id2, coordinator.authorization, coordinator.session.user.id, account);
-        if (inspected = { id: id2, revision, result: result2 }, kind === "get" || result2.status !== "consent") return result2;
-        if (!requestCurrent()) return stale();
-        let decision = await provider2.authorization[kind](id2, requestCurrent);
-        if (!requestCurrent()) return stale();
+        let account = coordinator.state.account, result2 = response2.data && typeof response2.data == "object" && "redirect_url" in response2.data ? authorizationReturn(response2.data) : authorizationDetails(response2.data, id3, coordinator.authorization, coordinator.session.user.id, account);
+        if (inspected = { id: id3, revision, result: result2 }, kind === "get" || result2.status !== "consent") return result2;
+        if (!requestCurrent()) return stale2();
+        let decision = await provider2.authorization[kind](id3, requestCurrent);
+        if (!requestCurrent()) return stale2();
         let returned = decision.error ? authorizationFailure(decision.error) : authorizationReturn(decision.data, kind);
-        return returned.status === "signed_out" && expire(coordinator), inspected = { id: id2, revision, result: returned }, returned;
+        return returned.status === "signed_out" && expire(coordinator), inspected = { id: id3, revision, result: returned }, returned;
       } catch (error) {
-        return !requestCurrent() || (inspected = void 0, safeReason(error) === "stale") ? stale() : Object.freeze({ status: "unavailable" });
+        return !requestCurrent() || (inspected = void 0, safeReason(error) === "stale") ? stale2() : Object.freeze({ status: "unavailable" });
       } finally {
         coordinator.action === marker && (coordinator.action = void 0), ownedAction === marker && (ownedAction = void 0);
       }
     }
     let handle2 = Object.freeze({
       authorization: Object.freeze({
-        get: (id2) => authorize("get", id2),
-        approve: (id2) => authorize("approve", id2),
-        deny: (id2) => authorize("deny", id2)
+        get: (id3) => authorize("get", id3),
+        approve: (id3) => authorize("approve", id3),
+        deny: (id3) => authorize("deny", id3)
       }),
       getState() {
         return active2 && coordinator.session && !validSession(coordinator.session) && expire(coordinator), lastState;
@@ -2477,19 +2883,19 @@ async function provider(configuration, guard) {
         throw request && (request.rejected = !0), new BrowserAuthError("stale");
       };
       request && (!request.current() || !guard.canAuthorize(new Headers(init2?.headers).get("authorization")?.replace(/^Bearer /, "") ?? "")) && rejectStale();
-      let response = await fetch(input, { ...init2, redirect: "error" }), body2 = await response.arrayBuffer();
+      let response2 = await fetch(input, { ...init2, redirect: "error" }), body2 = await response2.arrayBuffer();
       (!guard.current(revision) || request && !request.current()) && rejectStale();
       let result2 = new Response(
-        [204, 205, 304].includes(response.status) ? null : body2,
-        { status: response.status, statusText: response.statusText, headers: response.headers }
-      ), json2 = result2.json.bind(result2);
+        [204, 205, 304].includes(response2.status) ? null : body2,
+        { status: response2.status, statusText: response2.statusText, headers: response2.headers }
+      ), json3 = result2.json.bind(result2);
       return result2.json = async () => {
-        let value = await json2();
+        let value = await json3();
         return (!guard.current(revision) || request && !request.current()) && rejectStale(), value && typeof value.access_token == "string" && provenance.set(value.access_token, revision), value;
       }, result2;
     }, { preconnect: fetch.preconnect })
   });
-  async function authorization(kind, id2, current2) {
+  async function authorization(kind, id3, current2) {
     let previous = authorizationQueue, release;
     authorizationQueue = new Promise((resolve) => {
       release = resolve;
@@ -2498,7 +2904,7 @@ async function provider(configuration, guard) {
     authorizationRequest = request;
     try {
       if (!current2()) throw new BrowserAuthError("stale");
-      let result2 = await (kind === "get" ? client.oauth.getAuthorizationDetails(id2) : kind === "approve" ? client.oauth.approveAuthorization(id2, { skipBrowserRedirect: !0 }) : client.oauth.denyAuthorization(id2, { skipBrowserRedirect: !0 }));
+      let result2 = await (kind === "get" ? client.oauth.getAuthorizationDetails(id3) : kind === "approve" ? client.oauth.approveAuthorization(id3, { skipBrowserRedirect: !0 }) : client.oauth.denyAuthorization(id3, { skipBrowserRedirect: !0 }));
       if (request.rejected || !current2()) throw new BrowserAuthError("stale");
       return result2;
     } catch (error) {
@@ -2509,9 +2915,9 @@ async function provider(configuration, guard) {
   }
   return {
     authorization: {
-      get: (id2, current2) => authorization("get", id2, current2),
-      approve: (id2, current2) => authorization("approve", id2, current2),
-      deny: (id2, current2) => authorization("deny", id2, current2)
+      get: (id3, current2) => authorization("get", id3, current2),
+      approve: (id3, current2) => authorization("approve", id3, current2),
+      deny: (id3, current2) => authorization("deny", id3, current2)
     },
     getSession: () => client.getSession(),
     onAuthStateChange: (callback) => client.onAuthStateChange((event2, session) => {
@@ -2546,50 +2952,50 @@ var identifier = /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/, uuid = /^[0-9a-f]{8}-[0-
 function fail3(reason) {
   throw new AppRoutineError(reason);
 }
-function object3(value) {
+function object4(value) {
   return !!value && typeof value == "object" && !Array.isArray(value);
 }
-function keys3(value, expected) {
+function keys4(value, expected) {
   return Object.keys(value).sort().join(",") === expected;
 }
 function current(context2) {
   (!context2.isCurrent() || context2.signal.aborted) && fail3("authority_unavailable");
 }
-async function body(context2, response, maximum) {
+async function body(context2, response2, maximum) {
   try {
-    let value = await appResponse(response, maximum, context2.signal);
-    return current(context2), response.ok || (object3(value) && keys3(value, "error") && isReason(value.error) && (value.error === "authority_unavailable" && context2.invalidate(), fail3(value.error)), fail3("authority_unavailable")), value;
+    let value = await appResponse(response2, maximum, context2.signal);
+    return current(context2), response2.ok || (object4(value) && keys4(value, "error") && isReason(value.error) && (value.error === "authority_unavailable" && context2.invalidate(), fail3(value.error)), fail3("authority_unavailable")), value;
   } catch (error) {
     if (current(context2), error instanceof AppResponseReadError || error instanceof AppRoutineError) throw error;
     return fail3("execution_unavailable");
   }
 }
 function descriptor(value, key) {
-  return (!object3(value) || !keys3(value, "after,key,routine,runId") || value.key !== key || typeof value.runId != "string" || !uuid.test(value.runId) || value.after !== 0 || typeof value.routine != "string" || !identifier.test(value.routine)) && fail3("execution_unavailable"), value;
+  return (!object4(value) || !keys4(value, "after,key,routine,runId") || value.key !== key || typeof value.runId != "string" || !uuid.test(value.runId) || value.after !== 0 || typeof value.routine != "string" || !identifier.test(value.routine)) && fail3("execution_unavailable"), value;
 }
 function safeValue(value, depth = 0) {
-  return depth > 32 ? !1 : value === null || typeof value == "string" || typeof value == "boolean" ? !0 : typeof value == "number" ? Number.isFinite(value) : Array.isArray(value) ? value.every((item) => safeValue(item, depth + 1)) : object3(value) && Object.entries(value).every(([key, item]) => !["__proto__", "constructor", "prototype"].includes(key) && safeValue(item, depth + 1));
+  return depth > 32 ? !1 : value === null || typeof value == "string" || typeof value == "boolean" ? !0 : typeof value == "number" ? Number.isFinite(value) : Array.isArray(value) ? value.every((item) => safeValue(item, depth + 1)) : object4(value) && Object.entries(value).every(([key, item]) => !["__proto__", "constructor", "prototype"].includes(key) && safeValue(item, depth + 1));
 }
 function event(value, run, steps) {
-  (!object3(value) || value.runId !== run.runId || value.key !== run.key || value.routine !== run.routine || !Number.isSafeInteger(value.sequence) || value.sequence < 1 || new TextEncoder().encode(JSON.stringify(value)).byteLength > 16 * 1024) && fail3("execution_unavailable");
+  (!object4(value) || value.runId !== run.runId || value.key !== run.key || value.routine !== run.routine || !Number.isSafeInteger(value.sequence) || value.sequence < 1 || new TextEncoder().encode(JSON.stringify(value)).byteLength > 16 * 1024) && fail3("execution_unavailable");
   let common = "key,routine,runId,sequence,";
-  if (value.type === "started" && keys3(value, common + "type") && value.sequence === 1) return { type: "started" };
-  if (value.type === "step" && typeof value.id == "string" && identifier.test(value.id) && (!steps || steps.includes(value.id)) && keys3(value, "id," + common + (Object.hasOwn(value, "summary") ? "summary,type" : "type")) && (!Object.hasOwn(value, "summary") || safeValue(value.summary)))
+  if (value.type === "started" && keys4(value, common + "type") && value.sequence === 1) return { type: "started" };
+  if (value.type === "step" && typeof value.id == "string" && identifier.test(value.id) && (!steps || steps.includes(value.id)) && keys4(value, "id," + common + (Object.hasOwn(value, "summary") ? "summary,type" : "type")) && (!Object.hasOwn(value, "summary") || safeValue(value.summary)))
     return {
       type: "step",
       id: value.id,
       ...Object.hasOwn(value, "summary") ? { summary: value.summary } : {}
     };
   if (value.type === "finished") {
-    if (value.state === "succeeded" && keys3(value, "key," + (Object.hasOwn(value, "result") ? "result," : "") + "routine,runId,sequence,state,type") && (!Object.hasOwn(value, "result") || safeValue(value.result)))
+    if (value.state === "succeeded" && keys4(value, "key," + (Object.hasOwn(value, "result") ? "result," : "") + "routine,runId,sequence,state,type") && (!Object.hasOwn(value, "result") || safeValue(value.result)))
       return {
         type: "finished",
         state: "succeeded",
         ...Object.hasOwn(value, "result") ? { result: value.result } : {}
       };
-    if (value.state === "failed" && value.error === "execution_failed" && keys3(value, "error," + common + "state,type"))
+    if (value.state === "failed" && value.error === "execution_failed" && keys4(value, "error," + common + "state,type"))
       return { type: "finished", state: "failed", error: "execution_failed" };
-    if (value.state === "cancelled" && keys3(value, common + "state,type")) return { type: "finished", state: "cancelled" };
+    if (value.state === "cancelled" && keys4(value, common + "state,type")) return { type: "finished", state: "cancelled" };
   }
   return fail3("execution_unavailable");
 }
@@ -2610,26 +3016,26 @@ function handle(context2, run, steps) {
       let cursor = 0, terminal = !1, delay = 100, retainedBytes = 0, seen = [];
       for (; !terminal; ) {
         current(context2);
-        let response;
+        let response2;
         try {
-          response = await context2.requestRoutine(run.key, `runs/${run.runId}/events?after=${cursor}`);
+          response2 = await context2.requestRoutine(run.key, `runs/${run.runId}/events?after=${cursor}`);
         } catch {
           current(context2), await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
           continue;
         }
-        if (response.status >= 500) {
-          await response.body?.cancel(), await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
+        if (response2.status >= 500) {
+          await response2.body?.cancel(), await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
           continue;
         }
         let value;
         try {
-          value = await body(context2, response, 80 * 1024);
+          value = await body(context2, response2, 80 * 1024);
         } catch (error) {
           if (!(error instanceof AppResponseReadError)) throw error;
           await pause(context2, delay), delay = Math.min(delay * 2, 2e3);
           continue;
         }
-        (!object3(value) || !keys3(value, "after,events,terminal") || !Array.isArray(value.events) || value.events.length > 256 || typeof value.terminal != "boolean" || !Number.isSafeInteger(value.after)) && fail3("execution_unavailable");
+        (!object4(value) || !keys4(value, "after,events,terminal") || !Array.isArray(value.events) || value.events.length > 256 || typeof value.terminal != "boolean" || !Number.isSafeInteger(value.after)) && fail3("execution_unavailable");
         let delivery = [];
         for (let raw of value.events) {
           let publicEvent = event(raw, run, steps), encoded = JSON.stringify(raw), sequence = raw.sequence;
@@ -2649,7 +3055,7 @@ function handle(context2, run, steps) {
       args.length && fail3("invalid_input");
       try {
         let value = await body(context2, await context2.requestRoutine(run.key, `runs/${run.runId}/cancel`, { method: "POST" }), 1024);
-        (!object3(value) || !keys3(value, "cancelled") || value.cancelled !== !0) && fail3("execution_unavailable");
+        (!object4(value) || !keys4(value, "cancelled") || value.cancelled !== !0) && fail3("execution_unavailable");
       } catch (error) {
         if (current(context2), error instanceof AppRoutineError) throw error;
         fail3("execution_unavailable");
@@ -2664,12 +3070,12 @@ async function appRoutineOperation(key, input, recover) {
     let resolved = await resolveAppContext();
     if (resolved.kind !== "local" && fail3("execution_unavailable"), context2 = resolved, recover) {
       let value2 = await body(context2, await context2.requestRoutine(key, "runs"), 16384);
-      (!object3(value2) || !keys3(value2, "runs") || !Array.isArray(value2.runs) || value2.runs.length > 20) && fail3("execution_unavailable");
+      (!object4(value2) || !keys4(value2, "runs") || !Array.isArray(value2.runs) || value2.runs.length > 20) && fail3("execution_unavailable");
       let runs = value2.runs.map((run) => descriptor(run, key));
       return (new Set(runs.map((run) => run.runId)).size !== runs.length || new Set(runs.map((run) => run.routine)).size > 1) && fail3("execution_unavailable"), runs.map((run) => handle(resolved, run));
     }
     let available = await body(context2, await context2.requestAvailability(key), 16 * 1024);
-    object3(available) && keys3(available, "available,reason") && available.available === !1 && isReason(available.reason) && fail3(available.reason), (!object3(available) || !keys3(available, "available,steps") || available.available !== !0 || !Array.isArray(available.steps) || available.steps.length < 1 || available.steps.length > 64 || !available.steps.every((step) => typeof step == "string" && identifier.test(step)) || new Set(available.steps).size !== available.steps.length) && fail3("execution_unavailable");
+    object4(available) && keys4(available, "available,reason") && available.available === !1 && isReason(available.reason) && fail3(available.reason), (!object4(available) || !keys4(available, "available,steps") || available.available !== !0 || !Array.isArray(available.steps) || available.steps.length < 1 || available.steps.length > 64 || !available.steps.every((step) => typeof step == "string" && identifier.test(step)) || new Set(available.steps).size !== available.steps.length) && fail3("execution_unavailable");
     let steps = [...available.steps], encoded;
     try {
       encoded = JSON.stringify(input), (encoded === void 0 || new TextEncoder().encode(encoded).byteLength > 16 * 1024) && fail3("invalid_input");
@@ -2693,10 +3099,10 @@ async function availability(key) {
     if (!/^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/.test(key)) return authorityUnavailable();
     let context2 = await resolveAppContext();
     if (context2.kind !== "local") return { available: !1, reason: "execution_unavailable" };
-    let response = await context2.requestAvailability(key);
-    if (!response.ok || response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json")
+    let response2 = await context2.requestAvailability(key);
+    if (!response2.ok || response2.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json")
       return authorityUnavailable();
-    let value = await appResponse(response, MAX_RESPONSE_BYTES, context2.signal);
+    let value = await appResponse(response2, MAX_RESPONSE_BYTES, context2.signal);
     if (!context2.isCurrent() || !value || typeof value != "object" || Array.isArray(value)) return authorityUnavailable();
     let result2 = value;
     return result2.available === !1 && Object.keys(result2).sort().join(",") === "available,reason" && (result2.reason === "authority_unavailable" || result2.reason === "execution_unavailable") ? { available: !1, reason: result2.reason } : result2.available !== !0 || Object.keys(result2).sort().join(",") !== "available,steps" || !Array.isArray(result2.steps) || result2.steps.length < 1 || result2.steps.length > 64 || !result2.steps.every((step) => typeof step == "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*(?![\s\S])/.test(step)) || new Set(result2.steps).size !== result2.steps.length ? authorityUnavailable() : { available: !0, steps: [...result2.steps] };
@@ -2751,28 +3157,28 @@ function routinePublicationClient2(options = {}) {
   } : async () => {
     throw new Error("Member publication requires a host-supplied request");
   });
-  async function send2(operation2, body2) {
+  async function send3(operation2, body2) {
     if (local) return await local(operation2, body2);
-    let response = await request(`/api/cli/workspaces/${workspace}/inbox/${operation2}`, {
+    let response2 = await request(`/api/cli/workspaces/${workspace}/inbox/${operation2}`, {
       method: "POST",
       headers: { "content-type": "application/json", ...headers },
       body: JSON.stringify(body2)
-    }), result2 = await response.json();
-    if (!response.ok && operation2 === "records/update")
+    }), result2 = await response2.json();
+    if (!response2.ok && operation2 === "records/update")
       throw new RoutineRecordWriteError(result2.error ?? "Could not confirm routine preparation", result2.effect ?? "uncertain");
-    if (!response.ok) throw new Error(result2.error ?? "Could not confirm routine publication");
+    if (!response2.ok) throw new Error(result2.error ?? "Could not confirm routine publication");
     return result2;
   }
   let transport = {
     async publish(body2) {
-      return await send2("publish", body2);
+      return await send3("publish", body2);
     },
     async resolve(body2) {
-      await send2("resolve", body2);
+      await send3("resolve", body2);
     }
   };
   async function readRecords(input) {
-    return await send2("records/read", validateRecordRead(input));
+    return await send3("records/read", validateRecordRead(input));
   }
   return {
     ...createInboxPublisher(transport),
@@ -2781,15 +3187,15 @@ function routinePublicationClient2(options = {}) {
       readRecords,
       async writeRecords(input, options2) {
         if (!capability) throw new Error("A trusted routine launch is required");
-        return await send2("records/update", validateRoutineRecordWrite({ input, requestKey: options2?.requestKey }));
+        return await send3("records/update", validateRoutineRecordWrite({ input, requestKey: options2?.requestKey }));
       },
       async updateRecords(input, options2) {
         if (!capability) throw new Error("A trusted routine launch is required");
-        return await send2("records/update", validateRoutineRecordWrite({ input: validateRecordUpdate(input), requestKey: options2?.requestKey }));
+        return await send3("records/update", validateRoutineRecordWrite({ input: validateRecordUpdate(input), requestKey: options2?.requestKey }));
       },
       async deleteRecords(input, options2) {
         if (!capability) throw new Error("A trusted routine launch is required");
-        return await send2("records/update", validateRoutineRecordWrite({ input: validateRecordDelete(input), requestKey: options2?.requestKey }));
+        return await send3("records/update", validateRoutineRecordWrite({ input: validateRecordDelete(input), requestKey: options2?.requestKey }));
       }
     },
     files: {
@@ -2800,7 +3206,7 @@ function routinePublicationClient2(options = {}) {
       }
     },
     async check(body2) {
-      await send2("check", { requestKey: body2.requestKey, item: validatePublication(body2.item) });
+      await send3("check", { requestKey: body2.requestKey, item: validatePublication(body2.item) });
     }
   };
 }
@@ -2811,6 +3217,7 @@ export {
   DataOperationError,
   FileOperationError,
   InboxContractError,
+  InboxOperationError,
   RoutineRecordWriteError,
   app,
   appRun,
@@ -2824,6 +3231,7 @@ export {
   file,
   fileBlock,
   files,
+  inbox,
   os,
   question,
   recordBlock,