@undefineds.co/xpod 0.4.14 → 0.4.16

package/node_modules/@undefineds.co/extensions/dist-cjs/reader.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaderError = void 0;
+exports.readResultText = readResultText;
+exports.mergeDocumentMetadata = mergeDocumentMetadata;
+class ReaderError extends Error {
+    name = 'ReaderError';
+    code;
+    status;
+    retryable;
+    constructor(message, options) {
+        super(message, { cause: options.cause });
+        this.code = options.code;
+        this.status = options.status;
+        this.retryable = options.retryable ?? false;
+    }
+}
+exports.ReaderError = ReaderError;
+function readResultText(result) {
+    if (typeof result.text === 'string') {
+        return result.text;
+    }
+    if (typeof result.markdown === 'string') {
+        return result.markdown;
+    }
+    return result.documents.map((document) => document.text).filter(Boolean).join('\n\n');
+}
+function mergeDocumentMetadata(result, document) {
+    const metadata = {
+        id: document.id,
+        reader: result.reader,
+        model: result.model,
+        sourceUri: document.sourceUri,
+        pageRange: document.pageRange,
+        mimeType: document.mimeType,
+        ...document.metadata,
+    };
+    for (const [key, value] of Object.entries(metadata)) {
+        if (value === undefined) {
+            delete metadata[key];
+        }
+    }
+    return metadata;
+}

package/node_modules/@undefineds.co/extensions/dist-cjs/registry.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExtensionRegistry = createExtensionRegistry;
+function createExtensionRegistry() {
+    return new InMemoryExtensionRegistry();
+}
+class InMemoryExtensionRegistry {
+    readers = new Map();
+    sourceAccessors = new Map();
+    runtimeCapabilities = new Map();
+    tools = new Map();
+    configSchemas = new Map();
+    install(extension, descriptor) {
+        const api = this.createApi(descriptor);
+        const result = extension(api);
+        if (isPromiseLike(result)) {
+            return result.then(() => undefined);
+        }
+    }
+    getReader(id) {
+        return this.readers.get(id);
+    }
+    listReaders() {
+        return [...this.readers.values()];
+    }
+    getSourceAccessor(id) {
+        return this.sourceAccessors.get(id);
+    }
+    listSourceAccessors() {
+        return [...this.sourceAccessors.values()];
+    }
+    getRuntimeCapability(id) {
+        return this.runtimeCapabilities.get(id);
+    }
+    listRuntimeCapabilities() {
+        return [...this.runtimeCapabilities.values()];
+    }
+    getTool(id) {
+        return this.tools.get(id);
+    }
+    listTools() {
+        return [...this.tools.values()];
+    }
+    getConfigSchema(id) {
+        return this.configSchemas.get(id);
+    }
+    listConfigSchemas() {
+        return [...this.configSchemas.values()];
+    }
+    createApi(descriptor) {
+        const registration = {
+            extensionId: descriptor.id,
+            extensionVersion: descriptor.version,
+        };
+        return {
+            reader: {
+                register: (definition) => {
+                    assertUnique(this.readers, 'reader', definition.id);
+                    this.readers.set(definition.id, { ...definition, ...registration });
+                },
+            },
+            source: {
+                register: (definition) => {
+                    assertUnique(this.sourceAccessors, 'source accessor', definition.id);
+                    this.sourceAccessors.set(definition.id, { ...definition, ...registration });
+                },
+            },
+            runtime: {
+                registerCapability: (definition) => {
+                    assertUnique(this.runtimeCapabilities, 'runtime capability', definition.id);
+                    this.runtimeCapabilities.set(definition.id, { ...definition, ...registration });
+                },
+            },
+            tools: {
+                register: (definition) => {
+                    assertUnique(this.tools, 'tool', definition.id);
+                    this.tools.set(definition.id, { ...definition, ...registration });
+                },
+            },
+            config: {
+                registerSchema: (definition) => {
+                    assertUnique(this.configSchemas, 'config schema', definition.id);
+                    this.configSchemas.set(definition.id, { ...definition, ...registration });
+                },
+            },
+        };
+    }
+}
+function assertUnique(map, label, id) {
+    if (map.has(id)) {
+        throw new Error(`Duplicate ${label} id ${id}`);
+    }
+}
+function isPromiseLike(value) {
+    return typeof value === 'object'
+        && value !== null
+        && 'then' in value
+        && typeof value.then === 'function';
+}

package/node_modules/@undefineds.co/extensions/dist-cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,230 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/access-route.ts
+var exports_access_route = {};
+__export(exports_access_route, {
+  usableRoutes: () => usableRoutes,
+  createSolidAccessRouteFetch: () => createSolidAccessRouteFetch,
+  chooseAccessRoute: () => chooseAccessRoute
+});
+module.exports = __toCommonJS(exports_access_route);
+
+// src/local-route-fetch.ts
+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";
+function resolveSolidLocalRouteUrl(input, routes) {
+  let sourceUrl;
+  try {
+    sourceUrl = input instanceof URL ? new URL(input.href) : new URL(input);
+  } catch {
+    return;
+  }
+  const route = routes.map(normalizeRoute).filter((candidate) => isInsideBase(sourceUrl, candidate.canonicalBaseUrl)).sort((left, right) => right.canonicalBaseUrl.length - left.canonicalBaseUrl.length)[0];
+  return route ? replaceBase(sourceUrl, route) : undefined;
+}
+function createSolidLocalRouteFetch(options) {
+  return async (input, init) => {
+    const sourceUrl = requestUrl(input);
+    if (!sourceUrl) {
+      return init === undefined ? options.fetch.call(globalThis, input) : options.fetch.call(globalThis, input, init);
+    }
+    const routes = options.routes();
+    const targetUrl = resolveSolidLocalRouteUrl(sourceUrl, routes);
+    if (!targetUrl) {
+      return init === undefined ? options.fetch.call(globalThis, input) : options.fetch.call(globalThis, input, init);
+    }
+    const headers = routedHeaders(input, init, sourceUrl, targetUrl);
+    let response;
+    if (input instanceof Request) {
+      const request = new Request(new Request(targetUrl, input), { headers });
+      response = init === undefined ? await options.fetch.call(globalThis, request) : await options.fetch.call(globalThis, request, { ...init, headers });
+    } else {
+      response = await options.fetch.call(globalThis, targetUrl, { ...init, headers });
+    }
+    const canonicalResponseUrl = resolveSolidLocalRouteUrl(response.url, routes.map((route) => ({
+      canonicalBaseUrl: route.localBaseUrl,
+      localBaseUrl: route.canonicalBaseUrl
+    })));
+    return canonicalResponseUrl ? withResponseUrl(response, canonicalResponseUrl.href) : response;
+  };
+}
+function withResponseUrl(response, url) {
+  const clone = response.clone.bind(response);
+  Object.defineProperties(response, {
+    url: { value: url, configurable: true },
+    clone: { value: () => withResponseUrl(clone(), url), configurable: true }
+  });
+  return response;
+}
+function requestUrl(input) {
+  if (input instanceof Request)
+    return new URL(input.url);
+  try {
+    return new URL(String(input));
+  } catch {
+    return;
+  }
+}
+function normalizeRoute(route) {
+  return {
+    canonicalBaseUrl: normalizeBaseUrl(route.canonicalBaseUrl),
+    localBaseUrl: normalizeBaseUrl(route.localBaseUrl)
+  };
+}
+function normalizeBaseUrl(value) {
+  const url = new URL(value);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new TypeError("Solid local routes must use http or https");
+  }
+  url.search = "";
+  url.hash = "";
+  return url.href.endsWith("/") ? url.href : `${url.href}/`;
+}
+function isInsideBase(url, base) {
+  const canonical = new URL(base);
+  return url.origin === canonical.origin && url.pathname.startsWith(canonical.pathname);
+}
+function replaceBase(url, route) {
+  const canonical = new URL(route.canonicalBaseUrl);
+  const local = new URL(route.localBaseUrl);
+  const relativePath = url.pathname.slice(canonical.pathname.length);
+  const target = new URL(relativePath, local);
+  target.search = url.search;
+  target.hash = url.hash;
+  return target;
+}
+function routedHeaders(input, init, canonicalUrl, localUrl) {
+  const request = input instanceof Request ? input : undefined;
+  const headers = new Headers(request?.headers ?? undefined);
+  new Headers(init?.headers ?? undefined).forEach((value, key) => headers.set(key, value));
+  headers.set(SOLID_LOCAL_ROUTE_CANONICAL_URL_HEADER, canonicalUrl.toString());
+  headers.set(SOLID_LOCAL_ROUTE_CANONICAL_ORIGIN_HEADER, canonicalUrl.origin);
+  headers.set(SOLID_LOCAL_ROUTE_CANONICAL_HOST_HEADER, canonicalUrl.host);
+  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/access-route.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Access routes for a node whose canonical URL never changes.
+ *
+ * A Pod's canonical URL is its RDF identity (`docs/multi-channel-access.md`), and
+ * the same identity can be reached over several physical paths: the node's own
+ * loopback listener, a LAN address, a public address, a hole-punched p2p socket
+ * or the user's tunnel. Callers pick by *where they are*, so the routes carry the
+ * priority that encodes it and the health that says whether it currently works.
+ */
+export type AccessRouteKind = 'loopback' | 'lan' | 'public-direct' | 'p2p' | 'user-tunnel' | 'xpod-relay';
+export type AccessRouteVisibility = 'local-only' | 'same-account' | 'authorized-client' | 'public';
+export type AccessRouteHealth = 'unknown' | 'healthy' | 'degraded' | 'unreachable';
+export interface AccessRoute {
+    id: string;
+    nodeId?: string;
+    /** The canonical origin this route serves. Requests keep this identity. */
+    canonicalUrl: string;
+    kind: AccessRouteKind;
+    /** Where the request is actually sent. */
+    targetUrl: string;
+    /** Lower wins. Loopback is 10, lan 20, public-direct 30, p2p 40, tunnel 50. */
+    priority: number;
+    requiresManagedClient?: boolean;
+    visibility?: AccessRouteVisibility;
+    health?: AccessRouteHealth;
+    metadata?: Record<string, unknown>;
+}
+export interface AccessRouteSet {
+    nodeId?: string;
+    canonicalUrl: string;
+    generatedAt?: string;
+    routes: readonly AccessRoute[];
+}
+export interface ChooseAccessRouteOptions {
+    /** A client that may use private routes (LAN, p2p, tunnel). */
+    managedClient?: boolean;
+    /**
+     * A client running on the node's own host may use `local-only` routes. It has
+     * to say so: a loopback target is meaningless anywhere else.
+     */
+    allowLocalOnlyRoutes?: boolean;
+    probeTimeoutMs?: number;
+    probe?: (route: AccessRoute, signal: AbortSignal) => Promise<boolean> | boolean;
+}
+/**
+ * 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 declare function chooseAccessRoute(routeSet: AccessRouteSet, options?: ChooseAccessRouteOptions): Promise<AccessRoute | null>;
+export declare function usableRoutes(routeSet: AccessRouteSet, managedClient: boolean, allowLocalOnlyRoutes: boolean): AccessRoute[];
+export interface CreateSolidAccessRouteFetchOptions {
+    fetch: typeof globalThis.fetch;
+    /** Current route set. Re-read on every request so a caller can refresh it. */
+    routes: () => readonly AccessRoute[];
+    /**
+     * Re-discover the routes after the selected one stops working, which is how a
+     * client keeps using the newest path it knows about.
+     */
+    refreshRoutes?: () => Promise<readonly AccessRoute[] | void> | readonly AccessRoute[] | void;
+    managedClient?: boolean;
+    /** Set by clients that run on the node's own host (`local-only` routes). */
+    allowLocalOnlyRoutes?: boolean;
+    probeTimeoutMs?: number;
+    probe?: (route: AccessRoute, signal: AbortSignal) => Promise<boolean> | boolean;
+}
+/**
+ * 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 declare function createSolidAccessRouteFetch(options: CreateSolidAccessRouteFetchOptions): typeof globalThis.fetch;

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';