@oddington/sdk 0.1.8 → 0.1.10

package/dist/index.js

@@ -21709,44 +21709,91 @@ class DataOperationError extends Error {
   }
 }
 
-// ../../shared/data-search-input.ts
+// ../../shared/data-history-input.ts
 var invalid = () => {
   throw new DataOperationError("invalid_query");
 };
-var scalarText = (value) => typeof value === "string" && !/[\u0000\uD800-\uDFFF]/u.test(value);
-function captureRecordsSearchInput(query, options) {
-  if (!scalarText(query))
+var historyText = (value) => typeof value === "string" && !/[\u0000\uD800-\uDFFF]/u.test(value);
+function historyVersion(value) {
+  return historyText(value) && value.length > 0 && new TextEncoder().encode(value).length <= 1024 && !/[\u0000-\u001f\u007f-\u009f]/.test(value) && !/^[0-9a-f]{40}$/i.test(value);
+}
+function historyProperties(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value)))
+    return invalid();
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(value).some((key) => typeof key !== "string" || !descriptors[key]?.enumerable || !Object.hasOwn(descriptors[key], "value")))
+    return invalid();
+  return descriptors;
+}
+function captureHistoryListOptions(value) {
+  if (value === undefined)
+    return {};
+  const descriptors = historyProperties(value), result = {};
+  if (Object.keys(descriptors).some((key) => !["limit", "before"].includes(key)))
+    return invalid();
+  if (Object.hasOwn(descriptors, "limit")) {
+    const limit = descriptors.limit.value;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100)
+      return invalid();
+    result.limit = limit;
+  }
+  if (Object.hasOwn(descriptors, "before")) {
+    const before = descriptors.before.value;
+    if (!historyVersion(before))
+      return invalid();
+    result.before = before;
+  }
+  return result;
+}
+function captureHistoryInstant(value) {
+  if (!historyText(value) || value.length > 1024)
+    return invalid();
+  const match = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?([Zz]|([+-])(\d{2}):(\d{2}))$/.exec(value);
+  if (!match)
     return invalid();
+  const [year, month, day, hour, minute, second] = match.slice(1, 7).map(Number);
+  const days = new Date(Date.UTC(year, month, 0));
+  days.setUTCFullYear(year);
+  if (year < 1 || month < 1 || month > 12 || day < 1 || day > days.getUTCDate() || hour > 23 || minute > 59 || second > 59 || Number(match[9] ?? 0) > 23 || Number(match[10] ?? 0) > 59)
+    return invalid();
+  return value;
+}
+
+// ../../shared/data-search-input.ts
+var invalid2 = () => {
+  throw new DataOperationError("invalid_query");
+};
+function captureRecordsSearchInput(query, options) {
+  if (!historyText(query))
+    return invalid2();
   const length = [...query.trim()].length;
   if (length < 1 || length > 256)
-    return invalid();
+    return invalid2();
   if (options === undefined)
     return { query };
-  if (!options || typeof options !== "object" || Array.isArray(options) || ![Object.prototype, null].includes(Object.getPrototypeOf(options)))
-    return invalid();
-  const descriptors = Object.getOwnPropertyDescriptors(options);
-  if (Reflect.ownKeys(options).some((key) => typeof key !== "string" || !["collections", "limit"].includes(key) || !descriptors[key]?.enumerable || !Object.hasOwn(descriptors[key], "value")))
-    return invalid();
+  const descriptors = historyProperties(options);
+  if (Object.keys(descriptors).some((key) => !["collections", "limit"].includes(key)))
+    return invalid2();
   const captured = {};
   if (Object.hasOwn(descriptors, "collections")) {
     const supplied = descriptors.collections.value;
     if (!Array.isArray(supplied) || supplied.length < 1 || supplied.length > 16 || Reflect.ownKeys(supplied).length !== supplied.length + 1)
-      return invalid();
+      return invalid2();
     const collections = [];
     for (let index = 0;index < supplied.length; index++) {
       const descriptor = Object.getOwnPropertyDescriptor(supplied, String(index));
-      if (!descriptor?.enumerable || !Object.hasOwn(descriptor, "value") || !scalarText(descriptor.value))
-        return invalid();
+      if (!descriptor?.enumerable || !Object.hasOwn(descriptor, "value") || !historyText(descriptor.value))
+        return invalid2();
       collections.push(descriptor.value);
     }
     if (new Set(collections).size !== collections.length)
-      return invalid();
+      return invalid2();
     captured.collections = collections;
   }
   if (Object.hasOwn(descriptors, "limit")) {
     const supplied = descriptors.limit.value;
     if (!Number.isInteger(supplied) || supplied < 1 || supplied > 100)
-      return invalid();
+      return invalid2();
     captured.limit = supplied;
   }
   return { query, options: captured };
@@ -21886,55 +21933,55 @@ class FileOperationError extends Error {
 var FILE_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
 var FILE_ORIGINAL_MAX_BYTES = 5 * 1024 ** 3;
 function parseFileDescriptor(value) {
-  const invalid2 = () => {
+  const invalid3 = () => {
     throw new FileOperationError("unavailable", 503, true);
   };
   if (!value || typeof value !== "object" || Array.isArray(value))
-    return invalid2();
+    return invalid3();
   const f = value;
   if (Object.keys(f).sort().join(",") !== "details,enrichments,id,mediaType,name,path,sha256,size" || typeof f.id !== "string" || !FILE_ID_PATTERN.test(f.id) || !safeFileName(f.name) || !safeFilePath(f.path) || !Number.isSafeInteger(f.size) || f.size < 0 || f.size > FILE_ORIGINAL_MAX_BYTES || typeof f.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(f.sha256) || !f.enrichments || typeof f.enrichments !== "object" || Array.isArray(f.enrichments) || !f.details || typeof f.details !== "object" || Array.isArray(f.details))
-    return invalid2();
+    return invalid3();
   const d = f.details;
   if (d.kind === "other") {
     if (Object.keys(d).length !== 1 || f.mediaType !== "application/octet-stream")
-      return invalid2();
+      return invalid3();
   } else if (d.kind === "csv") {
     if (Object.keys(d).sort().join(",") !== "dataRows,delimiter,encoding,headerRow,kind" || f.mediaType !== "text/csv" || !["utf-8", "windows-1252"].includes(d.encoding) || ![",", ";", "\t"].includes(d.delimiter) || !Number.isSafeInteger(d.headerRow) || d.headerRow < 1 || !Number.isSafeInteger(d.dataRows) || d.dataRows < 0)
-      return invalid2();
+      return invalid3();
   } else
-    return invalid2();
+    return invalid3();
   for (const [name, descriptor] of Object.entries(f.enrichments)) {
     if (!safeEnrichmentName(name))
-      return invalid2();
+      return invalid3();
     parseEnrichmentDescriptor(descriptor);
   }
   if (new TextEncoder().encode(JSON.stringify(f)).byteLength > 16 * 1024)
-    return invalid2();
+    return invalid3();
   return f;
 }
 function parseEnrichmentDescriptor(value) {
-  const invalid2 = () => {
+  const invalid3 = () => {
     throw new FileOperationError("unavailable", 503, true);
   };
   if (!value || typeof value !== "object" || Array.isArray(value))
-    return invalid2();
+    return invalid3();
   const d = value;
   if (Object.keys(d).sort().join(",") !== "mediaType,sha256,size" || !["application/octet-stream", "text/plain", "text/markdown", "application/json"].includes(d.mediaType) || !Number.isSafeInteger(d.size) || d.size < 0 || d.size > 16 * 1024 * 1024 || typeof d.sha256 !== "string" || !/^[0-9a-f]{64}$/.test(d.sha256))
-    return invalid2();
+    return invalid3();
   return d;
 }
 function safeEnrichmentName(value) {
   return safeFileName(value) && !/^original(?:\.|$)/i.test(value);
 }
 function parseFileEnrichMetadata(value, maxBytes) {
-  const invalid2 = () => {
+  const invalid3 = () => {
     throw new FileOperationError("invalid_input", 400);
   };
   if (!value || typeof value !== "object" || Array.isArray(value))
-    return invalid2();
+    return invalid3();
   const d = value;
   if (Object.keys(d).some((key) => !["name", "size", "mediaType", "replace"].includes(key)) || !safeEnrichmentName(d.name) || !Number.isSafeInteger(d.size) || d.size < 0 || d.mediaType !== undefined && (typeof d.mediaType !== "string" || d.mediaType.length > 255 || /[\u0000-\u001f\u007f]/.test(d.mediaType)) || d.replace !== undefined && (typeof d.replace !== "string" || !/^[0-9a-f]{64}$/.test(d.replace)))
-    return invalid2();
+    return invalid3();
   if (d.size > maxBytes)
     throw new FileOperationError("request_too_large", 413);
   return d;
@@ -21946,37 +21993,37 @@ function safeFilePath(value) {
   return typeof value === "string" && value.length <= 1024 && value.split("/").every(safeFileName);
 }
 function parseFileCreateMetadata(value, maxBytes) {
-  const invalid2 = () => {
+  const invalid3 = () => {
     throw new FileOperationError("invalid_input", 400);
   };
   if (!value || typeof value !== "object" || Array.isArray(value))
-    return invalid2();
+    return invalid3();
   const input = value;
   if (Object.keys(input).some((key) => !["name", "path", "storage", "csv", "size", "requestKey"].includes(key)))
-    return invalid2();
+    return invalid3();
   const path = input.path === undefined ? "Files" : input.path;
   if (!safeFileName(input.name) || !safeFilePath(path))
-    return invalid2();
+    return invalid3();
   if (input.storage !== undefined && input.storage !== "remote" && input.storage !== "local")
-    return invalid2();
+    return invalid3();
   if (!Number.isSafeInteger(input.size) || input.size < 0)
-    return invalid2();
+    return invalid3();
   if (input.size > maxBytes)
     throw new FileOperationError("request_too_large", 413);
   if (typeof input.requestKey !== "string" || input.requestKey.length < 1 || input.requestKey.length > 256 || input.requestKey !== input.requestKey.trim() || /[\u0000-\u001f\u007f]/.test(input.requestKey))
-    return invalid2();
+    return invalid3();
   let csv;
   if (input.csv !== undefined) {
     if (!input.csv || typeof input.csv !== "object" || Array.isArray(input.csv))
-      return invalid2();
+      return invalid3();
     const hints = input.csv;
     if (Object.keys(hints).some((key) => !["encoding", "delimiter", "headerRow"].includes(key)))
-      return invalid2();
+      return invalid3();
     const encoding = hints.encoding === undefined ? "utf-8" : hints.encoding;
     const delimiter = hints.delimiter === undefined ? "," : hints.delimiter;
     const headerRow = hints.headerRow === undefined ? 1 : hints.headerRow;
     if (encoding !== "utf-8" && encoding !== "windows-1252" || ![",", ";", "\t"].includes(delimiter) || !Number.isSafeInteger(headerRow) || headerRow < 1 || headerRow > 1e5)
-      return invalid2();
+      return invalid3();
     csv = { encoding, delimiter, headerRow };
   }
   return {
@@ -22030,7 +22077,7 @@ function privateRoutineRequest(environment = typeof __ODDINGTON_BROWSER__ !== "u
     const tcp = /^tcp:\/\/127\.0\.0\.1:([1-9][0-9]{0,4})$/.exec(socket);
     const endpoint = tcp ? { hostname: "127.0.0.1", port: Number(tcp[1]) } : { socketPath: socket };
     const id2 = crypto.randomUUID();
-    if (init.body instanceof ReadableStream) {
+    if (init.body instanceof ReadableStream || suffix === "" && init.method === "POST") {
       await new Promise((resolve, reject) => {
         const admission = httpRequest({
           ...endpoint,
@@ -22432,15 +22479,16 @@ var data = {
     async function send(input) {
       const context = await resolveDataContext();
       try {
-        checkDataRequestSize({ repository, ...input });
+        const envelope = { repository, ...input };
+        checkDataRequestSize(envelope);
         if ("local" in context)
-          return await context.local("data/query", { repository, ...input });
+          return await context.local("data/query", envelope);
         const response = await fetch(context.url, {
           method: "POST",
           redirect: "error",
           cache: "no-store",
           headers: { "content-type": "application/json", ...context.headers },
-          body: JSON.stringify({ repository, ...input })
+          body: JSON.stringify(envelope)
         });
         const result = await response.json();
         if (!response.ok) {
@@ -22460,13 +22508,11 @@ var data = {
       },
       records: {
         select: (query) => send({ operation: "records.select", query }),
-        search: (query, options) => {
-          try {
-            return send({ operation: "records.search", ...captureRecordsSearchInput(query, options) });
-          } catch (error) {
-            return Promise.reject(error);
-          }
-        }
+        search: async (query, options) => send({ operation: "records.search", ...captureRecordsSearchInput(query, options) })
+      },
+      history: {
+        list: async (options) => send({ operation: "history.list", options: captureHistoryListOptions(options) }),
+        at: async (instant) => send({ operation: "history.at", instant: captureHistoryInstant(instant) })
       },
       changes() {
         let updates = [], creates = [], deletes = [], publicationId;
@@ -22574,7 +22620,7 @@ var TIMEOUT_MS = 30000;
 var MAX_ACTIVE = 4;
 var ATTEMPTS = 2;
 var active = 0;
-var invalid2 = () => new FileOperationError("invalid_input", 400);
+var invalid3 = () => new FileOperationError("invalid_input", 400);
 var unavailable = () => new FileOperationError("unavailable", 503, true);
 var failures = {
   400: ["invalid_input", "unsupported_context"],
@@ -22598,7 +22644,7 @@ async function boundedBytes(stream, limit) {
       if (done)
         break;
       if (!(value instanceof Uint8Array))
-        throw invalid2();
+        throw invalid3();
       size += value.byteLength;
       if (size > limit)
         throw new FileOperationError("request_too_large", 413);
@@ -22780,7 +22826,7 @@ async function send(suffix, init, descriptor, initial, parent) {
 }
 function idPath(id2) {
   if (typeof id2 !== "string" || !FILE_ID_PATTERN.test(id2))
-    throw invalid2();
+    throw invalid3();
   return `/${id2}`;
 }
 async function multipartCreate(input, metadata, exchange, release = () => {
@@ -22844,12 +22890,12 @@ async function multipartCreate(input, metadata, exchange, release = () => {
             offset = 0;
             const value2 = await next();
             if (value2.done)
-              throw invalid2();
+              throw invalid3();
             if (!(value2.value instanceof Uint8Array))
-              throw invalid2();
+              throw invalid3();
             chunk = value2.value;
             if (chunk.byteLength > metadata.size - sent - filled)
-              throw invalid2();
+              throw invalid3();
           }
           const take = Math.min(length - filled, chunk.byteLength - offset);
           part.set(chunk.subarray(offset, offset + take), filled);
@@ -22862,7 +22908,7 @@ async function multipartCreate(input, metadata, exchange, release = () => {
         }
       }
       if (part.byteLength !== length)
-        throw invalid2();
+        throw invalid3();
       if (reader && sent + length === metadata.size) {
         lastProgress = Date.now();
         for (;; ) {
@@ -22870,7 +22916,7 @@ async function multipartCreate(input, metadata, exchange, release = () => {
           if (value2.done)
             break;
           if (!(value2.value instanceof Uint8Array) || value2.value.byteLength)
-            throw invalid2();
+            throw invalid3();
         }
       }
       const value = await request((signal) => exchange(`${route}/part`, {
@@ -22890,7 +22936,7 @@ async function multipartCreate(input, metadata, exchange, release = () => {
       for (const name of Object.keys(upload.file.enrichments)) {
         const bytes = await request(() => upload.enrichment(name));
         if (bytes.byteLength !== upload.file.enrichments[name].size || bytes.byteLength > MAX_BYTES)
-          throw invalid2();
+          throw invalid3();
         await request((signal) => exchange(`${route}/enrichments/${encodeURIComponent(name)}`, {
           method: "POST",
           headers: { "content-type": "application/octet-stream", "x-oddington-transfer": ticket },
@@ -22944,7 +22990,7 @@ function contentPath(id2, name) {
   if (name === undefined)
     return `${path}/content`;
   if (!safeEnrichmentName(name))
-    throw invalid2();
+    throw invalid3();
   return `${path}/enrichments/${encodeURIComponent(name)}/content`;
 }
 async function read(id2, names) {
@@ -22955,16 +23001,16 @@ async function read(id2, names) {
     return operation((context2, signal) => send(path, { method: "GET" }, false, context2, signal), context);
   }
   if (!Array.isArray(names))
-    throw invalid2();
+    throw invalid3();
   const distinct = [];
   const seen = new Set;
   for (const name of names) {
     if (typeof name !== "string" || !safeEnrichmentName(name))
-      throw invalid2();
+      throw invalid3();
     if (seen.has(name))
       continue;
     if (seen.size === 16)
-      throw invalid2();
+      throw invalid3();
     seen.add(name);
     distinct.push(name);
   }
@@ -22998,15 +23044,15 @@ var files = {
   async create(input, options) {
     const context = await resolveFilesContext();
     if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "size", "path", "name", "storage", "csv"].includes(key)) || options !== undefined && (!options || typeof options !== "object" || Array.isArray(options) || Object.keys(options).some((key) => key !== "requestKey")))
-      throw invalid2();
+      throw invalid3();
     const blob = input.file instanceof Blob;
     const array2 = input.file instanceof Uint8Array;
     const stream = input.file instanceof ReadableStream;
     if (!blob && !array2 && !stream)
-      throw invalid2();
+      throw invalid3();
     const intrinsic = blob ? input.file.size : array2 ? input.file.byteLength : undefined;
     if (intrinsic !== undefined && input.size !== undefined && input.size !== intrinsic)
-      throw invalid2();
+      throw invalid3();
     let name = input.name;
     if (name === undefined && blob && "name" in input.file && typeof input.file.name === "string") {
       name = typeof globalThis.File !== "undefined" && input.file instanceof globalThis.File ? input.file.name : input.file.name.split(/[\\/]/).at(-1);
@@ -23023,7 +23069,7 @@ var files = {
       throw new FileOperationError("unsupported_context", 400);
     const header = encodeURIComponent(JSON.stringify(metadata));
     if (new TextEncoder().encode(header).byteLength > METADATA_BYTES)
-      throw invalid2();
+      throw invalid3();
     if (active >= MAX_ACTIVE)
       throw new FileOperationError("capacity", 429, true);
     active++;
@@ -23057,7 +23103,7 @@ var files = {
       try {
         const bytes = array2 ? input.file.slice() : await boundedBytes(blob ? input.file.stream() : input.file, metadata.size);
         if (bytes.byteLength !== metadata.size)
-          throw invalid2();
+          throw invalid3();
         if (signal.aborted)
           throw unavailable();
         return await send("", {
@@ -23075,7 +23121,7 @@ var files = {
   async enrich(input) {
     const context = await resolveFilesContext();
     if (!input || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => !["file", "name", "content", "mediaType", "replace"].includes(key)) || typeof input.content !== "string" && !(input.content instanceof Uint8Array))
-      throw invalid2();
+      throw invalid3();
     const path = `${idPath(input.file)}/enrichments`;
     if (typeof input.content === "string" ? input.content.length > MAX_BYTES : input.content.byteLength > MAX_BYTES)
       throw new FileOperationError("request_too_large", 413);
@@ -23097,7 +23143,7 @@ var files = {
       }, MAX_BYTES);
       const header = encodeURIComponent(JSON.stringify(metadata));
       if (new TextEncoder().encode(header).byteLength > METADATA_BYTES)
-        throw invalid2();
+        throw invalid3();
       const result2 = await send(path, { method: "POST", headers: {
         "content-type": "application/octet-stream",
         "x-oddington-enrichment": header
@@ -23114,9 +23160,16 @@ var files = {
 };
 // src/app-context.ts
 var sessionKey = "_os.app.session";
+var responseChecks = new WeakMap;
 
 class AppResponseReadError extends Error {
 }
+
+class AppContextDenied extends Error {
+}
+
+class AppRenewalUnavailable 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;
@@ -23137,8 +23190,13 @@ async function appResponse(response, maximum, signal) {
       }
       if (signal.aborted)
         throw new Error;
-      if (chunk.done)
-        return JSON.parse(text3 + decoder.decode());
+      if (chunk.done) {
+        const value = JSON.parse(text3 + decoder.decode());
+        await responseChecks.get(response)?.(value);
+        if (signal.aborted)
+          throw new Error;
+        return value;
+      }
       bytes += chunk.value.byteLength;
       if (bytes > maximum) {
         abort();
@@ -23165,38 +23223,239 @@ function appContext(origin, active2) {
   let denied = false;
   const controller = new AbortController;
   let expiry;
-  const invalidate = () => {
-    denied = true;
+  let startup;
+  let renewalTimer;
+  let renewal;
+  let observation;
+  let resolution2;
+  let disposed = false;
+  const stored = () => globalThis.localStorage.getItem(sessionKey);
+  const alive = () => {
+    try {
+      return !denied && !disposed && active2() && globalThis.location.origin === origin && (!binding || binding.expiresAt > Date.now());
+    } catch {
+      return false;
+    }
+  };
+  const cancel = () => {
     controller.abort();
     clearTimeout(expiry);
+    clearTimeout(startup);
+    clearTimeout(renewalTimer);
     clearInterval(monitor);
+    globalThis.removeEventListener?.("storage", storageChanged);
+  };
+  const invalidate = () => {
+    denied = true;
+    cancel();
     try {
-      if (active2() && globalThis.location.origin === origin && (!credential || globalThis.localStorage.getItem(sessionKey) === credential)) {
+      if (!disposed && active2() && globalThis.location.origin === origin && (!credential || globalThis.localStorage.getItem(sessionKey) === credential)) {
         globalThis.localStorage.removeItem(sessionKey);
       }
     } catch {}
   };
   const current = () => {
     try {
-      return !denied && active2() && globalThis.location.origin === origin && globalThis.localStorage.getItem(sessionKey) === credential && (!binding || binding.expiresAt > Date.now());
+      return alive() && stored() === credential;
     } catch {
       return false;
     }
   };
-  const monitor = setInterval(() => {
-    if (credential && !current())
+  const sameSession = (value) => !binding || value.appId === binding.appId && value.memberId === binding.memberId && value.workspace === binding.workspace && value.sessionId === binding.sessionId;
+  const bounded = (value) => validBinding(value) && value.expiresAt > Date.now() && value.expiresAt <= Date.now() + 600000 && sameSession(value);
+  async function proof(candidate, signal = controller.signal) {
+    if (!alive() || !/^[A-Za-z0-9_-]{43}$/.test(candidate))
+      throw new Error;
+    const url = `${origin}/_os/app/context`;
+    const response = await fetch(url, {
+      credentials: "omit",
+      redirect: "error",
+      cache: "no-store",
+      referrerPolicy: "no-referrer",
+      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;
+    const value = await appResponse(response, 4096, signal);
+    if (!alive() || !bounded(value))
+      throw new Error;
+    return value;
+  }
+  function install(value, candidate) {
+    binding = { ...value };
+    credential = candidate;
+    clearTimeout(expiry);
+    clearTimeout(renewalTimer);
+    const remaining = binding.expiresAt - Date.now();
+    expiry = setTimeout(invalidate, remaining);
+    renewalTimer = setTimeout(() => {
+      renew();
+    }, remaining - Math.min(60000, remaining / 5));
+  }
+  async function synchronize() {
+    if (!alive())
+      throw new Error;
+    if (!credential)
+      return;
+    if (stored() === credential)
+      return;
+    if (!binding)
+      throw new Error;
+    if (observation)
+      return observation;
+    observation = (async () => {
+      while (alive()) {
+        const 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)
+          continue;
+        install(value, candidate);
+        return;
+      }
+      throw new Error;
+    })();
+    try {
+      await observation;
+    } catch {
+      invalidate();
+      throw new Error("Local app context unavailable.");
+    } finally {
+      observation = undefined;
+    }
+  }
+  async function renew() {
+    if (renewal || !binding || !alive())
+      return;
+    renewal = (async () => {
+      const deadline = binding.expiresAt;
+      const requestController = new AbortController;
+      const abort = () => requestController.abort();
+      controller.signal.addEventListener("abort", abort, { once: true });
+      const timeout = setTimeout(abort, Math.min(20000, deadline - Date.now()));
+      const previous = credential;
+      try {
+        await synchronize();
+        if (credential !== previous)
+          return;
+        const url = `${origin}/_os/app/renew`;
+        let response;
+        try {
+          response = await fetch(url, {
+            method: "POST",
+            credentials: "omit",
+            redirect: "error",
+            cache: "no-store",
+            referrerPolicy: "no-referrer",
+            signal: requestController.signal,
+            headers: { authorization: `Bearer ${previous}` }
+          });
+        } catch {
+          throw new AppRenewalUnavailable;
+        }
+        if (response.redirected || response.url && response.url !== url)
+          throw new Error;
+        const 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")
+          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") {
+          while (alive() && stored() === previous && !requestController.signal.aborted) {
+            await new Promise((resolve2, reject) => {
+              const abortWait = () => {
+                clearTimeout(timer);
+                reject(new Error);
+              };
+              const timer = setTimeout(() => {
+                requestController.signal.removeEventListener("abort", abortWait);
+                resolve2();
+              }, 100);
+              requestController.signal.addEventListener("abort", abortWait, { once: true });
+            });
+          }
+          if (requestController.signal.aborted)
+            throw new Error;
+          await synchronize();
+          return;
+        }
+        if (!response.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;
+        const 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();
+          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 {}
+        if ((error instanceof AppRenewalUnavailable || error instanceof AppResponseReadError || requestController.signal.aborted) && current() && Date.now() < deadline) {
+          renewalTimer = setTimeout(() => {
+            renew();
+          }, Math.min(5000, (deadline - Date.now()) / 5));
+        } else
+          invalidate();
+      } finally {
+        clearTimeout(timeout);
+        controller.signal.removeEventListener("abort", abort);
+      }
+    })();
+    try {
+      await renewal;
+    } finally {
+      renewal = undefined;
+    }
+  }
+  const storageChanged = () => {
+    if (!credential)
+      return;
+    if (!alive()) {
       invalidate();
+      return;
+    }
+    synchronize().catch(invalidate);
+  };
+  const monitor = setInterval(() => {
+    storageChanged();
   }, 100);
+  globalThis.addEventListener?.("storage", storageChanged);
   const dispose = () => {
-    controller.abort();
-    clearTimeout(expiry);
-    clearInterval(monitor);
+    disposed = true;
+    cancel();
   };
   async function requestData(operation2, input) {
     try {
       if (operation2 !== "data/query" || !current())
         throw new Error;
       const url = `${origin}/_os/app/data`;
+      const admitted = credential;
       const response = await fetch(url, {
         method: "POST",
         credentials: "omit",
@@ -23207,13 +23466,20 @@ function appContext(origin, active2) {
         headers: { "content-type": "application/json", authorization: `Bearer ${credential}` },
         body: JSON.stringify(input)
       });
+      await synchronize();
+      while (alive() && stored() !== credential)
+        await synchronize();
       if (!current() || response.redirected || response.url && response.url !== url)
         throw new Error;
       if (response.status === 401 || response.status === 403) {
-        invalidate();
+        if (admitted === credential)
+          invalidate();
         throw new DataOperationError("access_denied");
       }
       const result2 = await appResponse(response, Number.MAX_SAFE_INTEGER, controller.signal);
+      await synchronize();
+      while (alive() && stored() !== credential)
+        await synchronize();
       if (!current())
         throw new Error;
       if (!response.ok)
@@ -23233,6 +23499,7 @@ function appContext(origin, active2) {
       throw new Error("Local app context unavailable.");
     }
     const url = `${origin}/_os/app/routines/${encodeURIComponent(key)}/${suffix}`;
+    const admitted = credential;
     const response = await fetch(url, {
       ...init,
       credentials: "omit",
@@ -23242,61 +23509,107 @@ function appContext(origin, active2) {
       signal: controller.signal,
       headers: { ...init.body === undefined ? {} : { "content-type": "application/json" }, authorization: `Bearer ${credential}` }
     });
+    await synchronize();
+    while (alive() && stored() !== credential)
+      await synchronize();
     if (!current() || response.redirected || response.url && response.url !== url) {
       invalidate();
       throw new Error("Local app context unavailable.");
     }
-    if (response.status === 401 || response.status === 403)
+    if ((response.status === 401 || response.status === 403) && admitted === credential)
       invalidate();
+    responseChecks.set(response, async (value) => {
+      await synchronize();
+      while (alive() && stored() !== credential)
+        await synchronize();
+      if (admitted === credential && value && typeof value === "object" && "error" in value && value.error === "authority_unavailable")
+        invalidate();
+    });
     return response;
   }
-  const resolve = async () => {
+  function context() {
+    const issued = credential;
+    return {
+      kind: "local",
+      ...binding,
+      get expiresAt() {
+        return binding.expiresAt;
+      },
+      isCurrent: current,
+      signal: controller.signal,
+      invalidate: () => {
+        if (issued === credential)
+          invalidate();
+      },
+      requestRoutine,
+      requestData,
+      requestAvailability: (key) => requestRoutine(key, "availability", { method: "GET" })
+    };
+  }
+  const resolveOnce = async () => {
+    let attempted;
     try {
       if (denied || !active2() || globalThis.location.origin !== origin)
         throw new Error;
-      const stored = globalThis.localStorage.getItem(sessionKey);
-      if (!stored || !/^[A-Za-z0-9_-]{43}$/.test(stored) || credential && stored !== credential)
+      if (credential)
+        await synchronize();
+      const candidate = stored();
+      if (!candidate || !/^[A-Za-z0-9_-]{43}$/.test(candidate))
         throw new Error;
-      credential = stored;
+      credential = candidate;
+      attempted = candidate;
       if (!current())
         throw new Error;
-      const response = await fetch(`${origin}/_os/app/context`, {
-        credentials: "omit",
-        redirect: "error",
-        referrerPolicy: "no-referrer",
-        headers: { authorization: `Bearer ${credential}` },
-        signal: controller.signal
-      });
-      if (!response.ok || response.redirected || response.url && response.url !== `${origin}/_os/app/context` || !response.headers.get("content-type")?.startsWith("application/json"))
+      const value = await proof(candidate);
+      if (stored() !== candidate || credential !== candidate) {
+        if (!binding)
+          binding = { ...value };
+        await synchronize();
+        return context();
+      }
+      if (!current())
         throw new Error;
-      const value = await appResponse(response, 4096, controller.signal);
-      if (!validBinding(value) || !current() || value.expiresAt <= Date.now() || value.expiresAt > Date.now() + 600000 || binding && (value.appId !== binding.appId || value.memberId !== binding.memberId || value.workspace !== binding.workspace || value.expiresAt > binding.expiresAt))
+      if (binding && value.expiresAt > binding.expiresAt)
         throw new Error;
-      binding = { ...value };
-      clearTimeout(expiry);
-      expiry = setTimeout(invalidate, binding.expiresAt - Date.now());
-      return {
-        kind: "local",
-        ...binding,
-        isCurrent: current,
-        signal: controller.signal,
-        invalidate,
-        requestRoutine,
-        requestData,
-        requestAvailability: (key) => requestRoutine(key, "availability", { method: "GET" })
-      };
-    } catch {
+      if (!binding || value.expiresAt !== binding.expiresAt)
+        install(value, candidate);
+      return context();
+    } catch (error) {
+      try {
+        if (binding && current() && attempted && attempted !== credential)
+          return context();
+        if (binding && alive() && stored() && stored() !== credential) {
+          await synchronize();
+          return context();
+        }
+      } catch {}
+      if (error instanceof AppContextDenied && binding && alive() && renewal)
+        throw new Error("Local app context unavailable.");
       invalidate();
       throw new Error("Local app context unavailable.");
     }
   };
-  return { resolve, invalidate, dispose };
+  const resolve = () => {
+    if (resolution2)
+      return resolution2;
+    resolution2 = resolveOnce().finally(() => {
+      resolution2 = undefined;
+    });
+    return resolution2;
+  };
+  const start = () => {
+    startup = setTimeout(() => {
+      if (alive() && !resolution2 && !binding)
+        resolve().catch(() => {});
+    }, 0);
+  };
+  return { resolve, start, invalidate, dispose };
 }
 function validBinding(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "appId,expiresAt,memberId,workspace")
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "appId,expiresAt,memberId,sessionId,workspace")
     return false;
   const binding = value;
-  return typeof binding.appId === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(binding.appId) && typeof binding.workspace === "string" && /^[a-z0-9][a-z0-9-]{0,62}$/.test(binding.workspace) && typeof binding.memberId === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(binding.memberId) && typeof binding.expiresAt === "number" && Number.isFinite(binding.expiresAt);
+  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);
 }
 
 // src/os.ts
@@ -23364,6 +23677,7 @@ function init({ auth }) {
       installedDispose = undefined;
   };
   installedDispose = dispose;
+  local?.start();
 }
 var os = { init };
 // src/app-routine-browser.ts