@maintainer-pro/ai-bridge 0.1.16 → 0.1.19

package/src/share-rewrite.mjs

@@ -79,7 +79,8 @@ export function prepareShareHttpRequest(
   headers,
   publicBase,
   acceptEncodingHint,
-  path
+  path,
+  portUrls
 ) {
   const out = { ...headers };
   const acceptEncoding = String(
@@ -116,6 +117,13 @@ export function prepareShareHttpRequest(
       /* ignore */
     }
   }
+  if (portUrls && typeof portUrls === "object") {
+    for (const key of Object.keys(out)) {
+      const lower = key.toLowerCase();
+      if (lower === "host" || lower === "content-length") continue;
+      out[key] = rewriteMappedLocalUrls(out[key], portUrls);
+    }
+  }
   return { headers: out, acceptEncoding, ifNoneMatch };
 }
 
@@ -123,14 +131,23 @@ export function shouldRewriteBody(headers) {
   const enc = headerGet(headers, "content-encoding").toLowerCase();
   if (enc && enc !== "identity") return false;
   const ct = headerGet(headers, "content-type").toLowerCase();
-  return /html|javascript|ecmascript|css|json|svg|xml|text\/plain|text\/x-component|text\/x-ref|\brsc\b/.test(
+  if (/event-stream|octet-stream|image\/|audio\/|video\/|font\/|wasm/.test(ct)) {
+    return false;
+  }
+  return /html|javascript|ecmascript|css|json|svg|xml|text\/|urlencoded|x-component|x-ref|\brsc\b/.test(
     ct
   );
 }
 
 /** Redirects have no Content-Type, but Location still has to stay under the share prefix. */
 export function shouldProcessShareResponse(headers) {
-  return Boolean(headerGet(headers, "location")) || shouldRewriteBody(headers);
+  if (headerGet(headers, "location")) return true;
+  if (shouldRewriteBody(headers)) return true;
+  const ct = headerGet(headers, "content-type").toLowerCase();
+  if (ct) return false;
+  const len = Number(headerGet(headers, "content-length") || 0);
+  if (len > 2 * 1024 * 1024) return false;
+  return true;
 }
 
 function isImmutableAssetPath(path) {
@@ -155,7 +172,8 @@ function isNoStorePath(path) {
     /\/@vite(?:\/|$)/.test(p) ||
     /\/@react-refresh/.test(p) ||
     /\/@fs\//.test(p) ||
-    /\/@id\//.test(p)
+    /\/@id\//.test(p) ||
+    /\/__mp\//.test(p)
   );
 }
 
@@ -240,30 +258,274 @@ function notModifiedResult(headers, etag) {
   return { status: 304, headers: out, body: Buffer.alloc(0) };
 }
 
-function rewriteLocation(value, publicBase, port) {
-  if (!publicBase) return value;
-  const base = String(publicBase).replace(/\/$/, "");
+function isLoopbackHost(host) {
+  const name = String(host || "").toLowerCase().replace(/^\[|\]$/g, "");
+  return (
+    name === "127.0.0.1" ||
+    name === "localhost" ||
+    name === "::1" ||
+    name === "0.0.0.0"
+  );
+}
+
+function mappedUrlForPort(portUrls, port) {
+  if (!portUrls || !port) return "";
+  const dest = portUrls[port] || portUrls[String(port)];
+  return dest ? String(dest).replace(/\/$/, "") : "";
+}
+
+function isProbablyUtf8Text(buf) {
+  if (!Buffer.isBuffer(buf) || !buf.length || buf.length > 8 * 1024 * 1024) {
+    return false;
+  }
+  const sample = buf.subarray(0, Math.min(buf.length, 4096));
+  if (sample.includes(0)) return false;
+  return true;
+}
+
+/**
+ * Replace app-list origins (`localhost:8080`, LAN IPs, hostnames) with the
+ * share URL for that port. Self-contained so the browser shim/SW can embed it.
+ *
+ * @param {string} text
+ * @param {Record<string, string> | null | undefined} portUrls
+ */
+export function rewriteMappedLocalUrls(text, portUrls) {
+  if (!text || !portUrls) return text;
+  const ports = Object.keys(portUrls)
+    .map((key) => Number(key))
+    .filter((port) => Number.isInteger(port) && port > 0 && port <= 65535)
+    .sort((a, b) => b - a);
+  if (!ports.length) return text;
+  const localHost =
+    "(?:localhost|127\\.0\\.0\\.1|\\[::1\\]|::1|0\\.0\\.0\\.0|" +
+    "10\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}|" +
+    "192\\.168\\.\\d{1,3}\\.\\d{1,3}|" +
+    "172\\.(?:1[6-9]|2\\d|3[01])\\.\\d{1,3}\\.\\d{1,3}|" +
+    "169\\.254\\.\\d{1,3}\\.\\d{1,3}|" +
+    "[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\\.(?:local|lan|internal|home))?)";
+  const anyHost = "(?:[^\\s'\"\\\\/<>@:]+|\\[[0-9a-fA-F:]+\\])";
+  let out = String(text);
+  for (let i = 0; i < ports.length; i++) {
+    const port = ports[i];
+    const dest = String(portUrls[port] || portUrls[String(port)] || "").replace(
+      /\/$/,
+      ""
+    );
+    if (!dest) continue;
+    const destWs = dest.replace(/^http/i, "ws");
+    const destEsc = dest.replace(/\//g, "\\/");
+    const destWsEsc = destWs.replace(/\//g, "\\/");
+    const tail = "(?!\\d)";
+    const swap = function (matched, replacement) {
+      if (!matched) return matched;
+      if (dest.indexOf(matched) === 0 || destWs.indexOf(matched) === 0) {
+        return matched;
+      }
+      return replacement;
+    };
+    out = out.replace(new RegExp("https?://" + localHost + ":" + port + tail, "gi"), function (m) {
+      return swap(m, dest);
+    });
+    out = out.replace(new RegExp("wss?://" + localHost + ":" + port + tail, "gi"), function (m) {
+      return swap(m, destWs);
+    });
+    out = out.replace(new RegExp("https?:\\\\/\\\\/" + localHost + ":" + port + tail, "gi"), function (m) {
+      return swap(m, destEsc);
+    });
+    out = out.replace(new RegExp("wss?:\\\\/\\\\/" + localHost + ":" + port + tail, "gi"), function (m) {
+      return swap(m, destWsEsc);
+    });
+    out = out.replace(new RegExp("//" + localHost + ":" + port + tail, "gi"), function (m) {
+      return swap(m, dest.replace(/^https?:/i, ""));
+    });
+    out = out.replace(new RegExp("http://" + anyHost + ":" + port + tail, "gi"), function (m) {
+      return swap(m, dest);
+    });
+    out = out.replace(new RegExp("ws://" + anyHost + ":" + port + tail, "gi"), function (m) {
+      return swap(m, destWs);
+    });
+    out = out.replace(
+      new RegExp("(?<![\\w./])" + localHost + ":" + port + tail, "gi"),
+      function (m) {
+        return swap(m, dest);
+      }
+    );
+  }
+  return out;
+}
+
+/**
+ * @param {Buffer | string | null | undefined} body
+ * @param {Record<string, string>} headers
+ * @param {Record<string, string> | null | undefined} portUrls
+ */
+export function rewriteShareRequestBody(body, headers, portUrls, publicBase) {
+  if (!body) return body;
+  const buf = Buffer.isBuffer(body) ? body : Buffer.from(body);
+  if (!buf.length) return buf;
+  if (!shouldRewriteBody(headers) && !isProbablyUtf8Text(buf)) return buf;
+  let text = buf.toString("utf8");
+  let next = text;
+  if (portUrls && Object.keys(portUrls).length) {
+    next = rewriteMappedLocalUrls(next, portUrls);
+  }
+  if (publicBase) next = rewriteShareOriginPaths(next, publicBase);
+  if (next === text) return buf;
+  return Buffer.from(next, "utf8");
+}
+
+export function shareTokenRoot(publicBase) {
   const prefix = proxyPathPrefix(publicBase);
+  if (!prefix) return "";
+  const parts = prefix.split("/").filter(Boolean);
+  if (parts[0] === "p" && parts[1]) return `/${parts[0]}/${parts[1]}/`;
+  return prefix.endsWith("/") ? prefix : `${prefix}/`;
+}
+
+export function shareShimScript(pathPrefix, portUrls) {
+  return `(${shareProxyShim.toString()})(${JSON.stringify(pathPrefix || "")},${JSON.stringify(portUrls || {})},${rewriteMappedLocalUrls.toString()});`;
+}
+
+export function shareServiceWorkerScript(portUrls, tokenRoot) {
+  return `(${shareServiceWorkerMain.toString()})(${JSON.stringify(portUrls || {})},${JSON.stringify(tokenRoot || "/")},${rewriteMappedLocalUrls.toString()});`;
+}
+
+function rewriteHeaderUrls(headers, publicBase, port, portUrls) {
+  if (headers.location) {
+    headers.location = rewriteLocation(
+      headers.location,
+      publicBase,
+      port,
+      portUrls
+    );
+  }
+  if (headers.link) {
+    headers.link = rewriteLinkHeader(headers.link, publicBase);
+  }
+  if (headers["access-control-allow-origin"]) {
+    headers["access-control-allow-origin"] = rewriteAllowOrigin(
+      headers["access-control-allow-origin"],
+      publicBase
+    );
+  }
+  if (portUrls && Object.keys(portUrls).length) {
+    for (const key of Object.keys(headers)) {
+      const lower = key.toLowerCase();
+      if (lower === "set-cookie" || lower === "content-length" || lower === "content-encoding") {
+        continue;
+      }
+      headers[key] = rewriteMappedLocalUrls(headers[key], portUrls);
+    }
+  }
+  if (publicBase) {
+    for (const key of Object.keys(headers)) {
+      const lower = key.toLowerCase();
+      if (lower === "set-cookie" || lower === "content-length" || lower === "content-encoding") {
+        continue;
+      }
+      headers[key] = rewriteShareOriginPaths(headers[key], publicBase);
+    }
+  }
+}
+
+/**
+ * Apps that honor X-Forwarded-Host emit https://admin-host/oauth2 instead of
+ * localhost:8080/oauth2. Put those back under /p/{token}/{slug} so the token
+ * and app route stay on the URL.
+ *
+ * @param {string} value
+ * @param {string} publicBase
+ */
+export function prefixShareOriginUrl(value, publicBase) {
+  if (!value || !publicBase) return value;
+  try {
+    const base = new URL(String(publicBase).replace(/\/$/, ""));
+    const prefix = base.pathname.replace(/\/$/, "");
+    if (!prefix || prefix.indexOf("/p/") !== 0) return value;
+    const u = new URL(String(value), base);
+    if (u.protocol !== "http:" && u.protocol !== "https:") return value;
+    if (String(u.hostname || "").toLowerCase() !== String(base.hostname || "").toLowerCase()) {
+      return value;
+    }
+    const reqPort = u.port || (u.protocol === "https:" ? "443" : "80");
+    const basePort = base.port || (base.protocol === "https:" ? "443" : "80");
+    if (reqPort !== basePort) return value;
+    const path = u.pathname || "/";
+    if (path === prefix || path.indexOf(prefix + "/") === 0) return u.toString();
+    if (path.indexOf("/p/") === 0) return u.toString();
+    u.pathname = path === "/" ? prefix : prefix + path;
+    return u.toString();
+  } catch {
+    return value;
+  }
+}
+
+export function rewriteShareOriginPaths(text, publicBase) {
+  if (!text || !publicBase) return text;
+  let origin = "";
+  try {
+    origin = new URL(String(publicBase).replace(/\/$/, "")).origin;
+  } catch {
+    return text;
+  }
+  if (!origin) return text;
+  const originEsc = origin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const originSlashEsc = origin
+    .replace(/\//g, "\\/")
+    .replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  let out = String(text);
+  out = out.replace(new RegExp(originEsc + "(?:/[^\\s'\"<>\\\\]*)?", "gi"), function (matched) {
+    return prefixShareOriginUrl(matched, publicBase);
+  });
+  out = out.replace(
+    new RegExp(originSlashEsc + "(?:\\\\/[^\\s'\"<>]*)?", "gi"),
+    function (matched) {
+      const unescaped = matched.replace(/\\\//g, "/");
+      return prefixShareOriginUrl(unescaped, publicBase).replace(/\//g, "\\/");
+    }
+  );
+  return out;
+}
+
+function rewriteLocation(value, publicBase, port, portUrls) {
+  if (!publicBase && !(portUrls && Object.keys(portUrls).length)) return value;
   try {
     const u = new URL(value, `http://127.0.0.1:${Number(port) || 0}`);
-    const host = String(u.hostname || "").toLowerCase();
-    const local =
-      host === "127.0.0.1" ||
-      host === "localhost" ||
-      host === "::1" ||
-      host === "0.0.0.0";
-    if (!local) return value;
-    let path = u.pathname || "/";
-    if (prefix && (path === prefix || path.startsWith(`${prefix}/`))) {
-      path = path.slice(prefix.length) || "/";
-    }
-    return `${base}${path}${u.search}${u.hash}`;
+    if (isLoopbackHost(u.hostname)) {
+      const locPort = Number(u.port) || Number(port) || 0;
+      const mapped =
+        mappedUrlForPort(portUrls, locPort) ||
+        String(publicBase || "").replace(/\/$/, "");
+      if (!mapped) return value;
+      const prefix = proxyPathPrefix(mapped);
+      let path = u.pathname || "/";
+      if (prefix && (path === prefix || path.startsWith(`${prefix}/`))) {
+        path = path.slice(prefix.length) || "/";
+      }
+      if (path === "/") return `${mapped}${u.search}${u.hash}`;
+      return `${mapped}${path}${u.search}${u.hash}`;
+    }
+    const fromPorts = rewriteMappedLocalUrls(String(value), portUrls);
+    if (fromPorts !== String(value)) return fromPorts;
+    if (publicBase) return prefixShareOriginUrl(String(value), publicBase);
   } catch {
     /* keep */
   }
   return value;
 }
 
+function rewriteAllowOrigin(value, publicBase) {
+  if (!value || value === "*" || !publicBase) return value;
+  try {
+    const u = new URL(value);
+    if (!isLoopbackHost(u.hostname)) return value;
+    return new URL(publicBase).origin;
+  } catch {
+    return value;
+  }
+}
+
 function rewriteLinkHeader(value, publicBase) {
   const prefix = proxyPathPrefix(publicBase);
   if (!prefix || !value) return value;
@@ -686,11 +948,22 @@ function injectMaintainerProEmbed(html, aiPublicBase) {
 }
 
 /**
- * In-page rewrite: navigation stays under the share prefix; fetch/XHR/WebSocket
- * only touch same-origin Vite/Next assets. Other hosts are left unchanged.
+ * Intercept every browser request and map listed app ports onto share URLs.
  */
-function shareProxyShim(p) {
-  if (!p) return;
+function shareProxyShim(p, portMap, rewriteMappedLocalUrls) {
+  if (!p || window.__MP_SHARE_SHIM__) return;
+  window.__MP_SHARE_SHIM__ = 1;
+  window.__MP_PORT_MAP__ = portMap || {};
+  function rewriteText(text) {
+    if (typeof text !== "string" || !text || typeof rewriteMappedLocalUrls !== "function") {
+      return text;
+    }
+    try {
+      return rewriteMappedLocalUrls(text, portMap);
+    } catch (e) {
+      return text;
+    }
+  }
   function collapse(path) {
     var d = p + p;
     while (path.indexOf(d) === 0) path = p + path.slice(d.length);
@@ -713,13 +986,40 @@ function shareProxyShim(p) {
       if (path === p || path.indexOf(p + "/") === 0) return collapse(path);
       var root = p.slice(0, p.lastIndexOf("/"));
       if (root && (path === root || path.indexOf(root + "/") === 0)) return path;
+      if (path.indexOf("/p/") === 0) return path;
       if (path === "/api/v1" || path.indexOf("/api/v1/") === 0) return path;
       return collapse(p + path);
     }
     return path;
   }
+  function mapLocal(v) {
+    if (typeof v !== "string" || !v) return v;
+    if (
+      v.indexOf("blob:") === 0 ||
+      v.indexOf("data:") === 0 ||
+      v.indexOf("javascript:") === 0
+    ) {
+      return v;
+    }
+    var raw = v;
+    if (
+      v.indexOf("://") < 0 &&
+      /^(localhost|127\.0\.0\.1|\[::1\]|0\.0\.0\.0):\d+/i.test(v)
+    ) {
+      raw = "http://" + v;
+    }
+    var next = rewriteText(raw);
+    if (next !== raw) return next;
+    try {
+      var u = new URL(v, location.href);
+      var resolved = rewriteText(u.href);
+      if (resolved !== u.href) return resolved;
+    } catch (e) {}
+    return v;
+  }
   function addNav(v) {
     if (typeof v !== "string" || !v) return v;
+    v = mapLocal(v);
     if (v.charAt(0) === "/" && v.charAt(1) !== "/") return prefixPath(v);
     try {
       var nav = new URL(v, location.href);
@@ -730,23 +1030,7 @@ function shareProxyShim(p) {
     return v;
   }
   function addNet(v) {
-    if (typeof v !== "string" || !v) return v;
-    try {
-      if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(v) || v.indexOf("//") === 0) {
-        var net = new URL(v, location.href);
-        if (net.origin !== location.origin) return v;
-        if (net.pathname === p || net.pathname.indexOf(p + "/") === 0) return v;
-        if (!isAsset(net.pathname)) return v;
-        net.pathname = prefixPath(net.pathname);
-        return net.toString();
-      }
-    } catch (e) {}
-    if (v.charAt(0) === "/" && v.charAt(1) !== "/") {
-      if (v === p || v.indexOf(p + "/") === 0) return collapse(v);
-      if (!isAsset(v)) return v;
-      return prefixPath(v);
-    }
-    return v;
+    return addNav(v);
   }
   function mapSel(sel) {
     if (typeof sel !== "string") return sel;
@@ -776,11 +1060,22 @@ function shareProxyShim(p) {
   patchQS(Element.prototype, "querySelectorAll");
   var sa = Element.prototype.setAttribute;
   Element.prototype.setAttribute = function (n, v) {
-    if ((n === "src" || n === "href") && typeof v === "string") v = addNav(v);
+    var name = String(n || "").toLowerCase();
+    if (
+      (name === "src" ||
+        name === "href" ||
+        name === "action" ||
+        name === "poster" ||
+        name === "data-src") &&
+      typeof v === "string"
+    ) {
+      v = addNav(v);
+    }
     return sa.call(this, n, v);
   };
   function patchUrlProp(ctor, prop) {
     try {
+      if (!ctor || !ctor.prototype) return;
       var d = Object.getOwnPropertyDescriptor(ctor.prototype, prop);
       if (!d || !d.set) return;
       Object.defineProperty(ctor.prototype, prop, {
@@ -795,6 +1090,13 @@ function shareProxyShim(p) {
   }
   patchUrlProp(HTMLScriptElement, "src");
   patchUrlProp(HTMLLinkElement, "href");
+  patchUrlProp(HTMLAnchorElement, "href");
+  patchUrlProp(HTMLImageElement, "src");
+  patchUrlProp(HTMLIFrameElement, "src");
+  patchUrlProp(HTMLFormElement, "action");
+  patchUrlProp(HTMLSourceElement, "src");
+  patchUrlProp(HTMLVideoElement, "src");
+  patchUrlProp(HTMLAudioElement, "src");
   var f = window.fetch;
   window.fetch = function (input, init) {
     if (typeof input === "string") input = addNet(input);
@@ -803,6 +1105,9 @@ function shareProxyShim(p) {
     } else if (typeof URL !== "undefined" && input instanceof URL) {
       input = new URL(addNet(input.href));
     }
+    if (init && typeof init.body === "string") {
+      init = Object.assign({}, init, { body: rewriteText(init.body) });
+    }
     return f.call(this, input, init);
   };
   var xo = XMLHttpRequest.prototype.open;
@@ -810,6 +1115,11 @@ function shareProxyShim(p) {
     if (typeof u === "string") arguments[1] = addNet(u);
     return xo.apply(this, arguments);
   };
+  var xs = XMLHttpRequest.prototype.send;
+  XMLHttpRequest.prototype.send = function (body) {
+    if (typeof body === "string") arguments[0] = rewriteText(body);
+    return xs.apply(this, arguments);
+  };
   var ps = history.pushState.bind(history);
   history.pushState = function (s, t, u) {
     if (typeof u === "string") u = addNav(u);
@@ -823,6 +1133,7 @@ function shareProxyShim(p) {
   var WS = window.WebSocket;
   function WrappedWS(url, protocols) {
     if (typeof url === "string") url = addNet(url);
+    else if (typeof URL !== "undefined" && url instanceof URL) url = addNet(url.href);
     return protocols !== undefined ? new WS(url, protocols) : new WS(url);
   }
   WrappedWS.prototype = WS.prototype;
@@ -831,6 +1142,30 @@ function shareProxyShim(p) {
   WrappedWS.CLOSING = WS.CLOSING;
   WrappedWS.CLOSED = WS.CLOSED;
   window.WebSocket = WrappedWS;
+  if (window.EventSource) {
+    var ES = window.EventSource;
+    function WrappedES(url, config) {
+      if (typeof url === "string") url = addNet(url);
+      return config !== undefined ? new ES(url, config) : new ES(url);
+    }
+    WrappedES.prototype = ES.prototype;
+    WrappedES.CONNECTING = ES.CONNECTING;
+    WrappedES.OPEN = ES.OPEN;
+    WrappedES.CLOSED = ES.CLOSED;
+    window.EventSource = WrappedES;
+  }
+  if (navigator.sendBeacon) {
+    var sb = navigator.sendBeacon.bind(navigator);
+    navigator.sendBeacon = function (url, data) {
+      if (typeof data === "string") data = rewriteText(data);
+      return sb(addNet(String(url)), data);
+    };
+  }
+  var wo = window.open;
+  window.open = function (url) {
+    if (typeof url === "string") arguments[0] = addNav(url);
+    return wo.apply(this, arguments);
+  };
   try {
     var la = location.assign.bind(location);
     location.assign = function (u) {
@@ -856,19 +1191,141 @@ function shareProxyShim(p) {
       });
     }
   } catch (e) {}
+  try {
+    var tokenRoot = p.replace(/\/[^/]+$/, "/");
+    if (navigator.serviceWorker && tokenRoot.indexOf("/p/") === 0) {
+      navigator.serviceWorker.register(p + "/__mp/sw.js", { scope: tokenRoot });
+    }
+  } catch (e) {}
+}
+
+function shareServiceWorkerMain(portMap, tokenRoot, rewriteMappedLocalUrls) {
+  self.addEventListener("install", function (event) {
+    event.waitUntil(self.skipWaiting());
+  });
+  self.addEventListener("activate", function (event) {
+    event.waitUntil(self.clients.claim());
+  });
+  function rewriteText(text) {
+    if (typeof text !== "string" || !text) return text;
+    try {
+      return rewriteMappedLocalUrls(text, portMap);
+    } catch (e) {
+      return text;
+    }
+  }
+  function appPrefixFromHref(href) {
+    try {
+      var u = new URL(String(href || ""));
+      var parts = u.pathname.split("/").filter(Boolean);
+      if (parts[0] === "p" && parts[1] && parts[2]) {
+        return "/" + parts[0] + "/" + parts[1] + "/" + parts[2];
+      }
+    } catch (e) {}
+    return "";
+  }
+  function prefixWith(url, prefix) {
+    if (!prefix) return url;
+    try {
+      var u = new URL(url, self.location.href);
+      if (u.origin !== self.location.origin) return url;
+      if (u.pathname.indexOf("/p/") === 0) return url;
+      if (u.pathname === prefix || u.pathname.indexOf(prefix + "/") === 0) return url;
+      u.pathname = u.pathname === "/" ? prefix : prefix + u.pathname;
+      return u.toString();
+    } catch (e) {}
+    return url;
+  }
+  function mapUrl(v, prefix) {
+    if (typeof v !== "string" || !v) return v;
+    if (v.indexOf("/__mp/") !== -1) return v;
+    return prefixWith(rewriteText(v), prefix);
+  }
+  self.addEventListener("fetch", function (event) {
+    var req = event.request;
+    if (req.url.indexOf("/__mp/") !== -1) return;
+    event.respondWith(
+      (async function () {
+        var client = null;
+        try {
+          if (event.clientId) client = await self.clients.get(event.clientId);
+        } catch (e) {}
+        var prefix =
+          appPrefixFromHref(client && client.url) ||
+          appPrefixFromHref(req.referrer) ||
+          appPrefixFromHref(self.registration && self.registration.scope);
+        var url = mapUrl(req.url, prefix);
+        var method = req.method;
+        var headers = new Headers(req.headers);
+        var body;
+        if (method !== "GET" && method !== "HEAD") {
+          try {
+            var ct = headers.get("content-type") || "";
+            if (/json|text|xml|urlencoded|javascript/.test(ct) || !ct) {
+              var text = await req.clone().text();
+              var next = rewriteText(text);
+              if (next !== text) body = next;
+            }
+          } catch (e) {}
+        }
+        var init = {
+          method: method,
+          headers: headers,
+          credentials: req.credentials,
+          redirect: req.redirect,
+          referrer: req.referrer,
+        };
+        if (req.mode && req.mode !== "navigate") init.mode = req.mode;
+        if (body !== undefined) init.body = body;
+        else if (method !== "GET" && method !== "HEAD") {
+          try {
+            init.body = await req.blob();
+          } catch (e) {}
+        }
+        var res = await fetch(new Request(url, init));
+        var outHeaders = new Headers(res.headers);
+        var loc = outHeaders.get("location");
+        if (loc) outHeaders.set("location", mapUrl(loc, prefix));
+        var resType = res.headers.get("content-type") || "";
+        if (
+          !/html|javascript|ecmascript|json|css|xml|svg|text|urlencoded/.test(resType)
+        ) {
+          if (loc && outHeaders.get("location") !== loc) {
+            return new Response(res.body, {
+              status: res.status,
+              statusText: res.statusText,
+              headers: outHeaders,
+            });
+          }
+          return res;
+        }
+        var resText = await res.text();
+        var mapped = rewriteText(resText);
+        outHeaders.delete("content-length");
+        outHeaders.delete("content-encoding");
+        return new Response(mapped, {
+          status: res.status,
+          statusText: res.statusText,
+          headers: outHeaders,
+        });
+      })()
+    );
+  });
 }
 
 function injectNextProxyShim(html, publicBase) {
   const prefix = proxyPathPrefix(publicBase);
-  if (
-    !prefix ||
-    html.includes("data-mp-proxy-next") ||
-    (!isNextDocument(html) && !isViteDocument(html))
-  ) {
+  if (!prefix || html.includes("data-mp-proxy-next")) {
     return html;
   }
-  const script = `<script data-mp-proxy-next>(${shareProxyShim.toString()})(${JSON.stringify(prefix)})</script>`;
-  return html.replace(/<head([^>]*)>/i, `<head$1>${script}`);
+  const script = `<script data-mp-proxy-next src="${prefix}/__mp/shim.js"><\/script>`;
+  if (/<head[^>]*>/i.test(html)) {
+    return html.replace(/<head([^>]*)>/i, `<head$1>${script}`);
+  }
+  if (/<body[^>]*>/i.test(html)) {
+    return html.replace(/<body([^>]*)>/i, `<body$1>${script}`);
+  }
+  return `${script}${html}`;
 }
 
 /**
@@ -885,6 +1342,7 @@ function injectNextProxyShim(html, publicBase) {
  *   acceptEncoding?: string,
  *   ifNoneMatch?: string,
  *   port?: number,
+ *   portUrls?: Record<string, string>,
  * }} opts
  * @returns {{ status: number, headers: Record<string, string>, body: Buffer }}
  */
@@ -896,6 +1354,8 @@ export function processShareHttpResponse(opts) {
   const acceptEncoding = String(opts?.acceptEncoding || "");
   const ifNoneMatch = String(opts?.ifNoneMatch || "");
   const port = Number(opts?.port) || 0;
+  const portUrls =
+    opts?.portUrls && typeof opts.portUrls === "object" ? opts.portUrls : {};
   let status =
     typeof opts?.status === "number" && opts.status >= 100 ? opts.status : 200;
   const headers = lowerHeaders(opts?.headers || {});
@@ -903,12 +1363,7 @@ export function processShareHttpResponse(opts) {
     ? opts.body
     : Buffer.from(opts?.body || "");
 
-  if (headers.location) {
-    headers.location = rewriteLocation(headers.location, publicBase, port);
-  }
-  if (headers.link) {
-    headers.link = rewriteLinkHeader(headers.link, publicBase);
-  }
+  rewriteHeaderUrls(headers, publicBase, port, portUrls);
 
   const cachedKey = rewriteCacheKey(publicBase, path);
   const hit =
@@ -933,10 +1388,27 @@ export function processShareHttpResponse(opts) {
 
   let text = payload.toString("utf8");
   let mutated = false;
-  if (publicBase && shouldRewriteBody(headers)) {
+  const rewriteTextBody =
+    shouldRewriteBody(headers) ||
+    (!headerGet(headers, "content-type") && isProbablyUtf8Text(payload));
+  if (publicBase && rewriteTextBody) {
     text = prefixRootPaths(text, publicBase, headers["content-type"] || "");
     mutated = true;
   }
+  if (Object.keys(portUrls).length && rewriteTextBody) {
+    const mapped = rewriteMappedLocalUrls(text, portUrls);
+    if (mapped !== text) {
+      text = mapped;
+      mutated = true;
+    }
+  }
+  if (publicBase && rewriteTextBody) {
+    const prefixed = rewriteShareOriginPaths(text, publicBase);
+    if (prefixed !== text) {
+      text = prefixed;
+      mutated = true;
+    }
+  }
   if (aiPublicBase) {
     const withShareUrls = rewriteLocalSidecarUrls(text, aiPublicBase, publicBase);
     if (withShareUrls !== text) {
@@ -951,12 +1423,8 @@ export function processShareHttpResponse(opts) {
       mutated = true;
     }
   }
-  if (
-    publicBase &&
-    isHtmlDocument(headers, text) &&
-    (isNextDocument(text) || isViteDocument(text))
-  ) {
-    const next = injectNextProxyShim(text, publicBase);
+  if (publicBase && isHtmlDocument(headers, text)) {
+    const next = injectNextProxyShim(text, publicBase, portUrls);
     if (next !== text) {
       text = next;
       mutated = true;