@statewalker/webrun-http-browser 0.5.0 → 0.6.0

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/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;
-    }
-  };
-}