@undefineds.co/xpod 0.4.20 → 0.4.27

package/node_modules/@undefineds.co/solid-sdk/dist/index.cjs

@@ -39,36 +39,37 @@ var __export = (target, all) => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
-  validateWebId: () => validateWebId,
-  useSolidSessionSnapshot: () => useSolidSessionSnapshot,
-  useSolidRuntime: () => useSolidRuntime,
-  useLoginStore: () => useLoginStore,
-  usableRoutes: () => usableRoutes,
-  storageBindingMatches: () => storageBindingMatches,
-  resolveSolidLocalRouteUrl: () => resolveSolidLocalRouteUrl,
-  resolveSolidLocalRouteFromStatus: () => resolveSolidLocalRouteFromStatus,
-  reconcileStorageSelection: () => reconcileStorageSelection,
-  normalizeWebIdLoginTransaction: () => normalizeWebIdLoginTransaction,
-  normalizeWebIdLoginRoute: () => normalizeWebIdLoginRoute,
-  normalizeStorageBinding: () => normalizeStorageBinding,
-  normalizeApplicationReturnTo: () => normalizeApplicationReturnTo,
-  getRememberedAccount: () => getRememberedAccount,
-  getAllProviders: () => getAllProviders,
-  discoverSolidLocalRoute: () => discoverSolidLocalRoute,
-  createStorageSelectionState: () => createStorageSelectionState,
-  createSolidSessionRuntime: () => createSolidSessionRuntime,
-  createSolidLocalRouteFetch: () => createSolidLocalRouteFetch,
-  createSolidAccessRouteFetch: () => createSolidAccessRouteFetch,
-  createPodRuntime: () => createPodRuntime,
-  createLoginStore: () => createLoginStore,
-  chooseAccessRoute: () => chooseAccessRoute,
-  SolidRuntimeProvider: () => SolidRuntimeProvider,
-  SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER: () => SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER,
-  SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER,
-  SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER,
-  SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER,
+  DEFAULT_PROVIDERS: () => DEFAULT_PROVIDERS,
   NoUsableAccessRouteError: () => NoUsableAccessRouteError,
-  DEFAULT_PROVIDERS: () => DEFAULT_PROVIDERS
+  SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER,
+  SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER,
+  SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER,
+  SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER: () => SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER,
+  SolidRuntimeProvider: () => SolidRuntimeProvider,
+  chooseAccessRoute: () => chooseAccessRoute,
+  createLoginStore: () => createLoginStore,
+  createPodRuntime: () => createPodRuntime,
+  createSolidAccessRouteFetch: () => createSolidAccessRouteFetch,
+  createSolidLocalRouteFetch: () => createSolidLocalRouteFetch,
+  createSolidSessionRuntime: () => createSolidSessionRuntime,
+  createStorageSelectionState: () => createStorageSelectionState,
+  discoverSolidLocalRoute: () => discoverSolidLocalRoute,
+  getAllProviders: () => getAllProviders,
+  getRememberedAccount: () => getRememberedAccount,
+  normalizeApplicationReturnTo: () => normalizeApplicationReturnTo,
+  normalizeStorageBinding: () => normalizeStorageBinding,
+  normalizeWebIdLoginRoute: () => normalizeWebIdLoginRoute,
+  normalizeWebIdLoginTransaction: () => normalizeWebIdLoginTransaction,
+  probeSolidLocalRouteStatus: () => probeSolidLocalRouteStatus,
+  reconcileStorageSelection: () => reconcileStorageSelection,
+  resolveSolidLocalRouteFromStatus: () => resolveSolidLocalRouteFromStatus,
+  resolveSolidLocalRouteUrl: () => resolveSolidLocalRouteUrl,
+  storageBindingMatches: () => storageBindingMatches,
+  usableRoutes: () => usableRoutes,
+  useLoginStore: () => useLoginStore,
+  useSolidRuntime: () => useSolidRuntime,
+  useSolidSessionSnapshot: () => useSolidSessionSnapshot,
+  validateWebId: () => validateWebId
 });
 module.exports = __toCommonJS(exports_src);
 
@@ -117,6 +118,8 @@ function createSolidSessionRuntime(options = {}) {
   let snapshot = { status: "initializing" };
   let lastNotifiedSnapshot;
   let initialization;
+  let initializationDeadline;
+  let settleInitializationWait;
   let initialized = false;
   let isInitializing = false;
   let initializationErrorSnapshot;
@@ -169,6 +172,8 @@ function createSolidSessionRuntime(options = {}) {
     return publish(snapshotFromSessionExpired(session.info));
   };
   const publishSessionError = (code, description) => {
+    if (pendingIdentity && pendingIdentity.generation !== identityOperationGeneration)
+      return;
     identityOperationGeneration += 1;
     const errorSnapshot = snapshotFromSessionError(description ?? code ?? "Solid session error", session.info);
     if (isInitializing) {
@@ -182,6 +187,43 @@ function createSolidSessionRuntime(options = {}) {
   session.events.on(import_solid_client_authn_browser.EVENTS.SESSION_EXPIRED, publishSessionExpired);
   const errorEvents = session.events;
   errorEvents.on(import_solid_client_authn_browser.EVENTS.ERROR, publishSessionError);
+  const boundIdentityCompletion = (completion, operation) => {
+    const bounded = new Promise((resolve, reject) => {
+      settleInitializationWait = () => resolve(snapshot);
+      initializationDeadline = setTimeout(() => {
+        initializationDeadline = undefined;
+        if (!disposed && operation.generation === identityOperationGeneration) {
+          identityOperationGeneration += 1;
+          if (snapshot.status === "initializing") {
+            const error = new Error("Previous login is still completing. Reload before reconnecting.");
+            error.name = "SolidSessionPendingError";
+            publish(snapshotFromSessionError(error, session.info));
+          }
+        }
+        resolve(snapshot);
+      }, 15000);
+      const cleanup = () => {
+        if (initialization !== bounded)
+          return;
+        clearTimeout(initializationDeadline);
+        initializationDeadline = undefined;
+        settleInitializationWait = undefined;
+        if (pendingIdentity === operation)
+          pendingIdentity = undefined;
+        initialization = undefined;
+        isInitializing = false;
+        initializationErrorSnapshot = undefined;
+      };
+      completion.then((value) => {
+        cleanup();
+        resolve(value);
+      }, (error) => {
+        cleanup();
+        reject(error);
+      });
+    });
+    return bounded;
+  };
   return {
     fetch: session.fetch,
     createAuthenticatedFetch(webId) {
@@ -210,7 +252,7 @@ function createSolidSessionRuntime(options = {}) {
     getSnapshot() {
       return snapshot;
     },
-    initialize(options2 = {}) {
+    initialize(options = {}) {
       if (initialization) {
         return initialization;
       }
@@ -225,8 +267,8 @@ function createSolidSessionRuntime(options = {}) {
       isInitializing = true;
       initializationErrorSnapshot = undefined;
       publish({ status: "initializing" });
-      const nextInitialization = session.handleIncomingRedirect({
-        restorePreviousSession: options2.restorePreviousSession ?? true
+      const completion = session.handleIncomingRedirect({
+        restorePreviousSession: options.restorePreviousSession ?? true
       }).then((info) => {
         if (!isCurrentOperation(info ?? session.info))
           return snapshot;
@@ -236,16 +278,8 @@ function createSolidSessionRuntime(options = {}) {
         }
         initialized = true;
         return publish(nextSnapshot);
-      }).catch((error) => isCurrentOperation() ? publish(snapshotFromSessionError(error, session.info)) : snapshot).finally(() => {
-        if (initialization === nextInitialization) {
-          if (pendingIdentity === operation)
-            pendingIdentity = undefined;
-          initialization = undefined;
-          isInitializing = false;
-          initializationErrorSnapshot = undefined;
-        }
-      });
-      initialization = nextInitialization;
+      }).catch((error) => isCurrentOperation() ? publish(snapshotFromSessionError(error, session.info)) : snapshot);
+      initialization = boundIdentityCompletion(completion, operation);
       return initialization;
     },
     handleIncomingRedirect(url) {
@@ -260,7 +294,7 @@ function createSolidSessionRuntime(options = {}) {
       isInitializing = true;
       initializationErrorSnapshot = undefined;
       publish({ status: "initializing" });
-      const nextInitialization = session.handleIncomingRedirect(url).then((info) => {
+      const completion = session.handleIncomingRedirect(url).then((info) => {
         if (!isCurrentOperation(info ?? session.info))
           return snapshot;
         const nextSnapshot = snapshotFromSessionInfo(info ?? session.info);
@@ -269,19 +303,11 @@ function createSolidSessionRuntime(options = {}) {
         }
         initialized = true;
         return publish(nextSnapshot);
-      }).catch((error) => isCurrentOperation() ? publish(snapshotFromSessionError(error, session.info)) : snapshot).finally(() => {
-        if (initialization === nextInitialization) {
-          if (pendingIdentity === operation)
-            pendingIdentity = undefined;
-          initialization = undefined;
-          isInitializing = false;
-          initializationErrorSnapshot = undefined;
-        }
-      });
-      initialization = nextInitialization;
-      return nextInitialization;
+      }).catch((error) => isCurrentOperation() ? publish(snapshotFromSessionError(error, session.info)) : snapshot);
+      initialization = boundIdentityCompletion(completion, operation);
+      return initialization;
     },
-    async login(options2) {
+    async login(options) {
       identityOperationGeneration += 1;
       invalidateAuthentication();
       authenticationOperations += 1;
@@ -293,7 +319,7 @@ function createSolidSessionRuntime(options = {}) {
         }
         if (disposed)
           throw new Error("Solid session runtime is disposed");
-        await session.login(options2);
+        await session.login(options);
       } catch (error) {
         publish(snapshotFromSessionError(error, session.info));
         throw error;
@@ -301,12 +327,12 @@ function createSolidSessionRuntime(options = {}) {
         authenticationOperations -= 1;
       }
     },
-    async logout(options2) {
+    async logout(options) {
       identityOperationGeneration += 1;
       invalidateAuthentication();
       authenticationOperations += 1;
       try {
-        await session.logout(options2);
+        await session.logout(options);
         publish({ status: "anonymous" });
       } catch (error) {
         publish(snapshotFromSessionError(error, session.info));
@@ -322,9 +348,12 @@ function createSolidSessionRuntime(options = {}) {
       };
     },
     dispose() {
+      clearTimeout(initializationDeadline);
       identityOperationGeneration += 1;
       invalidateAuthentication();
       disposed = true;
+      settleInitializationWait?.();
+      settleInitializationWait = undefined;
       listeners.clear();
       session.events.off(import_solid_client_authn_browser.EVENTS.LOGIN, publishSessionInfo);
       session.events.off(import_solid_client_authn_browser.EVENTS.SESSION_RESTORED, publishSessionInfo);
@@ -554,8 +583,8 @@ function createPodRuntime(options) {
       pendingByComposite.get(key)?.controller.abort();
       pendingByComposite.delete(key);
       readyByComposite.delete(key);
-      const discovered2 = readyByWebId.get(webIdKey);
-      if (discovered2 && compositeKey(discovered2.webId, discovered2.podUrl) === key) {
+      const discovered = readyByWebId.get(webIdKey);
+      if (discovered && compositeKey(discovered.webId, discovered.podUrl) === key) {
         readyByWebId.delete(webIdKey);
       }
       return;
@@ -614,40 +643,40 @@ function createPodRuntime(options) {
       const explicitPodUrl = args.podUrl === undefined ? undefined : normalizePodUrl(args.podUrl);
       if (explicitPodUrl !== undefined) {
         const key = compositeKey(args.webId, explicitPodUrl);
-        const cached2 = readyByComposite.get(key);
-        if (cached2) {
-          return Promise.resolve(cached2);
+        const cached = readyByComposite.get(key);
+        if (cached) {
+          return Promise.resolve(cached);
         }
-        const pending2 = pendingByComposite.get(key);
-        if (pending2) {
-          return pending2.promise;
+        const pending = pendingByComposite.get(key);
+        if (pending) {
+          return pending.promise;
         }
-        const generation2 = compositeGenerations.get(key) ?? 0;
-        compositeGenerations.set(key, generation2);
-        const controller2 = new AbortController;
-        const isCurrent2 = () => !controller2.signal.aborted && (compositeGenerations.get(key) ?? 0) === generation2;
-        const assertCurrent2 = () => {
-          if (!isCurrent2()) {
+        const generation = compositeGenerations.get(key) ?? 0;
+        compositeGenerations.set(key, generation);
+        const controller = new AbortController;
+        const isCurrent = () => !controller.signal.aborted && (compositeGenerations.get(key) ?? 0) === generation;
+        const assertCurrent = () => {
+          if (!isCurrent()) {
             throw createAbortedOpenError();
           }
         };
-        const promise2 = openDatabase({
+        const promise = openDatabase({
           webId: args.webId,
           podUrl: explicitPodUrl,
           fetch: args.fetch,
-          signal: controller2.signal,
-          isCurrent: isCurrent2,
-          assertCurrent: assertCurrent2
+          signal: controller.signal,
+          isCurrent,
+          assertCurrent
         });
-        pendingByComposite.set(key, { generation: generation2, promise: promise2, controller: controller2 });
-        const removePending2 = () => {
+        pendingByComposite.set(key, { generation, promise, controller });
+        const removePending = () => {
           const pendingOpen = pendingByComposite.get(key);
-          if (pendingOpen?.generation === generation2 && pendingOpen.promise === promise2) {
+          if (pendingOpen?.generation === generation && pendingOpen.promise === promise) {
             pendingByComposite.delete(key);
           }
         };
-        promise2.then(removePending2, removePending2);
-        return promise2;
+        promise.then(removePending, removePending);
+        return promise;
       }
       const cached = readyByWebId.get(webIdKey);
       if (cached) {
@@ -941,7 +970,7 @@ function resolveStorageProviderLabel(parsed) {
 function isLegacyCloudBackedLocalAccount(parsed, storageProviderLabel) {
   return storageProviderLabel?.trim().toLowerCase() === "local" && typeof parsed.webId === "string" && normalizeStoredUrl(parsed.webId)?.startsWith(`${LINX_CLOUD_IDENTITY_ORIGIN}/`) === true;
 }
-function createLoginState(persistRememberedAccount2) {
+function createLoginState(persistRememberedAccount) {
   return (set) => ({
     state: "restoring",
     error: null,
@@ -952,7 +981,7 @@ function createLoginState(persistRememberedAccount2) {
     setStoredAccount: (account) => set((current) => {
       if (current.storedAccount === account)
         return current;
-      persistRememberedAccount2(account);
+      persistRememberedAccount(account);
       return { storedAccount: account };
     }),
     addCustomProvider: (provider) => set((s) => ({
@@ -965,7 +994,7 @@ function createLoginState(persistRememberedAccount2) {
       customProviders: s.customProviders.filter((p) => p.url !== url)
     })),
     loginSuccess: (account) => set(() => {
-      persistRememberedAccount2(account);
+      persistRememberedAccount(account);
       return {
         state: "authenticated",
         error: null,
@@ -973,7 +1002,7 @@ function createLoginState(persistRememberedAccount2) {
       };
     }),
     reset: () => set((current) => {
-      persistRememberedAccount2(current.storedAccount);
+      persistRememberedAccount(current.storedAccount);
       return {
         state: "idle",
         error: null
@@ -1037,26 +1066,69 @@ var SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER = "x-xpod-canonical-url";
 var SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER = "x-xpod-canonical-origin";
 var SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER = "x-xpod-canonical-host";
 var SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER = "x-xpod-local-route-url";
-async function discoverSolidLocalRoute(options) {
-  let response;
+var SOLID_ROUTE_PROBE_TIMEOUT_MS = 1000;
+async function probeSolidLocalRouteStatus(options) {
+  if (options.signal?.aborted)
+    return;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), SOLID_ROUTE_PROBE_TIMEOUT_MS);
+  const relayAbort = () => controller.abort();
+  options.signal?.addEventListener("abort", relayAbort, { once: true });
+  if (options.signal?.aborted)
+    controller.abort();
   try {
-    response = await options.fetch.call(globalThis, options.statusUrl ?? "/provision/status", {
-      credentials: "include",
-      headers: { accept: "application/json" }
+    return await settleOnAbort(controller.signal, async () => {
+      const response = await options.fetch.call(globalThis, options.url, {
+        credentials: "include",
+        headers: { accept: "application/json" },
+        signal: controller.signal
+      });
+      return options.read(response);
     });
   } catch {
     return;
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", relayAbort);
   }
-  if (!response?.ok)
-    return;
-  const body = await response.json().catch(() => {
+}
+async function settleOnAbort(signal, operation) {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+  }
+  let remove = () => {
     return;
+  };
+  const aborted = new Promise((_resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    remove = () => signal.removeEventListener("abort", onAbort);
+  });
+  try {
+    return await Promise.race([operation(), aborted]);
+  } finally {
+    remove();
+  }
+}
+async function discoverSolidLocalRoute(options) {
+  const publicUrl = await probeSolidLocalRouteStatus({
+    fetch: options.fetch,
+    url: options.statusUrl ?? "/provision/status",
+    signal: options.signal,
+    read: async (response) => {
+      if (!response.ok)
+        return;
+      const body = await response.json().catch(() => {
+        return;
+      });
+      return typeof body?.publicUrl === "string" ? body.publicUrl : undefined;
+    }
   });
-  if (typeof body?.publicUrl !== "string")
+  if (typeof publicUrl !== "string")
     return;
   try {
     return normalizeRoute({
-      canonicalBaseUrl: body.publicUrl,
+      canonicalBaseUrl: publicUrl,
       localBaseUrl: options.localBaseUrl
     });
   } catch {
@@ -1185,10 +1257,9 @@ function usableRoutes(routeSet, managedClient, allowLocalOnlyRoutes) {
 function createSolidAccessRouteFetch(options) {
   const managedClient = options.managedClient ?? true;
   let selected;
-  let failed;
-  const selectRoute = async () => {
+  const selectRoute = async (excluded) => {
     const all = options.routes();
-    const routes = failed === undefined ? all : all.filter((route) => routeKey(route) !== failed);
+    const routes = excluded === undefined ? all : all.filter((route) => routeKey(route) !== excluded);
     const routeSet = {
       canonicalUrl: routes[0]?.canonicalUrl ?? "",
       routes
@@ -1229,6 +1300,10 @@ function createSolidAccessRouteFetch(options) {
     return url;
   };
   return async (input, init) => {
+    const sourceUrl = requestUrl2(input);
+    if (!sourceUrl || !routeCovers(sourceUrl)) {
+      return init === undefined ? options.fetch.call(globalThis, input) : options.fetch.call(globalThis, input, init);
+    }
     const route = await routeFor();
     if (!route) {
       const unreachable = unreachablePassThrough(input);
@@ -1239,13 +1314,14 @@ function createSolidAccessRouteFetch(options) {
     }
     try {
       const response = await routedFetchFor(route)(input, init);
-      failed = undefined;
       return response;
     } catch (error) {
-      failed = routeKey(route);
       selected = undefined;
+      const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+      if (!["GET", "HEAD", "OPTIONS"].includes(method))
+        throw error;
       await options.refreshRoutes?.();
-      const retryRoute = await selectRoute();
+      const retryRoute = await selectRoute(routeKey(route));
       if (retryRoute && routeKey(retryRoute) !== routeKey(route)) {
         return routedFetchFor(retryRoute)(input, init);
       }

package/node_modules/@undefineds.co/solid-sdk/dist/index.d.ts

@@ -1,9 +1,9 @@
-export * from './session';
-export * from './pod-runtime';
-export * from './react';
-export * from './webid-auth';
-export * from './storage-selection';
+export * from './session.js';
+export * from './pod-runtime.js';
+export * from './react.js';
+export * from './webid-auth.js';
+export * from './storage-selection.js';
 /** LinX four-phase store (`linx-login`). Xpod uses `xpod.remembered-login.v1` instead. */
-export * from './login-store';
-export * from './local-route-fetch';
-export * from './access-route';
+export * from './login-store.js';
+export * from './local-route-fetch.js';
+export * from './access-route.js';

package/node_modules/@undefineds.co/solid-sdk/dist/local-route-fetch.cjs

@@ -39,40 +39,84 @@ var __export = (target, all) => {
 // src/local-route-fetch.ts
 var exports_local_route_fetch = {};
 __export(exports_local_route_fetch, {
-  resolveSolidLocalRouteUrl: () => resolveSolidLocalRouteUrl,
-  resolveSolidLocalRouteFromStatus: () => resolveSolidLocalRouteFromStatus,
-  discoverSolidLocalRoute: () => discoverSolidLocalRoute,
-  createSolidLocalRouteFetch: () => createSolidLocalRouteFetch,
-  SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER: () => SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER,
-  SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER,
+  SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER,
   SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER,
-  SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER
+  SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER: () => SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER,
+  SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER: () => SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER,
+  createSolidLocalRouteFetch: () => createSolidLocalRouteFetch,
+  discoverSolidLocalRoute: () => discoverSolidLocalRoute,
+  probeSolidLocalRouteStatus: () => probeSolidLocalRouteStatus,
+  resolveSolidLocalRouteFromStatus: () => resolveSolidLocalRouteFromStatus,
+  resolveSolidLocalRouteUrl: () => resolveSolidLocalRouteUrl
 });
 module.exports = __toCommonJS(exports_local_route_fetch);
 var SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER = "x-xpod-canonical-url";
 var SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER = "x-xpod-canonical-origin";
 var SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER = "x-xpod-canonical-host";
 var SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER = "x-xpod-local-route-url";
-async function discoverSolidLocalRoute(options) {
-  let response;
+var SOLID_ROUTE_PROBE_TIMEOUT_MS = 1000;
+async function probeSolidLocalRouteStatus(options) {
+  if (options.signal?.aborted)
+    return;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), SOLID_ROUTE_PROBE_TIMEOUT_MS);
+  const relayAbort = () => controller.abort();
+  options.signal?.addEventListener("abort", relayAbort, { once: true });
+  if (options.signal?.aborted)
+    controller.abort();
   try {
-    response = await options.fetch.call(globalThis, options.statusUrl ?? "/provision/status", {
-      credentials: "include",
-      headers: { accept: "application/json" }
+    return await settleOnAbort(controller.signal, async () => {
+      const response = await options.fetch.call(globalThis, options.url, {
+        credentials: "include",
+        headers: { accept: "application/json" },
+        signal: controller.signal
+      });
+      return options.read(response);
     });
   } catch {
     return;
+  } finally {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", relayAbort);
   }
-  if (!response?.ok)
-    return;
-  const body = await response.json().catch(() => {
+}
+async function settleOnAbort(signal, operation) {
+  if (signal.aborted) {
+    return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+  }
+  let remove = () => {
     return;
+  };
+  const aborted = new Promise((_resolve, reject) => {
+    const onAbort = () => reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    remove = () => signal.removeEventListener("abort", onAbort);
+  });
+  try {
+    return await Promise.race([operation(), aborted]);
+  } finally {
+    remove();
+  }
+}
+async function discoverSolidLocalRoute(options) {
+  const publicUrl = await probeSolidLocalRouteStatus({
+    fetch: options.fetch,
+    url: options.statusUrl ?? "/provision/status",
+    signal: options.signal,
+    read: async (response) => {
+      if (!response.ok)
+        return;
+      const body = await response.json().catch(() => {
+        return;
+      });
+      return typeof body?.publicUrl === "string" ? body.publicUrl : undefined;
+    }
   });
-  if (typeof body?.publicUrl !== "string")
+  if (typeof publicUrl !== "string")
     return;
   try {
     return normalizeRoute({
-      canonicalBaseUrl: body.publicUrl,
+      canonicalBaseUrl: publicUrl,
       localBaseUrl: options.localBaseUrl
     });
   } catch {

package/node_modules/@undefineds.co/solid-sdk/dist/local-route-fetch.d.ts

@@ -16,7 +16,30 @@ export interface DiscoverSolidLocalRouteOptions {
     fetch: typeof globalThis.fetch;
     localBaseUrl: string;
     statusUrl?: string;
+    /** The owner of the probe; aborting it settles the whole exchange. */
+    signal?: AbortSignal;
 }
+export interface SolidRouteProbeOptions<T> {
+    fetch: typeof globalThis.fetch;
+    url: string;
+    /** The owner of the probe; aborting it settles the whole exchange. */
+    signal?: AbortSignal;
+    /**
+     * Reads and normalizes the response under the same deadline as the request,
+     * so a body that stalls after its headers cannot hold the caller open.
+     */
+    read: (response: Response) => Promise<T>;
+}
+/**
+ * Probe one optional runtime endpoint with a bounded, cancellable exchange.
+ *
+ * The budget covers the whole operation, including the caller's body decode.
+ * The probe settles at the deadline or when its owner aborts, even if the fetch
+ * adapter ignores the signal, and always clears its timer and listeners. Any
+ * failure reports `undefined`, so a missing optional endpoint can never
+ * fabricate a route.
+ */
+export declare function probeSolidLocalRouteStatus<T>(options: SolidRouteProbeOptions<T>): Promise<T | undefined>;
 /** Discover the canonical origin currently hosted by this local Xpod. */
 export declare function discoverSolidLocalRoute(options: DiscoverSolidLocalRouteOptions): Promise<SolidLocalRoute | undefined>;
 export declare function resolveSolidLocalRouteFromStatus(input: string | URL, options: DiscoverSolidLocalRouteOptions): Promise<URL | undefined>;