@undefineds.co/xpod 0.4.14 → 0.4.15

package/node_modules/@undefineds.co/solid-sdk/dist/access-route.js

@@ -0,0 +1,115 @@
+import { createSolidLocalRouteFetch } from './local-route-fetch.js';
+/**
+ * Pick the best route that actually answers: candidates are ordered by priority
+ * and probed in parallel, so a same-machine client lands on loopback while a
+ * remote one skips it without waiting for it to time out.
+ */
+export async function chooseAccessRoute(routeSet, options = {}) {
+    const candidates = usableRoutes(routeSet, options.managedClient ?? true, options.allowLocalOnlyRoutes ?? false);
+    if (candidates.length === 0) {
+        return null;
+    }
+    const probe = options.probe ?? defaultProbe;
+    const timeoutMs = options.probeTimeoutMs ?? 1000;
+    const results = await Promise.all(candidates.map(async (route) => ({
+        route,
+        ok: await probeWithTimeout(route, probe, timeoutMs),
+    })));
+    return results.find((result) => result.ok)?.route ?? null;
+}
+export function usableRoutes(routeSet, managedClient, allowLocalOnlyRoutes) {
+    return routeSet.routes
+        .filter((route) => route.health !== 'unreachable')
+        .filter((route) => managedClient || !route.requiresManagedClient)
+        .filter((route) => allowLocalOnlyRoutes || route.visibility !== 'local-only')
+        .slice()
+        .sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id));
+}
+/**
+ * A fetch that keeps canonical URLs canonical while sending the request over the
+ * best route this client can use.
+ *
+ * Canonical identity is preserved end to end: the target URL is rewritten, the
+ * canonical host travels in the `x-xpod-canonical-*` headers, and the response
+ * reports its canonical URL again. When the chosen route stops answering, the
+ * routes are refreshed and the request is retried once against the new best one.
+ */
+export function createSolidAccessRouteFetch(options) {
+    const managedClient = options.managedClient ?? true;
+    let selected;
+    const selectRoute = async () => {
+        const routeSet = {
+            canonicalUrl: options.routes()[0]?.canonicalUrl ?? '',
+            routes: options.routes(),
+        };
+        const candidate = await chooseAccessRoute(routeSet, {
+            managedClient,
+            ...(options.allowLocalOnlyRoutes === undefined
+                ? {}
+                : { allowLocalOnlyRoutes: options.allowLocalOnlyRoutes }),
+            ...(options.probeTimeoutMs === undefined ? {} : { probeTimeoutMs: options.probeTimeoutMs }),
+            ...(options.probe === undefined ? {} : { probe: options.probe }),
+        });
+        selected = candidate ?? undefined;
+        return candidate;
+    };
+    const routeFor = async () => {
+        if (selected && options.routes().some((route) => route.id === selected?.id && route.targetUrl === selected?.targetUrl)) {
+            return selected;
+        }
+        return (await selectRoute()) ?? undefined;
+    };
+    const routedFetchFor = (route) => createSolidLocalRouteFetch({
+        fetch: options.fetch,
+        routes: () => [{
+                canonicalBaseUrl: route.canonicalUrl,
+                localBaseUrl: route.targetUrl,
+            }],
+    });
+    return async (input, init) => {
+        const route = await routeFor();
+        if (!route) {
+            return init === undefined
+                ? options.fetch.call(globalThis, input)
+                : options.fetch.call(globalThis, input, init);
+        }
+        try {
+            return await routedFetchFor(route)(input, init);
+        }
+        catch (error) {
+            // The route went away (laptop moved networks, tunnel restarted). Ask for
+            // the current set once and retry against whatever is best now.
+            selected = undefined;
+            await options.refreshRoutes?.();
+            const retryRoute = await selectRoute();
+            if (!retryRoute || retryRoute.id === route.id) {
+                throw error;
+            }
+            return routedFetchFor(retryRoute)(input, init);
+        }
+    };
+}
+async function probeWithTimeout(route, probe, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await Promise.resolve(probe(route, controller.signal));
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function defaultProbe(route, signal) {
+    if (!route.targetUrl.startsWith('http://') && !route.targetUrl.startsWith('https://')) {
+        // Non-HTTP routes (p2p sockets) report their own readiness.
+        return route.health === 'healthy';
+    }
+    const response = await fetch(new URL('/.well-known/solid', route.targetUrl), {
+        method: 'HEAD',
+        signal,
+    });
+    return response.ok || response.status === 401 || response.status === 403;
+}

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

@@ -43,6 +43,7 @@ __export(exports_src, {
   useSolidSessionSnapshot: () => useSolidSessionSnapshot,
   useSolidRuntime: () => useSolidRuntime,
   useLoginStore: () => useLoginStore,
+  usableRoutes: () => usableRoutes,
   storageBindingMatches: () => storageBindingMatches,
   resolveSolidLocalRouteUrl: () => resolveSolidLocalRouteUrl,
   resolveSolidLocalRouteFromStatus: () => resolveSolidLocalRouteFromStatus,
@@ -57,8 +58,10 @@ __export(exports_src, {
   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,
@@ -1154,3 +1157,89 @@ function routedHeaders(input, init, canonicalUrl, localUrl) {
   headers.set(SOLID_LOCAL_ROUTE_LOCAL_URL_HEADER, localUrl.toString());
   return headers;
 }
+// src/access-route.ts
+async function chooseAccessRoute(routeSet, options = {}) {
+  const candidates = usableRoutes(routeSet, options.managedClient ?? true, options.allowLocalOnlyRoutes ?? false);
+  if (candidates.length === 0) {
+    return null;
+  }
+  const probe = options.probe ?? defaultProbe;
+  const timeoutMs = options.probeTimeoutMs ?? 1000;
+  const results = await Promise.all(candidates.map(async (route) => ({
+    route,
+    ok: await probeWithTimeout(route, probe, timeoutMs)
+  })));
+  return results.find((result) => result.ok)?.route ?? null;
+}
+function usableRoutes(routeSet, managedClient, allowLocalOnlyRoutes) {
+  return routeSet.routes.filter((route) => route.health !== "unreachable").filter((route) => managedClient || !route.requiresManagedClient).filter((route) => allowLocalOnlyRoutes || route.visibility !== "local-only").slice().sort((left, right) => left.priority - right.priority || left.id.localeCompare(right.id));
+}
+function createSolidAccessRouteFetch(options) {
+  const managedClient = options.managedClient ?? true;
+  let selected;
+  const selectRoute = async () => {
+    const routeSet = {
+      canonicalUrl: options.routes()[0]?.canonicalUrl ?? "",
+      routes: options.routes()
+    };
+    const candidate = await chooseAccessRoute(routeSet, {
+      managedClient,
+      ...options.allowLocalOnlyRoutes === undefined ? {} : { allowLocalOnlyRoutes: options.allowLocalOnlyRoutes },
+      ...options.probeTimeoutMs === undefined ? {} : { probeTimeoutMs: options.probeTimeoutMs },
+      ...options.probe === undefined ? {} : { probe: options.probe }
+    });
+    selected = candidate ?? undefined;
+    return candidate;
+  };
+  const routeFor = async () => {
+    if (selected && options.routes().some((route) => route.id === selected?.id && route.targetUrl === selected?.targetUrl)) {
+      return selected;
+    }
+    return await selectRoute() ?? undefined;
+  };
+  const routedFetchFor = (route) => createSolidLocalRouteFetch({
+    fetch: options.fetch,
+    routes: () => [{
+      canonicalBaseUrl: route.canonicalUrl,
+      localBaseUrl: route.targetUrl
+    }]
+  });
+  return async (input, init) => {
+    const route = await routeFor();
+    if (!route) {
+      return init === undefined ? options.fetch.call(globalThis, input) : options.fetch.call(globalThis, input, init);
+    }
+    try {
+      return await routedFetchFor(route)(input, init);
+    } catch (error) {
+      selected = undefined;
+      await options.refreshRoutes?.();
+      const retryRoute = await selectRoute();
+      if (!retryRoute || retryRoute.id === route.id) {
+        throw error;
+      }
+      return routedFetchFor(retryRoute)(input, init);
+    }
+  };
+}
+async function probeWithTimeout(route, probe, timeoutMs) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await Promise.resolve(probe(route, controller.signal));
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function defaultProbe(route, signal) {
+  if (!route.targetUrl.startsWith("http://") && !route.targetUrl.startsWith("https://")) {
+    return route.health === "healthy";
+  }
+  const response = await fetch(new URL("/.well-known/solid", route.targetUrl), {
+    method: "HEAD",
+    signal
+  });
+  return response.ok || response.status === 401 || response.status === 403;
+}

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

@@ -6,3 +6,4 @@ export * from './storage-selection';
 /** 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';

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

@@ -6,3 +6,4 @@ export * from './storage-selection.js';
 /** LinX four-phase store (`linx-login`). Xpod uses `xpod.remembered-login.v1` instead. */
 export * from './login-store.js';
 export * from './local-route-fetch.js';
+export * from './access-route.js';

package/node_modules/@undefineds.co/solid-sdk/package.json

@@ -42,10 +42,15 @@
       "types": "./dist/local-route-fetch.d.ts",
       "import": "./dist/local-route-fetch.js",
       "require": "./dist/local-route-fetch.cjs"
+    },
+    "./access-route": {
+      "types": "./dist/access-route.d.ts",
+      "import": "./dist/access-route.js",
+      "require": "./dist/access-route.cjs"
     }
   },
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.json && bun ../../scripts/fix-dist-js-imports.mjs dist && bun build src/index.ts --target=node --format=cjs --packages=external --outfile=dist/index.cjs && bun build src/local-route-fetch.ts --target=node --format=cjs --packages=external --outfile=dist/local-route-fetch.cjs",
+    "build": "rm -rf dist && tsc -p tsconfig.json && bun ../../scripts/fix-dist-js-imports.mjs dist && bun build src/index.ts --target=node --format=cjs --packages=external --outfile=dist/index.cjs && bun build src/local-route-fetch.ts --target=node --format=cjs --packages=external --outfile=dist/local-route-fetch.cjs && bun build src/access-route.ts --target=node --format=cjs --packages=external --outfile=dist/access-route.cjs",
     "test": "vitest run test --config ../../vitest.packages.config.mts"
   },
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@undefineds.co/xpod",
-  "version": "0.4.14",
+  "version": "0.4.15",
   "description": "Xpod is an extended Community Solid Server, offering rich-feature, production-level Solid Pod and identity management.",
   "repository": "https://github.com/undefinedsco/xpod",
   "author": "developer@undefineds.co",
@@ -384,7 +384,7 @@
     }
   },
   "optionalDependencies": {
-    "@undefineds.co/xpod-darwin-arm64": "0.4.14"
+    "@undefineds.co/xpod-darwin-arm64": "0.4.15"
   },
   "resolutions": {
     "@inrupt/solid-client-authn-browser": "^3.1.1",