@statewalker/webrun-http-browser 0.5.0 → 0.6.2

package/src/relay/mount-table.ts

@@ -0,0 +1,115 @@
+/**
+ * Which registered service owns a URL.
+ *
+ * A pure lookup: no ServiceWorker, no storage, no I/O, so the routing rules
+ * can be tested as arithmetic rather than through a browser.
+ *
+ * TWO KINDS OF MOUNT, AND WHY BOTH. A `path` is a prefix, which is all most
+ * hosts need and costs nothing to match. A `match` predicate is the escape
+ * hatch for anything richer -- a host that wants URLPattern brings it and pays
+ * for it; this file must stay dependency-free, because it runs in a
+ * ServiceWorker that has to start fast.
+ *
+ * SPECIFICITY, NOT REGISTRATION ORDER. Prefixes are tried longest-first, so a
+ * catch-all at "/" cannot swallow "/peers/" and a host need not register in a
+ * careful order. Predicates are opaque -- nothing can be said about how
+ * specific they are -- so they are tried after every prefix, in the order they
+ * were registered.
+ */
+
+export interface MountSpec {
+  /** A path prefix, e.g. `/peers/`. `/` is the whole origin. */
+  path?: string;
+  /** Anything richer. Consulted only when no prefix matches. */
+  match?: (url: URL) => boolean;
+}
+
+export interface MountTable {
+  /** Add or replace the mount for `key`. */
+  set(key: string, spec: MountSpec): void;
+  remove(key: string): void;
+  /** The key that owns `url`, or `undefined` — meaning "not the relay's". */
+  find(url: URL): string | undefined;
+  /**
+   * Is `url` reserved by `exclude`? `find` already applies it, but the relay
+   * has a SECOND route — the `/~<key>/` spelling, which does not go through
+   * the table at all — and "an excluded path is never claimed" has to hold
+   * for both. The predicate lives here so there is one copy of it.
+   */
+  excludes(url: URL): boolean;
+}
+
+export interface MountTableOptions {
+  /**
+   * Paths the relay never claims, checked BEFORE the table. A root mount
+   * matches every path, so a host with files of its own (a relay page, a
+   * worker, hashed assets) is unusable without this.
+   */
+  exclude?: (url: URL) => boolean;
+}
+
+interface Entry {
+  key: string;
+  /** `""` for a predicate-only mount; otherwise `/` or `/a/b/`. */
+  prefix: string;
+  match?: (url: URL) => boolean;
+  /** Registration order, to break ties between predicates. */
+  seq: number;
+}
+
+/** `/` stays `/`; `/peers` and `/peers/` both become `/peers/`. */
+function normalise(path: string): string {
+  if (path === "" || path === "/") return "/";
+  const withSlash = path.startsWith("/") ? path : `/${path}`;
+  return withSlash.endsWith("/") ? withSlash : `${withSlash}/`;
+}
+
+/** Does `prefix` own `pathname`? `/peers/` owns `/peers/`, `/peers` and `/peers/x`. */
+function owns(prefix: string, pathname: string): boolean {
+  if (prefix === "/") return true;
+  if (pathname.startsWith(prefix)) return true;
+  return `${pathname}/` === prefix;
+}
+
+export function newMountTable(options: MountTableOptions = {}): MountTable {
+  const entries = new Map<string, Entry>();
+  let seq = 0;
+
+  return {
+    set(key, spec) {
+      entries.set(key, {
+        key,
+        prefix: spec.path == null ? "" : normalise(spec.path),
+        match: spec.match,
+        seq: seq++,
+      });
+    },
+
+    remove(key) {
+      entries.delete(key);
+    },
+
+    excludes(url) {
+      return options.exclude?.(url) === true;
+    },
+
+    find(url) {
+      if (options.exclude?.(url) === true) return undefined;
+
+      let best: Entry | undefined;
+      for (const entry of entries.values()) {
+        if (entry.prefix === "" || !owns(entry.prefix, url.pathname)) continue;
+        if (best == null || entry.prefix.length > best.prefix.length) best = entry;
+      }
+      if (best != null) return best.key;
+
+      const predicates = [...entries.values()]
+        .filter((entry) => entry.match != null)
+        .sort((a, b) => a.seq - b.seq);
+      for (const entry of predicates) {
+        if (entry.match?.(url) === true) return entry.key;
+      }
+      return undefined;
+    },
+  };
+}

package/src/relay/split-service-url.ts

@@ -12,19 +12,79 @@ export interface SplitServiceUrl {
  */
 export function splitServiceUrl(url: URL | string, separator = "~"): SplitServiceUrl {
   const str = `${url}`;
-  const idx = str.indexOf(separator);
-  let baseUrl = "";
-  let key = "";
-  let path = "";
-  if (idx >= 0) {
-    baseUrl = str.substring(0, idx + separator.length);
-    str.substring(idx + separator.length).replace(/^([^/]+)/, (match, $1) => {
-      baseUrl += match;
-      if (baseUrl.length < str.length) baseUrl += "/";
-      key = $1;
-      path = str.substring(baseUrl.length);
-      return "";
-    });
+  const empty = { url: str, key: "", baseUrl: "", path: "" };
+
+  // Strip query and fragment to prevent false positives on `?q=~foo` or `#~FS`.
+  // Extract the prefix (origin) and path from the input verbatim, preserving case
+  // and form (e.g., `//host` vs. `http://host`, `HTTPS://` vs. `https://`).
+  const hashIdx = str.indexOf("#");
+  const queryIdx = str.indexOf("?");
+  let strippedEnd = str.length;
+  if (hashIdx >= 0) strippedEnd = Math.min(strippedEnd, hashIdx);
+  if (queryIdx >= 0) strippedEnd = Math.min(strippedEnd, queryIdx);
+  const stripped = str.slice(0, strippedEnd);
+
+  // Identify where the path begins in the input. Three cases:
+  // 1. scheme://authority/path — prefix is scheme://authority
+  // 2. //authority/path — prefix is //authority
+  // 3. relative path — prefix is empty
+  let prefixEnd = 0;
+  const schemeMatch = stripped.match(/^[a-zA-Z][a-zA-Z0-9+\-.]*:\/\//);
+  if (schemeMatch) {
+    // scheme://authority/path — find the next / after the scheme
+    prefixEnd = schemeMatch[0].length;
+    const slashIdx = stripped.indexOf("/", prefixEnd);
+    if (slashIdx >= 0) {
+      prefixEnd = slashIdx;
+    } else {
+      return empty; // No path
+    }
+  } else if (stripped.startsWith("//")) {
+    // //authority/path — find the next / after the //
+    prefixEnd = 2;
+    const slashIdx = stripped.indexOf("/", prefixEnd);
+    if (slashIdx >= 0) {
+      prefixEnd = slashIdx;
+    } else {
+      return empty; // No path
+    }
   }
+  // else prefixEnd = 0: relative URL
+
+  const prefix = stripped.slice(0, prefixEnd);
+  const pathPart = stripped.slice(prefixEnd);
+
+  // Check if pathPart starts with the separator, anchored at the segment boundary.
+  // With an authority the path always begins with `/`, so the separator must be
+  // at `/<separator>`. Without one the input is either ROOT-RELATIVE
+  // (`/~FS/a/b` -- `location.pathname`, or any root-absolute href) or plain
+  // relative (`~FS/a/b`), and both are accepted: treating "no authority" as
+  // "relative" made every root-relative caller get nothing back.
+  let keyStart: number;
+  let rooted = false;
+  if (prefix === "") {
+    if (pathPart.startsWith(`/${separator}`)) {
+      rooted = true;
+      keyStart = separator.length + 1;
+    } else if (pathPart.startsWith(separator)) {
+      keyStart = separator.length;
+    } else {
+      return empty;
+    }
+  } else {
+    if (!pathPart.startsWith(`/${separator}`)) return empty;
+    keyStart = separator.length + 1;
+  }
+
+  const rest = pathPart.slice(keyStart);
+  const slash = rest.indexOf("/");
+  const key = slash < 0 ? rest : rest.slice(0, slash);
+  if (key === "") return empty;
+
+  // The base keeps the input's own form: `https://host/~FS/`, `//host/~FS/`,
+  // `/~FS/` and `~FS/` each round-trip as written.
+  const base = prefix === "" ? (rooted ? "/" : "") : `${prefix}/`;
+  const baseUrl = `${base}${separator}${key}${slash < 0 ? "" : "/"}`;
+  const path = slash < 0 ? "" : rest.slice(slash + 1);
   return { url: str, key, baseUrl, path };
 }

package/src/relay-sw.ts

@@ -1,7 +1,15 @@
 /// <reference lib="webworker" />
 
-import { startRelayServiceWorker } from "./relay/index-sw.js";
+import { type RelayServiceWorkerOptions, startRelayServiceWorker } from "./relay/index-sw.js";
 
-declare const self: ServiceWorkerGlobalScope;
+declare const self: ServiceWorkerGlobalScope & { RELAY_OPTIONS?: RelayServiceWorkerOptions };
 
-startRelayServiceWorker(self);
+// OPTIONS FROM A GLOBAL, because this bundle is loaded by `importScripts` from
+// a host's own worker script, which runs first and can set them. A classic
+// worker cannot pass arguments any other way, and module service workers are
+// not reachable through the relay page's registration (the bundle is IIFE, and
+// `getRelayWindowMessageHandler` registers with no `type`).
+//
+// Absent, the options are `{}` -- exactly what this file passed before, so a
+// host that only `importScripts`es the bundle sees no change.
+startRelayServiceWorker(self, self.RELAY_OPTIONS ?? {});

package/src/relay-worker.ts

@@ -0,0 +1,20 @@
+/**
+ * The relay ServiceWorker runtime, for a host that builds its own worker.
+ *
+ * TWO WAYS TO SHIP THE RELAY WORKER, and this is the typed one. A host that
+ * takes the prebuilt bundle loads `@statewalker/webrun-http-browser/relay-sw`
+ * through classic `importScripts` and passes its options in
+ * `self.RELAY_OPTIONS`, which cannot be typed from the outside because that
+ * bundle ships no declarations. A host that bundles its own worker imports
+ * this module instead and calls `startRelayServiceWorker(self, { … })`
+ * directly, with `RelayServiceWorkerOptions` to type the options — including
+ * `self.RELAY_OPTIONS`, for a host writing the tiny loader script by hand.
+ *
+ * Kept as its own entry rather than re-exported from the package root: this
+ * code only runs inside a ServiceWorker, and the root entry is what pages
+ * import.
+ */
+
+export type { RelayServiceWorkerOptions } from "./relay/index-sw.js";
+export { startRelayServiceWorker } from "./relay/index-sw.js";
+export type { MountSpec } from "./relay/mount-table.js";

package/src/sw/sw-dispatcher.ts

@@ -60,8 +60,17 @@ export class SwPortHandler {
     return this.options.scope ?? new URL("./", this.serviceWorkerUrl).pathname;
   }
 
+  /**
+   * The scope as a url on the worker's origin. Resolved against the worker's
+   * own url when one is given, not against this module's: a bundle that is
+   * not an ES module (an IIFE, Theia's frontend) has no `import.meta.url`, and
+   * `new URL(scope, undefined)` threw `Invalid URL` there. Only without a
+   * worker url does the module's location decide (its default `index-sw.js`
+   * sits next to it).
+   */
   get rootUrl(): URL {
-    return new URL(this.scope, import.meta.url);
+    const base = this.options.serviceWorkerUrl ? this.serviceWorkerUrl : import.meta.url;
+    return new URL(this.scope, base);
   }
 
   get serviceWorkerUrl(): string {

package/public-relay/heartbeat.js

@@ -1,31 +0,0 @@
-import * as workerTimer from "https://unpkg.com/worker-timers@7.0.74/build/es2019/module.js?module";
-
-export function startHeartbit({
-  timeout = 10 * 1000,
-  url = "./ping", // 10 seconds
-}) {
-  return callPeriodically(async () => {
-    const _res = await fetch(url);
-  }, timeout);
-}
-
-export async function callPeriodically(action, timeout) {
-  let timerId,
-    stopped = false;
-  async function run() {
-    try {
-      await action();
-    } catch (err) {
-      console.error(err);
-    }
-    timerId = !stopped ? workerTimer.setTimeout(run, timeout) : 0;
-  }
-  run();
-  return () => {
-    stopped = true;
-    if (timerId) {
-      workerTimer.clearTimeout(timerId);
-      timerId = 0;
-    }
-  };
-}