@oddington/sdk 0.1.8 → 0.1.9

package/README.md

@@ -54,9 +54,10 @@ an OS-launched IPv4 loopback origin. It checks `/_os/app/context` on that exact
 origin for every protected operation, without reading hosted access credentials.
 It accepts no workspace, endpoint or token option. Missing, forged, expired or
 changed local context fails closed, as do sign-out and initialization replacement.
-Local Data and Files currently return `context_unavailable` and
-`unsupported_context` respectively after checking context; they do not return
-empty data, upload locally or fall back to hosted services. Local app routine
+Local Data selects from the Host's exact published index; a warm selection
+neither initiates nor waits for renewal or synchronous hosted authority checks.
+Local Files returns `unsupported_context` after checking context. Neither path
+falls back to hosted services. Local app routine
 execution uses the installed routine's immediate-publication authority.
 
 Apps can assess a declared routine without starting it:
@@ -104,14 +105,26 @@ Only event reads reconnect, with bounded backoff and duplicate suppression;
 launch and cancellation requests are never automatically retried. Failed
 cancellation requests do not acknowledge cancellation. Handles expose no IDs,
 cursors, raw output or process controls. Local sign-out, expiry, context
-replacement and origin/credential changes invalidate pending work.
+replacement, origin changes and unconfirmed credential changes invalidate pending work.
 
 The exact-origin browser credential survives reload and tab closure in local
-storage. Host expiry and current membership remain authoritative; stored state
-cannot revive a stopped host. Recovery covers only the operation's current
-session and bounded terminal grace, without relaunching or durable history.
+storage. Each active initialization proactively renews before expiry, normally
+sixty seconds early with a shorter lead for shorter lifetimes. Only the exact
+Local Host silently refreshes the secure CLI login and confirms unchanged
+complete access. Successful renewal rotates only the bounded browser credential;
+it exposes no CLI credential or login prompt. Other tabs and SDK instances
+retain only their unchanged deadline during a temporary renewal outage and
+retry proactively without starting or delaying Data reads. They
+confirm the stored winner against the same Host and logical session before
+silently adopting it. Rotation preserves admitted Data/results and owned runs;
+old credentials cannot admit new requests and failed writes, launches and
+cancellations are never replayed. Sign-out, replacement and expiry cancel
+renewal, including pending response bodies. Host expiry and current membership
+remain authoritative; stored state cannot revive a stopped host. Recovery
+covers only the operation's current logical session and bounded terminal grace,
+without relaunching or durable history.
 Supplied File inputs currently reject `execution_unavailable` before launch;
-File-use transfer and local Data/Files adapters are separate work.
+File-use transfer and a local browser Files adapter are separate work.
 
 The fixed child imports `appRun` from the same package and shares the app's
 customer-owned input/result/step types:

package/dist/browser.js

@@ -1500,7 +1500,9 @@ var files = {
   read
 };
 
-var sessionKey = "_os.app.session", AppResponseReadError = class extends Error {
+var sessionKey = "_os.app.session", responseChecks = /* @__PURE__ */ new WeakMap(), AppResponseReadError = class extends Error {
+}, 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();
@@ -1519,7 +1521,11 @@ async function appResponse(response, maximum, signal) {
         throw new AppResponseReadError();
       }
       if (signal.aborted) throw new Error();
-      if (chunk.done) return JSON.parse(text3 + decoder.decode());
+      if (chunk.done) {
+        let value = JSON.parse(text3 + decoder.decode());
+        if (await responseChecks.get(response)?.(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 });
@@ -1537,27 +1543,180 @@ function isAppOrigin(value) {
   }
 }
 function appContext(origin, active2) {
-  let binding, credential, denied = !1, controller = new AbortController(), expiry, invalidate = () => {
-    denied = !0, controller.abort(), clearTimeout(expiry), clearInterval(monitor);
+  let binding, credential, denied = !1, controller = 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());
+    } catch {
+      return !1;
+    }
+  }, cancel = () => {
+    controller.abort(), clearTimeout(expiry), clearTimeout(startup), clearTimeout(renewalTimer), clearInterval(monitor), globalThis.removeEventListener?.("storage", storageChanged);
+  }, invalidate = () => {
+    denied = !0, cancel();
     try {
-      active2() && globalThis.location.origin === origin && (!credential || globalThis.localStorage.getItem(sessionKey) === credential) && globalThis.localStorage.removeItem(sessionKey);
+      !disposed && active2() && globalThis.location.origin === origin && (!credential || globalThis.localStorage.getItem(sessionKey) === credential) && globalThis.localStorage.removeItem(sessionKey);
     } catch {
     }
   }, current2 = () => {
     try {
-      return !denied && active2() && globalThis.location.origin === origin && globalThis.localStorage.getItem(sessionKey) === credential && (!binding || binding.expiresAt > Date.now());
+      return alive() && stored() === credential;
     } 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`, 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();
+    let 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);
+    let remaining = binding.expiresAt - Date.now();
+    expiry = setTimeout(invalidate, remaining), renewalTimer = setTimeout(() => {
+      renew();
+    }, remaining - Math.min(6e4, remaining / 5));
+  }
+  async function synchronize() {
+    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;
+          }
+        }
+        throw new Error();
+      })();
+      try {
+        await observation;
+      } catch {
+        throw invalidate(), new Error("Local app context unavailable.");
+      } finally {
+        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`, 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();
+          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")
+            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") {
+            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 (!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();
+          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();
+            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);
+        }
+      })();
+      try {
+        await renewal;
+      } finally {
+        renewal = void 0;
+      }
+    }
+  }
+  let storageChanged = () => {
+    if (credential) {
+      if (!alive()) {
+        invalidate();
+        return;
+      }
+      synchronize().catch(invalidate);
+    }
   }, monitor = setInterval(() => {
-    credential && !current2() && invalidate();
-  }, 100), dispose = () => {
-    controller.abort(), clearTimeout(expiry), clearInterval(monitor);
+    storageChanged();
+  }, 100);
+  globalThis.addEventListener?.("storage", storageChanged);
+  let dispose = () => {
+    disposed = !0, cancel();
   };
   async function requestData(operation2, input) {
     try {
       if (operation2 !== "data/query" || !current2()) throw new Error();
-      let url = `${origin}/_os/app/data`, response = await fetch(url, {
+      let url = `${origin}/_os/app/data`, admitted = credential, response = await fetch(url, {
         method: "POST",
         credentials: "omit",
         redirect: "error",
@@ -1567,10 +1726,12 @@ function appContext(origin, active2) {
         headers: { "content-type": "application/json", authorization: `Bearer ${credential}` },
         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)
-        throw invalidate(), new DataOperationError("access_denied");
+        throw admitted === credential && invalidate(), new DataOperationError("access_denied");
       let result2 = await appResponse(response, 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);
       return result2;
@@ -1581,7 +1742,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}`, response = await fetch(url, {
+    let url = `${origin}/_os/app/routines/${encodeURIComponent(key)}/${suffix}`, admitted = credential, response = await fetch(url, {
       ...init2,
       credentials: "omit",
       redirect: "error",
@@ -1590,45 +1751,69 @@ function appContext(origin, active2) {
       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() || response.redirected || response.url && response.url !== url)
       throw invalidate(), new Error("Local app context unavailable.");
-    return (response.status === 401 || response.status === 403) && invalidate(), response;
+    return (response.status === 401 || response.status === 403) && admitted === credential && invalidate(), responseChecks.set(response, 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;
+  }
+  function context2() {
+    let issued = credential;
+    return {
+      kind: "local",
+      ...binding,
+      get expiresAt() {
+        return binding.expiresAt;
+      },
+      isCurrent: current2,
+      signal: controller.signal,
+      invalidate: () => {
+        issued === credential && invalidate();
+      },
+      requestRoutine,
+      requestData,
+      requestAvailability: (key) => requestRoutine(key, "availability", { method: "GET" })
+    };
   }
-  return { resolve: async () => {
+  let resolveOnce = async () => {
+    let attempted;
     try {
       if (denied || !active2() || globalThis.location.origin !== origin) throw new Error();
-      let stored = globalThis.localStorage.getItem(sessionKey);
-      if (!stored || !/^[A-Za-z0-9_-]{43}$/.test(stored) || credential && stored !== credential) throw new Error();
-      if (credential = stored, !current2()) throw new Error();
-      let 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")) throw new Error();
-      let value = await appResponse(response, 4096, controller.signal);
-      if (!validBinding(value) || !current2() || value.expiresAt <= Date.now() || value.expiresAt > Date.now() + 6e5 || binding && (value.appId !== binding.appId || value.memberId !== binding.memberId || value.workspace !== binding.workspace || value.expiresAt > binding.expiresAt)) throw new Error();
-      return binding = { ...value }, clearTimeout(expiry), expiry = setTimeout(invalidate, binding.expiresAt - Date.now()), {
-        kind: "local",
-        ...binding,
-        isCurrent: current2,
-        signal: controller.signal,
-        invalidate,
-        requestRoutine,
-        requestData,
-        requestAvailability: (key) => requestRoutine(key, "availability", { method: "GET" })
-      };
-    } catch {
-      throw invalidate(), new Error("Local app context unavailable.");
+      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 (!current2()) throw new Error();
+      if (binding && value.expiresAt > binding.expiresAt) throw new Error();
+      return (!binding || value.expiresAt !== binding.expiresAt) && install(value, candidate), context2();
+    } catch (error) {
+      try {
+        if (binding && current2() && attempted && attempted !== credential) return context2();
+        if (binding && alive() && stored() && stored() !== credential)
+          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."));
     }
+  }, resolve = () => resolution2 || (resolution2 = resolveOnce().finally(() => {
+    resolution2 = void 0;
+  }), resolution2);
+  return { resolve, start: () => {
+    startup = setTimeout(() => {
+      alive() && !resolution2 && !binding && resolve().catch(() => {
+      });
+    }, 0);
   }, invalidate, dispose };
 }
 function validBinding(value) {
-  if (!value || typeof value != "object" || Array.isArray(value) || Object.keys(value).sort().join(",") !== "appId,expiresAt,memberId,workspace") return !1;
+  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.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);
 }
 
 var installedDispose;
@@ -1664,7 +1849,7 @@ function init({ auth }) {
   }), dispose = () => {
     active2 && (active2 = !1, local?.dispose(), revision++, subscription.unsubscribe(), uninstall(), installedDispose === dispose && (installedDispose = void 0));
   };
-  installedDispose = dispose;
+  installedDispose = dispose, local?.start();
 }
 var os = { init };
 

package/dist/index.js

@@ -22030,7 +22030,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,
@@ -23114,9 +23114,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 +23144,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 +23177,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 +23420,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 +23453,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 +23463,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 +23631,7 @@ function init({ auth }) {
       installedDispose = undefined;
   };
   installedDispose = dispose;
+  local?.start();
 }
 var os = { init };
 // src/app-routine-browser.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oddington/sdk",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Oddington routine and response-handler SDK",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",