@oddington/sdk 0.1.17 → 0.1.19

package/dist/browser.js

@@ -1782,9 +1782,14 @@ var InboxOperationError = class extends Error {
   }
   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 = {
+}, INBOX_RESULT_BYTES = 8 * 1024 * 1024, INBOX_INPUT_BYTES = 8192, INBOX_LOCAL_INPUT_BYTES = 256 * 1024, 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;
+function isAppQuestionOperation(operation2) {
+  return operation2 === "questions.list" || operation2 === "questions.answer" || operation2 === "questions.searchRecords";
+}
+var operations = {
   current: [],
   "items.list": [],
+  "questions.list": [],
   "items.read": ["itemId"],
   "items.see": ["itemId"],
   "items.markDigestRead": ["itemId"],
@@ -1937,7 +1942,7 @@ function parseInboxRequest(value) {
     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"));
+    assert(required.every((key) => Object.hasOwn(input, key)) && Object.keys(input).every((key) => required.includes(key) || operation2 === "questions.searchRecords" && key === "selected" || (operation2 === "items.list" || operation2 === "questions.list") && key === "beforeNumber"));
     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 {
@@ -1990,12 +1995,32 @@ function parseInboxItem(value) {
     assert(id2(work.id) && text3(work.questionId) && text3(work.reason) && optionalDate(work.settledAt));
   }), item;
 }
+function parseAnswerableQuestion(value) {
+  let entry = object3(json2(value));
+  keys3(entry, ["item", "origin", "question", "recordRefs"]);
+  let item = object3(entry.item);
+  keys3(item, ["id", "number", "revision", "title", "href"]), assert(id2(item.id) && integer(item.number) && integer(item.revision) && text3(item.title) && text3(item.href));
+  let link = new URL(item.href), slug = link.hostname.slice(0, -13);
+  assert(link.hostname.endsWith(".oddington.ai") && slug.length <= 63 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug) && !["auth", "www", "api", "os"].includes(slug) && item.href === `https://${slug}.oddington.ai/inbox/${item.id}`);
+  let origin = object3(entry.origin);
+  keys3(origin, ["routine"]), assert(text3(origin.routine) && origin.routine === origin.routine.trim());
+  let question2 = object3(entry.question);
+  keys3(question2, ["id", "prompt", "instructions", "response"]), assert(text3(question2.id) && question2.id === question2.id.trim() && text3(question2.prompt) && (question2.instructions === null || text3(question2.instructions, !0))), responseDefinition(question2.response);
+  let refs = array2(entry.recordRefs);
+  return assert(refs.every((ref) => text3(ref) && ref === ref.trim()) && new Set(refs).size === refs.length), entry;
+}
 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 === "questions.list") {
+    let page = object3(value);
+    keys3(page, ["questions", "nextBeforeNumber"]);
+    let questions = array2(page.questions).map(parseAnswerableQuestion);
+    return assert(page.nextBeforeNumber === null || integer(page.nextBeforeNumber)), { questions, nextBeforeNumber: page.nextBeforeNumber };
+  }
   if (operation2 === "items.read") return parseInboxItem(value);
   if (operation2 === "items.list") {
     let page = object3(value), items = array2(page.items).map(parseInboxItem);
@@ -2063,134 +2088,80 @@ async function limitedBody(request, limit, timeoutMs) {
   }
 }
 
-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();
+var 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;
+function parseInboxHostContext(value) {
+  if (!value || typeof value != "object" || Array.isArray(value)) throw new Error("Inbox context unavailable");
+  let v = value;
+  if (v.kind !== "inbox" && v.kind !== "focused" || Object.keys(v).sort().join(",") !== (v.kind === "inbox" ? "generation,kind,memberId,workspaceId" : "appId,generation,kind,memberId,workspaceId") || typeof v.workspaceId != "string" || !UUID.test(v.workspaceId) || typeof v.memberId != "string" || !UUID.test(v.memberId) || typeof v.generation != "string" || !UUID.test(v.generation) || v.kind === "focused" && (typeof v.appId != "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(v.appId)))
+    throw new Error("Inbox context unavailable");
+  let base = { workspaceId: v.workspaceId, memberId: v.memberId, generation: v.generation };
+  return Object.freeze(v.kind === "inbox" ? { ...base, kind: "inbox" } : { ...base, kind: "focused", appId: v.appId });
+}
+
+var InboxContextError = class extends Error {
+  constructor(status) {
+    super("Inbox context unavailable");
+    this.status = status;
   }
-  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),
+  status;
+}, contexts = /* @__PURE__ */ new WeakMap();
+function resolveHostedInboxContext(host) {
+  if (!host.binding || !host.memberId) throw new Error("Inbox context unavailable");
+  let resolve = contexts.get(host.binding);
+  return resolve || (resolve = hostedInboxContext(), contexts.set(host.binding, resolve)), resolve({ ...host, memberId: host.memberId });
+}
+function hostedInboxContext() {
+  let installed2, revision = 0, issued = 0, settled = 0;
+  return async (host) => {
+    let started = ++issued, check = () => {
+      if (!host.isCurrent() || host.expiresAt <= Date.now()) throw new Error("Inbox context unavailable");
+    };
+    check();
+    let response2 = await fetch(`${host.endpoint}/api/inbox/context`, {
+      method: "GET",
+      headers: { authorization: `Bearer ${host.accessToken}` },
+      credentials: "omit",
       redirect: "error",
       cache: "no-store",
-      signal: AbortSignal.timeout(3e4)
+      signal: AbortSignal.timeout(15e3)
     });
     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();
+      if (check(), (response2.status === 401 || response2.status === 403) && (installed2 = void 0, revision++, settled = Math.max(settled, started)), !response2.ok || response2.status !== 200) throw new InboxContextError(response2.status);
+      let bytes = await limitedBody(response2, 4096);
+      if (check(), !bytes) throw new Error("Inbox context unavailable");
+      let context2 = parseInboxHostContext(JSON.parse(new TextDecoder("utf-8", { fatal: !0 }).decode(bytes)));
+      if (context2.memberId !== host.memberId) throw new Error("Inbox context unavailable");
+      if (JSON.stringify(installed2) !== JSON.stringify(context2)) {
+        if (started < settled) throw new Error("Inbox context unavailable");
+        installed2 = context2, revision++;
       }
-      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);
-}
-function browserAuthSource(handle2) {
-  return sources.get(handle2);
+      settled = Math.max(settled, started);
+      let current2 = revision;
+      return Object.freeze({ context: context2, isCurrent: () => host.isCurrent() && host.expiresAt > Date.now() && current2 === revision });
+    } finally {
+      response2.body?.cancel().catch(() => {
+      });
+    }
+  };
 }
 
 var sessionKey = "_os.app.session", responseChecks = /* @__PURE__ */ new WeakMap(), AppResponseReadError = class extends Error {
 }, AppContextDenied = class extends Error {
 }, AppRenewalUnavailable = class extends Error {
 };
+async function untilAborted(work, signal) {
+  if (signal.aborted)
+    throw work.catch(() => {
+    }), new AppRenewalUnavailable();
+  let abort, cancelled = new Promise((_resolve, reject) => {
+    abort = () => reject(new AppRenewalUnavailable()), signal.addEventListener("abort", abort, { once: !0 });
+  });
+  try {
+    return await Promise.race([work, cancelled]);
+  } finally {
+    signal.removeEventListener("abort", 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 = () => {
@@ -2230,159 +2201,164 @@ function isAppOrigin(value) {
   }
 }
 function appContext(origin, active2) {
-  let binding, credential, denied = !1, controller = new AbortController(), expiry, startup, renewalTimer, renewal, observation, resolution2, disposed = !1, stored = () => globalThis.localStorage.getItem(sessionKey), alive = () => {
+  let binding, credential, pair, serialized, denied = !1, controller = new AbortController(), access = new AbortController(), expiry, startup, renewalTimer, renewal, observation, resolution2, disposed = !1, stored = () => globalThis.localStorage.getItem(sessionKey), alive = () => {
     try {
-      return !denied && !disposed && active2() && globalThis.location.origin === origin && (!binding || binding.expiresAt > Date.now());
+      return !denied && !disposed && active2() && globalThis.location.origin === origin;
     } catch {
       return !1;
     }
   }, cancel = () => {
-    controller.abort(), clearTimeout(expiry), clearTimeout(startup), clearTimeout(renewalTimer), clearInterval(monitor), globalThis.removeEventListener?.("storage", storageChanged);
+    controller.abort(), access.abort(), clearTimeout(expiry), clearTimeout(startup), clearTimeout(renewalTimer), clearInterval(monitor), globalThis.removeEventListener?.("storage", storageChanged);
+    for (let event2 of ["pageshow", "focus", "visibilitychange"]) globalThis.removeEventListener?.(event2, wake);
   }, invalidate = () => {
     denied = !0, cancel();
     try {
-      !disposed && active2() && globalThis.location.origin === origin && (!credential || globalThis.localStorage.getItem(sessionKey) === credential) && globalThis.localStorage.removeItem(sessionKey);
+      !disposed && active2() && globalThis.location.origin === origin && (!serialized || globalThis.localStorage.getItem(sessionKey) === serialized) && globalThis.localStorage.removeItem(sessionKey);
     } catch {
     }
   }, current2 = () => {
     try {
-      return alive() && stored() === credential;
+      return alive() && !!binding && binding.expiresAt > Date.now() && stored() === serialized;
     } catch {
       return !1;
     }
-  }, 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`, response2 = await fetch(url, {
-      credentials: "omit",
-      redirect: "error",
-      cache: "no-store",
-      referrerPolicy: "no-referrer",
-      headers: { authorization: `Bearer ${candidate}` },
-      signal
-    });
+  }, sameSession = (value) => !binding || ["appId", "memberId", "workspace", "sessionId"].every((key) => value[key] === binding[key]), bounded = (value) => validBinding(value) && value.expiresAt > Date.now() && value.expiresAt <= Date.now() + 6e5 && sameSession(value), readPair = (candidate) => {
+    let value = JSON.parse(candidate ?? "null");
+    if (!validPair(value) || value.context.expiresAt > Date.now() + 6e5 || !sameSession(value.context)) throw new Error();
+    return value;
+  }, expireAccess = () => {
+    binding && binding.expiresAt <= Date.now() && access.abort();
+  };
+  async function send3(path, candidate, signal, init2 = {}) {
+    let url = `${origin}/_os/app/${path}`, response2;
+    try {
+      response2 = await fetch(url, {
+        ...init2,
+        credentials: "omit",
+        redirect: "error",
+        cache: "no-store",
+        referrerPolicy: "no-referrer",
+        signal,
+        headers: {
+          ...init2.body === void 0 ? {} : { "content-type": "application/json" },
+          authorization: `Bearer ${candidate}`
+        }
+      });
+    } catch {
+      throw new AppRenewalUnavailable();
+    }
     if (response2.redirected || response2.url && response2.url !== url) throw new Error();
+    return response2;
+  }
+  async function proof(candidate, signal = controller.signal) {
+    if (!alive() || !validProof(candidate)) throw new Error();
+    let response2 = await send3("context", candidate, signal);
     if (response2.status === 401 || response2.status === 403) throw new AppContextDenied();
+    if (response2.status >= 500) throw new AppRenewalUnavailable();
     if (!response2.ok) throw new Error();
     let value = await appResponse(response2, 4096, signal);
     if (!alive() || !bounded(value)) throw new Error();
     return value;
   }
-  function install(value, candidate) {
-    binding = { ...value }, credential = candidate, clearTimeout(expiry), clearTimeout(renewalTimer);
+  function install(value, candidate, raw) {
+    expireAccess(), access.signal.aborted && (access = new AbortController()), binding = { ...value }, pair = candidate, credential = candidate.credential, serialized = raw, clearTimeout(expiry), clearTimeout(renewalTimer);
     let remaining = binding.expiresAt - Date.now();
-    expiry = setTimeout(invalidate, remaining), renewalTimer = setTimeout(() => {
-      renew();
+    expiry = setTimeout(expireAccess, remaining), renewalTimer = setTimeout(() => {
+      renew().catch(() => {
+      });
     }, remaining - Math.min(6e4, remaining / 5));
   }
-  async function synchronize() {
+  async function synchronize(signal = controller.signal) {
     if (!alive()) throw new Error();
-    if (credential && stored() !== credential) {
-      if (!binding) throw new Error();
-      if (observation) return observation;
-      observation = (async () => {
-        for (; alive(); ) {
-          let candidate = stored();
-          if (!candidate) throw new Error();
-          let value;
-          try {
-            value = await proof(candidate);
-          } catch {
-            if (stored() !== candidate) continue;
-            throw new Error();
-          }
-          if (stored() === candidate) {
-            install(value, candidate);
-            return;
-          }
+    if (signal.aborted) throw new AppRenewalUnavailable();
+    if (!credential || stored() === serialized) return;
+    if (!binding) throw new Error();
+    if (observation) return untilAborted(observation, signal);
+    observation = (async () => {
+      for (; alive(); ) {
+        let candidate = stored();
+        if (!candidate) throw new Error();
+        let value, replacement;
+        try {
+          replacement = readPair(candidate), value = await proof(replacement.credential, signal);
+        } catch (error) {
+          if (stored() !== candidate) continue;
+          throw error;
+        }
+        if (stored() === candidate) {
+          if (value.expiresAt !== replacement.context.expiresAt) throw new Error();
+          install(value, replacement, candidate);
+          return;
         }
-        throw new Error();
-      })();
-      try {
-        await observation;
-      } catch {
-        throw invalidate(), new Error("Local app context unavailable.");
-      } finally {
-        observation = void 0;
       }
+      throw new Error();
+    })();
+    let observed = observation;
+    try {
+      await untilAborted(observed, signal);
+    } catch (error) {
+      throw error instanceof AppRenewalUnavailable || error instanceof AppResponseReadError || invalidate(), error;
+    } finally {
+      observation === observed && (observation = void 0);
     }
   }
   async function renew() {
-    if (!(renewal || !binding || !alive())) {
-      renewal = (async () => {
-        let deadline = binding.expiresAt, requestController = new AbortController(), abort = () => requestController.abort();
-        controller.signal.addEventListener("abort", abort, { once: !0 });
-        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`, response2;
-          try {
-            response2 = await fetch(url, {
-              method: "POST",
-              credentials: "omit",
-              redirect: "error",
-              cache: "no-store",
-              referrerPolicy: "no-referrer",
-              signal: requestController.signal,
-              headers: { authorization: `Bearer ${previous}` }
+    if (renewal) return renewal;
+    if (!binding || !pair || !alive()) throw new Error();
+    renewal = (async () => {
+      let requestController = new AbortController(), abort = () => requestController.abort();
+      controller.signal.addEventListener("abort", abort, { once: !0 });
+      let timeout = setTimeout(abort, 2e4), previous = serialized;
+      try {
+        if (await synchronize(requestController.signal), serialized !== previous) return;
+        let response2 = await send3("renew", pair.renewalCredential, requestController.signal, { method: "POST" }), 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 (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 = () => {
+                clearTimeout(timer), reject(new Error());
+              }, timer = setTimeout(() => {
+                requestController.signal.removeEventListener("abort", abortWait), resolve2();
+              }, 100);
+              requestController.signal.addEventListener("abort", abortWait, { once: !0 });
             });
-          } catch {
-            throw new AppRenewalUnavailable();
-          }
-          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 (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 = () => {
-                  clearTimeout(timer), reject(new Error());
-                }, timer = setTimeout(() => {
-                  requestController.signal.removeEventListener("abort", abortWait), resolve2();
-                }, 100);
-                requestController.signal.addEventListener("abort", abortWait, { once: !0 });
-              });
-            if (requestController.signal.aborted) throw new Error();
-            await synchronize();
-            return;
-          }
-          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();
-          if (stored() !== previous) {
-            await synchronize();
+          if (requestController.signal.aborted) throw new Error();
+          await synchronize(requestController.signal);
+          return;
+        }
+        if (!response2.ok) throw new Error();
+        if (!alive() || !validPair(value) || !bounded(value.context) || (/* @__PURE__ */ new Set([value.credential, value.renewalCredential, pair.credential, pair.renewalCredential])).size !== 4) throw new Error();
+        if (stored() !== previous) {
+          await synchronize(requestController.signal);
+          return;
+        }
+        let raw = JSON.stringify(value);
+        globalThis.localStorage.setItem(sessionKey, raw), install(value.context, value, raw);
+      } catch (error) {
+        try {
+          if (alive() && stored() && stored() !== previous) {
+            await synchronize(requestController.signal);
             return;
           }
-          globalThis.localStorage.setItem(sessionKey, result2.credential), install(result2.context, result2.credential);
-        } catch (error) {
-          try {
-            if (alive() && stored() && stored() !== previous) {
-              await synchronize();
-              return;
-            }
-          } catch {
-          }
-          try {
-            if (alive() && stored() && stored() !== previous) {
-              await synchronize();
-              return;
-            }
-          } catch {
-          }
-          (error instanceof AppRenewalUnavailable || error instanceof AppResponseReadError || requestController.signal.aborted) && current2() && Date.now() < deadline ? renewalTimer = setTimeout(() => {
-            renew();
-          }, Math.min(5e3, (deadline - Date.now()) / 5)) : invalidate();
-        } finally {
-          clearTimeout(timeout), controller.signal.removeEventListener("abort", abort);
+        } catch {
         }
-      })();
-      try {
-        await renewal;
+        throw (error instanceof AppRenewalUnavailable || error instanceof AppResponseReadError || requestController.signal.aborted) && alive() ? current2() && (renewalTimer = setTimeout(
+          () => {
+            renew().catch(() => {
+            });
+          },
+          Math.min(5e3, (binding.expiresAt - Date.now()) / 5)
+        )) : invalidate(), new AppRenewalUnavailable();
       } finally {
-        renewal = void 0;
+        clearTimeout(timeout), controller.signal.removeEventListener("abort", abort);
       }
+    })();
+    try {
+      await renewal;
+    } finally {
+      renewal = void 0;
     }
   }
   let storageChanged = () => {
@@ -2391,101 +2367,102 @@ function appContext(origin, active2) {
         invalidate();
         return;
       }
-      synchronize().catch(invalidate);
+      expireAccess(), synchronize().catch(() => {
+      });
     }
   }, monitor = setInterval(() => {
     storageChanged();
   }, 100);
   globalThis.addEventListener?.("storage", storageChanged);
+  let wake = () => {
+    alive() && resolve().catch(() => {
+    });
+  };
+  for (let event2 of ["pageshow", "focus", "visibilitychange"]) globalThis.addEventListener?.(event2, wake);
   let dispose = () => {
     disposed = !0, cancel();
   };
+  async function settledAccess(signal) {
+    for (await synchronize(); alive() && stored() !== serialized; ) await synchronize();
+    if (signal.aborted || !current2()) throw new Error();
+  }
   async function requestData(operation2, input) {
     try {
       if (operation2 !== "data/query" || !current2()) throw new Error();
-      let url = `${origin}/_os/app/data`, admitted = credential, response2 = await fetch(url, {
-        method: "POST",
-        credentials: "omit",
-        redirect: "error",
-        cache: "no-store",
-        referrerPolicy: "no-referrer",
-        signal: controller.signal,
-        headers: { "content-type": "application/json", authorization: `Bearer ${credential}` },
-        body: JSON.stringify(input)
-      });
-      for (await synchronize(); alive() && stored() !== credential; ) await synchronize();
-      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(response2, Number.MAX_SAFE_INTEGER, controller.signal);
-      for (await synchronize(); alive() && stored() !== credential; ) await synchronize();
-      if (!current2()) throw new Error();
-      if (!response2.ok) throw dataTransportError(response2.status, result2);
+      let admitted = credential, signal = access.signal, response2 = await send3("data", credential, signal, { method: "POST", body: JSON.stringify(input) });
+      if (await settledAccess(signal), response2.status === 401 || response2.status === 403)
+        throw admitted === credential && current2() && invalidate(), new DataOperationError("access_denied");
+      let result2 = await appResponse(response2, Number.MAX_SAFE_INTEGER, signal);
+      if (await settledAccess(signal), !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);
     }
   }
+  async function requestInbox(operation2, input) {
+    if (!["questions.list", "questions.answer", "questions.searchRecords"].includes(operation2)) throw new Error("Inbox operation unavailable");
+    return requestChecked("inbox", { method: "POST", body: JSON.stringify({ operation: operation2, input }) }, !0);
+  }
   async function requestRoutine(key, suffix, init2 = {}) {
-    if (!current2())
-      throw invalidate(), new Error("Local app context unavailable.");
-    let url = `${origin}/_os/app/routines/${encodeURIComponent(key)}/${suffix}`, admitted = credential, response2 = await fetch(url, {
-      ...init2,
-      credentials: "omit",
-      redirect: "error",
-      cache: "no-store",
-      referrerPolicy: "no-referrer",
-      signal: controller.signal,
-      headers: { ...init2.body === void 0 ? {} : { "content-type": "application/json" }, authorization: `Bearer ${credential}` }
-    });
-    for (await synchronize(); alive() && stored() !== credential; ) await synchronize();
-    if (!current2() || response2.redirected || response2.url && response2.url !== url)
-      throw invalidate(), new Error("Local app context unavailable.");
-    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();
+    return requestChecked(`routines/${encodeURIComponent(key)}/${suffix}`, init2);
+  }
+  async function requestChecked(path, init2, inbox2 = !1) {
+    if (!current2()) throw new Error("Local app context unavailable.");
+    let admitted = credential, signal = access.signal, response2 = await send3(path, credential, signal, init2);
+    return await settledAccess(signal), (response2.status === 401 || !inbox2 && response2.status === 403) && admitted === credential && current2() && invalidate(), responseChecks.set(response2, async (value) => {
+      await settledAccess(signal), admitted === credential && current2() && value && typeof value == "object" && "error" in value && value.error === "authority_unavailable" && invalidate();
     }), response2;
   }
   function context2() {
-    let issued = credential;
+    let issued = credential, signal = access.signal;
     return {
       kind: "local",
       ...binding,
       get expiresAt() {
         return binding.expiresAt;
       },
-      isCurrent: current2,
-      signal: controller.signal,
+      isCurrent: () => !signal.aborted && current2(),
+      signal,
       invalidate: () => {
-        issued === credential && invalidate();
+        issued === credential && current2() && invalidate();
       },
       requestRoutine,
       requestData,
+      requestInbox,
       requestAvailability: (key) => requestRoutine(key, "availability", { method: "GET" })
     };
   }
   let resolveOnce = async () => {
     let attempted;
     try {
-      if (denied || !active2() || globalThis.location.origin !== origin) throw new Error();
-      credential && await synchronize();
-      let candidate = stored();
-      if (!candidate || !/^[A-Za-z0-9_-]{43}$/.test(candidate)) throw new Error();
-      if (credential = candidate, attempted = candidate, !current2()) throw new Error();
-      let value = await proof(candidate);
-      if (stored() !== candidate || credential !== candidate)
-        return binding || (binding = { ...value }), await synchronize(), context2();
+      if (!alive()) throw new Error();
+      if (!pair) {
+        let candidate2 = stored(), retained2 = readPair(candidate2);
+        pair = retained2, binding = { ...retained2.context }, credential = retained2.credential, serialized = candidate2;
+      }
+      if (expireAccess(), binding.expiresAt <= Date.now()) {
+        if (await renew(), !current2()) throw new AppRenewalUnavailable();
+        return context2();
+      }
+      await synchronize();
+      let candidate = stored(), retained = readPair(candidate);
+      if (attempted = candidate ?? void 0, !current2()) throw new AppRenewalUnavailable();
+      let value = await proof(retained.credential);
+      if (stored() !== candidate || serialized !== candidate)
+        return await synchronize(), context2();
       if (!current2()) throw new Error();
-      if (binding && value.expiresAt > binding.expiresAt) throw new Error();
-      return (!binding || value.expiresAt !== binding.expiresAt) && install(value, candidate), context2();
+      if (expiry && binding && value.expiresAt > binding.expiresAt) throw new Error();
+      return (!expiry || value.expiresAt !== binding.expiresAt) && install(value, retained, candidate), context2();
     } catch (error) {
+      if (alive() && error instanceof AppRenewalUnavailable)
+        throw new Error();
       try {
-        if (binding && current2() && attempted && attempted !== credential) return context2();
-        if (binding && alive() && stored() && stored() !== credential)
+        if (binding && current2() && attempted && attempted !== serialized) return context2();
+        if (binding && alive() && stored() && stored() !== serialized)
           return await synchronize(), context2();
       } catch {
       }
-      throw error instanceof AppContextDenied && binding && alive() && renewal ? new Error("Local app context unavailable.") : (invalidate(), new Error("Local app context unavailable."));
+      throw error instanceof AppContextDenied && binding && alive() && renewal ? new Error() : alive() && (error instanceof AppResponseReadError || pair && stored() === serialized && !current2()) ? new Error() : (invalidate(), new Error());
     }
   }, resolve = () => resolution2 || (resolution2 = resolveOnce().finally(() => {
     resolution2 = void 0;
@@ -2497,10 +2474,205 @@ function appContext(origin, active2) {
     }, 0);
   }, invalidate, dispose };
 }
+function validProof(value) {
+  return typeof value == "string" && /^[A-Za-z0-9_-]{43}$/.test(value);
+}
 function validBinding(value) {
   if (!value || typeof value != "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "appId,expiresAt,memberId,sessionId,workspace") return !1;
   let binding = value;
-  return typeof binding.appId == "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(binding.appId) && typeof binding.workspace == "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(binding.workspace) && typeof binding.memberId == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(binding.memberId) && typeof binding.sessionId == "string" && /^[A-Za-z0-9_-]{43}$/.test(binding.sessionId) && typeof binding.expiresAt == "number" && Number.isFinite(binding.expiresAt);
+  return typeof binding.appId == "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(binding.appId) && typeof binding.workspace == "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(binding.workspace) && typeof binding.memberId == "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(binding.memberId) && validProof(binding.sessionId) && typeof binding.expiresAt == "number" && Number.isFinite(binding.expiresAt);
+}
+function validPair(value) {
+  if (!value || typeof value != "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "context,credential,renewalCredential") return !1;
+  let pair = value;
+  return validProof(pair.credential) && validProof(pair.renewalCredential) && pair.credential !== pair.renewalCredential && validBinding(pair.context);
+}
+
+var unavailable2 = () => new InboxOperationError(503, "unavailable"), stale = () => new InboxOperationError(401, "authority_unavailable");
+function hostFailure(error, context2) {
+  return !context2.isCurrent() || context2.expiresAt <= Date.now() || error instanceof InboxContextError && error.status === 401 ? stale() : error instanceof InboxContextError && error.status === 403 ? new InboxOperationError(403, "access_denied") : unavailable2();
+}
+async function send2(operation2, input) {
+  let envelope = parseInboxRequest({ operation: operation2, input }), context2;
+  try {
+    context2 = await resolveAppContext();
+  } catch {
+    throw stale();
+  }
+  if (context2.kind === "local") {
+    if (!isAppQuestionOperation(operation2)) throw new InboxOperationError(403, "access_denied");
+    let check2 = () => {
+      if (!context2.isCurrent() || context2.signal.aborted || context2.expiresAt <= Date.now()) throw stale();
+    };
+    try {
+      let response2 = await context2.requestInbox(operation2, envelope.input), value = await appResponse(response2, INBOX_RESULT_BYTES, context2.signal);
+      if (check2(), !response2.ok) throw 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 unavailable2();
+      let parsed = parseInboxResult(operation2, value);
+      if (check2(), operation2 === "questions.answer" && typeof envelope.input.response.selection == "object" && !parsed.label?.trim()) throw unavailable2();
+      return parsed;
+    } catch (error) {
+      throw check2(), error instanceof InboxOperationError ? error : unavailable2();
+    }
+  }
+  if (context2.endpoint !== `https://${context2.workspace}.oddington.ai` || ["auth", "www", "api", "os"].includes(context2.workspace)) throw stale();
+  let host;
+  try {
+    host = await resolveHostedInboxContext(context2);
+  } catch (error) {
+    throw hostFailure(error, context2);
+  }
+  if (!host) throw unavailable2();
+  let check = () => {
+    if (!context2.isCurrent() || !host.isCurrent() || !Number.isFinite(context2.expiresAt) || context2.expiresAt <= Date.now()) throw stale();
+  };
+  if (check(), host.context.kind === "focused" && !isAppQuestionOperation(operation2))
+    throw new InboxOperationError(403, "access_denied");
+  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 host;
+      try {
+        host = initial.kind !== "local" && await resolveHostedInboxContext(initial);
+      } catch (error) {
+        throw hostFailure(error, initial);
+      }
+      if (initial.kind === "local") throw new InboxOperationError(403, "access_denied");
+      if (!host) throw unavailable2();
+      let check = () => {
+        if (!initial.isCurrent() || !host.isCurrent() || initial.expiresAt <= Date.now()) throw stale();
+      };
+      do {
+        check();
+        let page = await send2("items.list", beforeNumber === void 0 ? {} : { beforeNumber });
+        if (check(), beforeNumber !== void 0 && (page.items.some((item) => item.number >= beforeNumber) || page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber)) throw unavailable2();
+        if (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: {
+    async list() {
+      let questions = [], beforeNumber, initial;
+      try {
+        initial = await resolveAppContext();
+      } catch {
+        throw stale();
+      }
+      let host;
+      try {
+        host = initial.kind !== "local" && await resolveHostedInboxContext(initial);
+      } catch (error) {
+        throw hostFailure(error, initial);
+      }
+      if (initial.kind !== "local" && !host) throw unavailable2();
+      let check = () => {
+        if (!initial.isCurrent() || host && !host.isCurrent() || initial.expiresAt <= Date.now()) throw stale();
+      };
+      do {
+        check();
+        let page = await send2("questions.list", beforeNumber === void 0 ? {} : { beforeNumber });
+        if (check(), page.questions.some((question2) => question2.item.href !== `https://${initial.workspace}.oddington.ai/inbox/${question2.item.id}`) || beforeNumber !== void 0 && (page.questions.some((question2) => question2.item.number >= beforeNumber) || page.nextBeforeNumber !== null && page.nextBeforeNumber >= beforeNumber)) throw unavailable2();
+        if (questions.push(...page.questions), page.nextBeforeNumber === null) return questions;
+        beforeNumber = page.nextBeforeNumber;
+      } while (!0);
+    },
+    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);
+}
+function browserAuthSource(handle2) {
+  return sources.get(handle2);
 }
 
 var installedDispose;
@@ -2521,7 +2693,7 @@ function init({ auth: input }) {
     url.protocol === "https:" && !url.port && !url.username && !url.password && !url.search && !url.hash && url.pathname === "/" && /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(slug) && slug !== "auth" && (endpoint = url.origin, workspace = slug);
   } catch {
   }
-  let active2 = !0, revision = 0, person, token, local = localOrigin ? appContext(localOrigin, () => active2) : void 0, subscription, stopDisposal, uninstall = installMemberContext(async () => {
+  let active2 = !0, revision = 0, person, token, binding = {}, local = localOrigin ? appContext(localOrigin, () => active2) : void 0, subscription, stopDisposal, uninstall = installMemberContext(async () => {
     if (local) return local.resolve();
     if (!active2 || !endpoint || !workspace || globalThis.location.origin !== endpoint) throw new Error("Hosted Data context unavailable.");
     let started = revision, { data: { session }, error } = await auth2.getSession();
@@ -2530,12 +2702,16 @@ function init({ auth: input }) {
     let expiresAt = (session.expires_at ?? 0) * 1e3;
     if (!Number.isFinite(expiresAt) || expiresAt <= Date.now() || !session.user.id)
       throw new Error("Hosted Data context unavailable.");
-    return person = session.user.id, {
+    person = session.user.id;
+    let isCurrent = () => active2 && globalThis.location.origin === endpoint && revision === started && person === session.user.id;
+    return {
       workspace,
       endpoint,
       accessToken: session.access_token,
       expiresAt,
-      isCurrent: () => active2 && globalThis.location.origin === endpoint && revision === started && person === session.user.id
+      isCurrent,
+      memberId: session.user.id,
+      binding
     };
   }), dispose = () => {
     active2 && (active2 = !1, local?.dispose(), revision++, subscription?.unsubscribe(), stopDisposal?.(), uninstall(), installedDispose === dispose && (installedDispose = void 0));