@pagepocket/lib 0.7.1 → 0.8.0

package/dist/replay/match-api.js

@@ -0,0 +1,162 @@
+import { urlEquivalent } from "../utils.js";
+export function matchAPI(options) {
+    const { records, byKey, baseUrl, method, url, body } = options;
+    const normalizeBody = (value) => {
+        if (value === undefined || value === null)
+            return "";
+        if (typeof value === "string")
+            return value;
+        try {
+            return String(value);
+        }
+        catch {
+            return "";
+        }
+    };
+    const normalizeUrl = (input) => {
+        try {
+            return new URL(input, baseUrl).toString();
+        }
+        catch {
+            return input;
+        }
+    };
+    const stripHash = (value) => {
+        const index = value.indexOf("#");
+        return index === -1 ? value : value.slice(0, index);
+    };
+    const stripTrailingSlash = (value) => {
+        if (value.length > 1 && value.endsWith("/")) {
+            return value.slice(0, -1);
+        }
+        return value;
+    };
+    const safeUrl = (input) => {
+        try {
+            return new URL(input, baseUrl);
+        }
+        catch {
+            return null;
+        }
+    };
+    const toPathSearch = (input) => {
+        const parsed = safeUrl(input);
+        if (!parsed)
+            return input;
+        return parsed.pathname + parsed.search;
+    };
+    const toPathname = (input) => {
+        const parsed = safeUrl(input);
+        return parsed ? parsed.pathname : input;
+    };
+    const buildUrlVariants = (input) => {
+        const variants = new Set();
+        const push = (value) => {
+            if (!value)
+                return;
+            variants.add(value);
+        };
+        const raw = String(input ?? "");
+        push(raw);
+        push(stripHash(raw));
+        push(stripTrailingSlash(raw));
+        push(stripTrailingSlash(stripHash(raw)));
+        const absolute = normalizeUrl(raw);
+        push(absolute);
+        const absoluteNoHash = stripHash(absolute);
+        push(absoluteNoHash);
+        push(stripTrailingSlash(absoluteNoHash));
+        const pathSearch = toPathSearch(raw);
+        push(pathSearch);
+        push(stripTrailingSlash(pathSearch));
+        const pathname = toPathname(raw);
+        push(pathname);
+        push(stripTrailingSlash(pathname));
+        return Array.from(variants);
+    };
+    const makeKey = (keyMethod, keyUrl, keyBody) => keyMethod.toUpperCase() + " " + normalizeUrl(keyUrl) + " " + normalizeBody(keyBody);
+    const urlVariants = buildUrlVariants(url);
+    const bodyValue = normalizeBody(body);
+    const methodValue = (method || "GET").toUpperCase();
+    const tryLookup = (keyMethod, keyBody) => {
+        if (!byKey)
+            return undefined;
+        for (const urlVariant of urlVariants) {
+            const record = byKey.get(makeKey(keyMethod, urlVariant, keyBody));
+            if (record)
+                return record;
+        }
+        return undefined;
+    };
+    const matchOrder = [
+        [methodValue, bodyValue],
+        [methodValue, ""],
+        ["GET", ""],
+        ["GET", bodyValue]
+    ];
+    for (const [keyMethod, keyBody] of matchOrder) {
+        const record = tryLookup(keyMethod, keyBody);
+        if (record)
+            return record;
+    }
+    const toUrlOrNull = (value) => {
+        try {
+            return new URL(value, baseUrl);
+        }
+        catch {
+            return null;
+        }
+    };
+    const normalizePath = (value) => {
+        if (value.length > 1 && value.endsWith("/")) {
+            return value.slice(0, -1);
+        }
+        return value;
+    };
+    const urlMatches = (inputUrl, recordUrl) => {
+        // Strong match first.
+        if (urlEquivalent(inputUrl, recordUrl, {
+            baseUrl,
+            ignoreHash: true,
+            ignoreDefaultPort: true,
+            normalizeTrailingSlash: true
+        })) {
+            return true;
+        }
+        // Relaxed fallback: allow origin mismatch but keep path/search stable.
+        const left = toUrlOrNull(inputUrl);
+        const right = toUrlOrNull(recordUrl);
+        if (!left || !right) {
+            return false;
+        }
+        const leftPathSearch = normalizePath(left.pathname) + left.search;
+        const rightPathSearch = normalizePath(right.pathname) + right.search;
+        if (leftPathSearch === rightPathSearch) {
+            return true;
+        }
+        const leftPath = normalizePath(left.pathname);
+        const rightPath = normalizePath(right.pathname);
+        return leftPath === rightPath;
+    };
+    const scanRecords = (keyMethod, keyBody) => {
+        for (const record of records || []) {
+            if (!record || !record.url || !record.method)
+                continue;
+            if (record.method.toUpperCase() !== keyMethod)
+                continue;
+            if (!urlMatches(url, record.url))
+                continue;
+            const recordBody = record.requestBody || record.requestBodyBase64 || "";
+            if (keyBody && recordBody !== keyBody)
+                continue;
+            return record;
+        }
+        return undefined;
+    };
+    for (const [keyMethod, keyBody] of matchOrder) {
+        const record = scanRecords(keyMethod, keyBody);
+        if (record)
+            return record;
+    }
+    return undefined;
+}

package/dist/replay/templates/match-api-source.d.ts

@@ -0,0 +1 @@
+export declare const matchAPISource = "function matchAPI(options) {\n    const { records, byKey, baseUrl, method, url, body } = options;\n    const normalizeBody = (value) => {\n        if (value === undefined || value === null)\n            return \"\";\n        if (typeof value === \"string\")\n            return value;\n        try {\n            return String(value);\n        }\n        catch {\n            return \"\";\n        }\n    };\n    const normalizeUrl = (input) => {\n        try {\n            return new URL(input, baseUrl).toString();\n        }\n        catch {\n            return input;\n        }\n    };\n    const stripHash = (value) => {\n        const index = value.indexOf(\"#\");\n        return index === -1 ? value : value.slice(0, index);\n    };\n    const stripTrailingSlash = (value) => {\n        if (value.length > 1 && value.endsWith(\"/\")) {\n            return value.slice(0, -1);\n        }\n        return value;\n    };\n    const safeUrl = (input) => {\n        try {\n            return new URL(input, baseUrl);\n        }\n        catch {\n            return null;\n        }\n    };\n    const toPathSearch = (input) => {\n        const parsed = safeUrl(input);\n        if (!parsed)\n            return input;\n        return parsed.pathname + parsed.search;\n    };\n    const toPathname = (input) => {\n        const parsed = safeUrl(input);\n        return parsed ? parsed.pathname : input;\n    };\n    const buildUrlVariants = (input) => {\n        const variants = new Set();\n        const push = (value) => {\n            if (!value)\n                return;\n            variants.add(value);\n        };\n        const raw = String(input ?? \"\");\n        push(raw);\n        push(stripHash(raw));\n        push(stripTrailingSlash(raw));\n        push(stripTrailingSlash(stripHash(raw)));\n        const absolute = normalizeUrl(raw);\n        push(absolute);\n        const absoluteNoHash = stripHash(absolute);\n        push(absoluteNoHash);\n        push(stripTrailingSlash(absoluteNoHash));\n        const pathSearch = toPathSearch(raw);\n        push(pathSearch);\n        push(stripTrailingSlash(pathSearch));\n        const pathname = toPathname(raw);\n        push(pathname);\n        push(stripTrailingSlash(pathname));\n        return Array.from(variants);\n    };\n    const makeKey = (keyMethod, keyUrl, keyBody) => keyMethod.toUpperCase() + \" \" + normalizeUrl(keyUrl) + \" \" + normalizeBody(keyBody);\n    const urlVariants = buildUrlVariants(url);\n    const bodyValue = normalizeBody(body);\n    const methodValue = (method || \"GET\").toUpperCase();\n    const tryLookup = (keyMethod, keyBody) => {\n        if (!byKey)\n            return undefined;\n        for (const urlVariant of urlVariants) {\n            const record = byKey.get(makeKey(keyMethod, urlVariant, keyBody));\n            if (record)\n                return record;\n        }\n        return undefined;\n    };\n    const matchOrder = [\n        [methodValue, bodyValue],\n        [methodValue, \"\"],\n        [\"GET\", \"\"],\n        [\"GET\", bodyValue]\n    ];\n    for (const [keyMethod, keyBody] of matchOrder) {\n        const record = tryLookup(keyMethod, keyBody);\n        if (record)\n            return record;\n    }\n    const urlMatches = (inputUrl, recordUrl) => {\n        const inputAbs = stripHash(normalizeUrl(inputUrl));\n        const recordAbs = stripHash(normalizeUrl(recordUrl));\n        if (inputAbs === recordAbs)\n            return true;\n        const inputPathSearch = stripTrailingSlash(toPathSearch(inputUrl));\n        const recordPathSearch = stripTrailingSlash(toPathSearch(recordUrl));\n        if (inputPathSearch === recordPathSearch)\n            return true;\n        const inputPath = stripTrailingSlash(toPathname(inputUrl));\n        const recordPath = stripTrailingSlash(toPathname(recordUrl));\n        if (inputPath === recordPath)\n            return true;\n        return false;\n    };\n    const scanRecords = (keyMethod, keyBody) => {\n        for (const record of records || []) {\n            if (!record || !record.url || !record.method)\n                continue;\n            if (record.method.toUpperCase() !== keyMethod)\n                continue;\n            if (!urlMatches(url, record.url))\n                continue;\n            const recordBody = record.requestBody || record.requestBodyBase64 || \"\";\n            if (keyBody && recordBody !== keyBody)\n                continue;\n            return record;\n        }\n        return undefined;\n    };\n    for (const [keyMethod, keyBody] of matchOrder) {\n        const record = scanRecords(keyMethod, keyBody);\n        if (record)\n            return record;\n    }\n    return undefined;\n}";

package/dist/replay/templates/match-api-source.js

@@ -0,0 +1,137 @@
+export const matchAPISource = `function matchAPI(options) {
+    const { records, byKey, baseUrl, method, url, body } = options;
+    const normalizeBody = (value) => {
+        if (value === undefined || value === null)
+            return "";
+        if (typeof value === "string")
+            return value;
+        try {
+            return String(value);
+        }
+        catch {
+            return "";
+        }
+    };
+    const normalizeUrl = (input) => {
+        try {
+            return new URL(input, baseUrl).toString();
+        }
+        catch {
+            return input;
+        }
+    };
+    const stripHash = (value) => {
+        const index = value.indexOf("#");
+        return index === -1 ? value : value.slice(0, index);
+    };
+    const stripTrailingSlash = (value) => {
+        if (value.length > 1 && value.endsWith("/")) {
+            return value.slice(0, -1);
+        }
+        return value;
+    };
+    const safeUrl = (input) => {
+        try {
+            return new URL(input, baseUrl);
+        }
+        catch {
+            return null;
+        }
+    };
+    const toPathSearch = (input) => {
+        const parsed = safeUrl(input);
+        if (!parsed)
+            return input;
+        return parsed.pathname + parsed.search;
+    };
+    const toPathname = (input) => {
+        const parsed = safeUrl(input);
+        return parsed ? parsed.pathname : input;
+    };
+    const buildUrlVariants = (input) => {
+        const variants = new Set();
+        const push = (value) => {
+            if (!value)
+                return;
+            variants.add(value);
+        };
+        const raw = String(input ?? "");
+        push(raw);
+        push(stripHash(raw));
+        push(stripTrailingSlash(raw));
+        push(stripTrailingSlash(stripHash(raw)));
+        const absolute = normalizeUrl(raw);
+        push(absolute);
+        const absoluteNoHash = stripHash(absolute);
+        push(absoluteNoHash);
+        push(stripTrailingSlash(absoluteNoHash));
+        const pathSearch = toPathSearch(raw);
+        push(pathSearch);
+        push(stripTrailingSlash(pathSearch));
+        const pathname = toPathname(raw);
+        push(pathname);
+        push(stripTrailingSlash(pathname));
+        return Array.from(variants);
+    };
+    const makeKey = (keyMethod, keyUrl, keyBody) => keyMethod.toUpperCase() + " " + normalizeUrl(keyUrl) + " " + normalizeBody(keyBody);
+    const urlVariants = buildUrlVariants(url);
+    const bodyValue = normalizeBody(body);
+    const methodValue = (method || "GET").toUpperCase();
+    const tryLookup = (keyMethod, keyBody) => {
+        if (!byKey)
+            return undefined;
+        for (const urlVariant of urlVariants) {
+            const record = byKey.get(makeKey(keyMethod, urlVariant, keyBody));
+            if (record)
+                return record;
+        }
+        return undefined;
+    };
+    const matchOrder = [
+        [methodValue, bodyValue],
+        [methodValue, ""],
+        ["GET", ""],
+        ["GET", bodyValue]
+    ];
+    for (const [keyMethod, keyBody] of matchOrder) {
+        const record = tryLookup(keyMethod, keyBody);
+        if (record)
+            return record;
+    }
+    const urlMatches = (inputUrl, recordUrl) => {
+        const inputAbs = stripHash(normalizeUrl(inputUrl));
+        const recordAbs = stripHash(normalizeUrl(recordUrl));
+        if (inputAbs === recordAbs)
+            return true;
+        const inputPathSearch = stripTrailingSlash(toPathSearch(inputUrl));
+        const recordPathSearch = stripTrailingSlash(toPathSearch(recordUrl));
+        if (inputPathSearch === recordPathSearch)
+            return true;
+        const inputPath = stripTrailingSlash(toPathname(inputUrl));
+        const recordPath = stripTrailingSlash(toPathname(recordUrl));
+        if (inputPath === recordPath)
+            return true;
+        return false;
+    };
+    const scanRecords = (keyMethod, keyBody) => {
+        for (const record of records || []) {
+            if (!record || !record.url || !record.method)
+                continue;
+            if (record.method.toUpperCase() !== keyMethod)
+                continue;
+            if (!urlMatches(url, record.url))
+                continue;
+            const recordBody = record.requestBody || record.requestBodyBase64 || "";
+            if (keyBody && recordBody !== keyBody)
+                continue;
+            return record;
+        }
+        return undefined;
+    };
+    for (const [keyMethod, keyBody] of matchOrder) {
+        const record = scanRecords(keyMethod, keyBody);
+        if (record)
+            return record;
+    }
+    return undefined;
+}`;

package/dist/replay/templates/replay-script-template.d.ts

@@ -0,0 +1,5 @@
+export declare const buildReplayInjectedScript: (options: {
+    basePayload: string;
+    apiPayload: string;
+    hackerScripts: string;
+}) => string;

package/dist/replay/templates/replay-script-template.js

@@ -0,0 +1,337 @@
+import { matchAPISource } from "./match-api-source.js";
+import { resourceProxyScript } from "./resource-proxy-script.js";
+export const buildReplayInjectedScript = (options) => {
+    const { basePayload, apiPayload, hackerScripts } = options;
+    return `
+<script>
+(function(){
+  const baseUrl = ${basePayload};
+  const apiUrl = ${apiPayload};
+  const resourcesPathUrl = "/resources_path.json";
+  const __pagepocketOriginalFetch = window.fetch ? window.fetch.bind(window) : null;
+
+${resourceProxyScript}
+
+  const loadResourcesPath = async () => {
+    try {
+      const injected = window && window.__pagepocketResourcesPath;
+      if (injected && injected.version === "1.0" && Array.isArray(injected.items)) {
+        return injected;
+      }
+
+      if (!__pagepocketOriginalFetch) {
+        throw new Error("Fetch is unavailable");
+      }
+      const response = await __pagepocketOriginalFetch(resourcesPathUrl);
+      if (!response.ok) {
+        throw new Error("Failed to load resources_path.json");
+      }
+      const json = await response.json();
+      if (!json || json.version !== "1.0" || !Array.isArray(json.items)) {
+        throw new Error("Invalid resources_path.json");
+      }
+      return json;
+    } catch {
+      return { version: "1.0", createdAt: 0, items: [] };
+    }
+  };
+
+  const loadApiSnapshot = async () => {
+    try {
+      const injected = window && window.__pagepocketApiSnapshot;
+      if (injected && injected.version === "1.0" && Array.isArray(injected.records)) {
+        return injected;
+      }
+
+      if (!__pagepocketOriginalFetch) {
+        throw new Error("Fetch is unavailable");
+      }
+      const response = await __pagepocketOriginalFetch(apiUrl);
+      if (!response.ok) {
+        throw new Error("Failed to load api.json");
+      }
+      return await response.json();
+    } catch {
+      return { version: "1.0", url: baseUrl, createdAt: 0, records: [] };
+    }
+  };
+
+  const originalResponseJson = Response && Response.prototype && Response.prototype.json;
+  if (originalResponseJson) {
+    Response.prototype.json = function(...args) {
+      try {
+        return originalResponseJson.apply(this, args).catch(() => null);
+      } catch {
+        return Promise.resolve(null);
+      }
+    };
+  }
+
+  const ensureReplayPatches = () => {
+    try {
+      if (!window.fetch.__pagepocketOriginal && typeof __pagepocketOriginalFetch === "function") {
+        window.fetch.__pagepocketOriginal = __pagepocketOriginalFetch;
+      }
+    } catch {}
+    try {
+      if (!XMLHttpRequest.prototype.send.__pagepocketOriginal) {
+        XMLHttpRequest.prototype.send.__pagepocketOriginal = XMLHttpRequest.prototype.send;
+      }
+    } catch {}
+  };
+
+  let records = [];
+  const byKey = new Map();
+
+  let resourceIndex = null;
+  let embeddedByPath = new Map();
+  const blobUrlByPath = new Map();
+
+  const normalizeUrl = (input) => {
+    try { return new URL(input, baseUrl).toString(); } catch { return input; }
+  };
+
+  const normalizeBody = (body) => {
+    if (body === undefined || body === null) return "";
+    if (typeof body === "string") return body;
+    try { return String(body); } catch { return ""; }
+  };
+
+  const makeKey = (method, url, body) => method.toUpperCase() + " " + normalizeUrl(url) + " " + normalizeBody(body);
+  const makeVariantKeys = (method, url, body) => [makeKey(method, url, body)];
+
+  const matchAPI = ${matchAPISource};
+
+  const primeLookups = (snapshot) => {
+    records = snapshot.records || [];
+    byKey.clear();
+    for (const record of records) {
+      if (!record || !record.url || !record.method) continue;
+      const keys = makeVariantKeys(record.method, record.url, record.requestBody || record.requestBodyBase64 || "");
+      for (const key of keys) {
+        if (!byKey.has(key)) {
+          byKey.set(key, record);
+        }
+      }
+    }
+  };
+
+  const ready = (async () => {
+    const [apiSnapshot, resourcesPath] = await Promise.all([loadApiSnapshot(), loadResourcesPath()]);
+    resourceIndex = __pagepocketResourceProxy.buildIndex(resourcesPath || {});
+
+    embeddedByPath = new Map();
+    try {
+      const items = (resourcesPath && resourcesPath.items) || [];
+      for (const item of items) {
+        if (!item || !item.path || !item.data || item.dataEncoding !== "base64") {
+          continue;
+        }
+        embeddedByPath.set(item.path, item);
+      }
+    } catch {}
+
+    const snapshot = apiSnapshot || {};
+    primeLookups(snapshot);
+    return snapshot;
+  })();
+
+  const isLocalResource = (value) => {
+    if (!value) return false;
+    if (value.startsWith("data:") || value.startsWith("blob:")) return true;
+    // Protocol-relative URLs ("//host/path") are NOT local paths.
+    // Treat them as absolute URLs so they can be mapped via resources_path.json.
+    if (value.startsWith("//")) return false;
+    if (value.startsWith("/")) return true;
+    return false;
+  };
+
+  const findRecord = (method, url, body) => {
+    return matchAPI({ records, byKey, baseUrl, method, url, body });
+  };
+
+  const urlLookupCache = new Map();
+  const findByUrl = (url) => {
+    if (isLocalResource(url)) return null;
+    if (urlLookupCache.has(url)) {
+      return urlLookupCache.get(url);
+    }
+    const record = matchAPI({ records, byKey, baseUrl, method: "GET", url, body: "" });
+    urlLookupCache.set(url, record || null);
+    return record;
+  };
+
+  const findLocalPath = (url) => {
+    try {
+      if (!url || isLocalResource(String(url))) {
+        return null;
+      }
+      if (!resourceIndex) {
+        return null;
+      }
+
+      const resolvedPath = __pagepocketResourceProxy.resolveToLocalPath(String(url), baseUrl, resourceIndex);
+      if (!resolvedPath) {
+        return null;
+      }
+
+      const embedded = embeddedByPath && embeddedByPath.get(resolvedPath);
+      if (embedded && embedded.dataEncoding === "base64" && embedded.data) {
+        if (blobUrlByPath.has(resolvedPath)) {
+          return blobUrlByPath.get(resolvedPath);
+        }
+
+        const binary = atob(embedded.data);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i += 1) {
+          bytes[i] = binary.charCodeAt(i);
+        }
+
+        const mime = embedded.mimeType || "application/octet-stream";
+        const blob = new Blob([bytes], { type: mime });
+        const blobUrl = URL.createObjectURL(blob);
+        blobUrlByPath.set(resolvedPath, blobUrl);
+        return blobUrl;
+      }
+
+      return resolvedPath;
+    } catch {
+      return null;
+    }
+  };
+
+  /**
+   * Rewrite a resource URL to a snapshot-local URL.
+   *
+   * Strategy (in order):
+   * 1) If already local (data:/blob:/absolute path), keep as-is.
+   * 2) If resources_path.json can map it to a local file, return that path.
+   * 3) Otherwise, if we have a recorded body for the URL, return a data: URL
+   *    (used as a placeholder for some resource types).
+   * 4) Otherwise, keep the original URL.
+   */
+  const rewriteResourceUrl = (value, ctx) => {
+    try {
+      const raw = String(value || "");
+      if (!raw) {
+        return raw;
+      }
+
+      if (isLocalResource(raw)) {
+        return raw;
+      }
+
+      const localPath = findLocalPath(raw);
+      if (localPath) {
+        return localPath;
+      }
+
+      const fallbackType = ctx && ctx.fallbackType ? String(ctx.fallbackType) : undefined;
+      const record = findByUrl(raw);
+      if (record) {
+        const dataUrl = toDataUrl(record, fallbackType);
+        if (dataUrl) {
+          return dataUrl;
+        }
+      }
+
+      return raw;
+    } catch {
+      try {
+        return String(value || "");
+      } catch {
+        return value;
+      }
+    }
+  };
+
+  const defineProp = (obj, key, value) => {
+    try {
+      Object.defineProperty(obj, key, { value, configurable: true });
+    } catch {}
+  };
+
+  const decodeBase64 = (input) => {
+    try {
+      const binary = atob(input || "");
+      const bytes = new Uint8Array(binary.length);
+      Array.from(binary).forEach((char, index) => {
+        bytes[index] = char.charCodeAt(0);
+      });
+      return bytes;
+    } catch {
+      return new Uint8Array();
+    }
+  };
+
+  const bytesToBase64 = (bytes) => {
+    const binary = Array.from(bytes, (value) => String.fromCharCode(value)).join("");
+    return btoa(binary);
+  };
+
+  const textToBase64 = (text) => {
+    try {
+      const bytes = new TextEncoder().encode(text || "");
+      return bytesToBase64(bytes);
+    } catch {
+      return btoa(text || "");
+    }
+  };
+
+  const getContentType = (record) => {
+    const headers = record.responseHeaders || {};
+    for (const key in headers) {
+      if (key.toLowerCase() === "content-type") {
+        return headers[key] || "application/octet-stream";
+      }
+    }
+    return "application/octet-stream";
+  };
+
+  const dataUrlCache = new Map();
+  const toDataUrl = (record, fallbackType) => {
+    if (!record) return "";
+    const contentType = getContentType(record) || fallbackType || "application/octet-stream";
+    const cacheKey = (record.url || "") + "|" + contentType + "|" + (record.responseEncoding || "") + "|" +
+      (record.responseBodyBase64 ? "b64:" + record.responseBodyBase64.length : "txt:" + (record.responseBody ? record.responseBody.length : 0));
+    if (dataUrlCache.has(cacheKey)) {
+      return dataUrlCache.get(cacheKey);
+    }
+    if (record.responseEncoding === "base64" && record.responseBodyBase64) {
+      const dataUrl = "data:" + contentType + ";base64," + record.responseBodyBase64;
+      dataUrlCache.set(cacheKey, dataUrl);
+      return dataUrl;
+    }
+    if (record.responseBody) {
+      const dataUrl = "data:" + contentType + ";base64," + textToBase64(record.responseBody);
+      dataUrlCache.set(cacheKey, dataUrl);
+      return dataUrl;
+    }
+    const dataUrl = "data:" + (fallbackType || "application/octet-stream") + ",";
+    dataUrlCache.set(cacheKey, dataUrl);
+    return dataUrl;
+  };
+
+  const responseFromRecord = (record) => {
+    const headers = new Headers(record.responseHeaders || {});
+    if (record.responseEncoding === "base64" && record.responseBodyBase64) {
+      const bytes = decodeBase64(record.responseBodyBase64);
+      return new Response(bytes, {
+        status: record.status || 200,
+        statusText: record.statusText || "OK",
+        headers
+      });
+    }
+    const bodyText = record.responseBody || "";
+    return new Response(bodyText, {
+      status: record.status || 200,
+      statusText: record.statusText || "OK",
+      headers
+    });
+  };
+
+${hackerScripts}
+})();
+</script>
+`;
+};

package/dist/replay/templates/resource-proxy-script.d.ts

@@ -0,0 +1 @@
+export declare const resourceProxyScript = "\n  const __pagepocketResourceProxy = (() => {\n    const stripHash = (value) => {\n      const input = String(value || \"\");\n      const index = input.indexOf(\"#\");\n      return index === -1 ? input : input.slice(0, index);\n    };\n\n    const stripTrailingSlash = (value) => {\n      const input = String(value || \"\");\n      if (!input || input === \"/\") return input;\n      return input.endsWith(\"/\") ? input.slice(0, -1) : input;\n    };\n\n    const looksAlreadyEscapedForStaticServers = (value) => {\n      return /%25[0-9a-fA-F]{2}/.test(String(value || \"\"));\n    };\n\n    const escapePercentForStaticServersOnce = (value) => {\n      const input = String(value || \"\");\n      if (!input) return input;\n      if (looksAlreadyEscapedForStaticServers(input)) return input;\n      return input.split(\"%\").join(\"%25\");\n    };\n\n    const isLikelyHostname = (value) => {\n      const input = String(value || \"\");\n      if (!input) return false;\n      if (input === \"localhost\") return true;\n      return input.includes(\".\");\n    };\n\n    const encodeEmbeddedUrlTailIfPresent = (pathname) => {\n      const raw = String(pathname || \"\");\n      if (!raw.includes(\"/http\")) return null;\n      const parts = raw.split(\"/\");\n      for (let i = 0; i < parts.length; i += 1) {\n        const scheme = parts[i];\n        if (scheme !== \"http:\" && scheme !== \"https:\") continue;\n        const hasDoubleSlash = parts[i + 1] === \"\";\n        const host = parts[i + 2] || \"\";\n        if (!hasDoubleSlash || !isLikelyHostname(host)) continue;\n        const embedded = scheme + \"//\" + parts.slice(i + 2).join(\"/\");\n        const encoded = encodeURIComponent(embedded);\n        const nextParts = parts.slice(0, i).concat(encoded);\n        const rebuilt = nextParts.join(\"/\") || \"/\";\n        return rebuilt.startsWith(\"/\") ? rebuilt : \"/\" + rebuilt;\n      }\n      return null;\n    };\n\n    const makePathnameVariants = (pathname) => {\n      const variants = new Set();\n      const push = (value) => {\n        if (!value) return;\n        variants.add(value);\n      };\n\n      const raw = String(pathname || \"\");\n      push(raw);\n      push(stripTrailingSlash(raw));\n\n      const encodedTail = encodeEmbeddedUrlTailIfPresent(raw);\n      if (encodedTail && encodedTail !== raw) {\n        push(encodedTail);\n        push(stripTrailingSlash(encodedTail));\n      }\n\n      return Array.from(variants);\n    };\n\n    const toUrlOrNull = (value, base) => {\n      try {\n        return new URL(String(value || \"\"), String(base || \"\"));\n      } catch {\n        return null;\n      }\n    };\n\n    const getBasename = (pathname) => {\n      const clean = String(pathname || \"\").split(\"?\")[0] || \"\";\n      const parts = clean.split(\"/\").filter(Boolean);\n      return parts[parts.length - 1] || \"\";\n    };\n\n    const makeSuffixes = (pathname) => {\n      const parts = String(pathname || \"\").split(\"/\").filter(Boolean);\n      const out = [];\n      for (let i = 0; i < parts.length; i += 1) {\n        out.push({ key: \"/\" + parts.slice(i).join(\"/\"), depth: parts.length - i });\n      }\n      return out;\n    };\n\n    const toArray = (value) => {\n      if (!value) return [];\n      return Array.isArray(value) ? value : [value];\n    };\n\n    const addMulti = (map, key, value) => {\n      const existing = map.get(key);\n      if (!existing) {\n        map.set(key, value);\n        return;\n      }\n      if (Array.isArray(existing)) {\n        existing.push(value);\n        return;\n      }\n      map.set(key, [existing, value]);\n    };\n\n    const uniqByPath = (items) => {\n      const seen = new Set();\n      const out = [];\n      for (const item of items || []) {\n        const p = item && item.path;\n        if (!p || seen.has(p)) continue;\n        seen.add(p);\n        out.push(item);\n      }\n      return out;\n    };\n\n    const chooseUnique = (items, baseUrl, depth) => {\n      const unique = uniqByPath(items);\n      if (unique.length === 0) return null;\n      if (unique.length === 1) return unique[0];\n\n      try {\n        const base = new URL(String(baseUrl || \"\"));\n        const sameOrigin = unique.filter((i) => i && i.origin === base.origin);\n        if (sameOrigin.length === 1) {\n          return sameOrigin[0];\n        }\n        if (sameOrigin.length > 1) {\n          items = sameOrigin;\n        }\n      } catch {}\n\n      if (depth < 2) {\n        return null;\n      }\n\n      return null;\n    };\n\n    const buildIndex = (snapshot) => {\n      const byExactUrl = new Map();\n      const byCanonicalUrl = new Map();\n      const byPathnameWithSearch = new Map();\n      const byPathname = new Map();\n      const byBasename = new Map();\n\n      const canonicalizeHttpUrlForIndex = (url) => {\n        try {\n          if (!url || !url.protocol) return String(url || \"\");\n          if (url.protocol === \"http:\" || url.protocol === \"https:\") {\n            return \"//\" + url.host + (url.pathname || \"\") + (url.search || \"\");\n          }\n          return url.toString();\n        } catch {\n          return String(url || \"\");\n        }\n      };\n\n      for (const item of (snapshot && snapshot.items) || []) {\n        if (!item || !item.url || !item.path) continue;\n        let parsed = null;\n        try {\n          parsed = new URL(item.url);\n        } catch {\n          parsed = null;\n        }\n        if (!parsed) continue;\n\n        const pathname = parsed.pathname || \"/\";\n        const pathnameWithSearch = pathname + (parsed.search || \"\");\n        const basename = getBasename(pathname);\n\n        const indexed = {\n          url: parsed.toString(),\n          canonicalUrl: canonicalizeHttpUrlForIndex(parsed),\n          origin: parsed.origin,\n          pathname,\n          pathnameWithSearch,\n          basename,\n          path: item.path,\n          resourceType: item.resourceType,\n          mimeType: item.mimeType,\n          size: item.size\n        };\n\n        if (!byExactUrl.has(indexed.url)) {\n          byExactUrl.set(indexed.url, indexed);\n        }\n\n        if (!byCanonicalUrl.has(indexed.canonicalUrl)) {\n          byCanonicalUrl.set(indexed.canonicalUrl, indexed);\n        }\n        addMulti(byPathnameWithSearch, pathnameWithSearch, indexed);\n        addMulti(byPathname, pathname, indexed);\n        if (basename) {\n          addMulti(byBasename, basename, indexed);\n        }\n      }\n\n      return { byExactUrl, byCanonicalUrl, byPathnameWithSearch, byPathname, byBasename };\n    };\n\n    const resolveToLocalPath = (requestUrl, baseUrl, index) => {\n      if (!requestUrl) return null;\n      const abs = toUrlOrNull(String(requestUrl), baseUrl);\n      if (!abs) return null;\n\n      const absString = abs.toString();\n      const exact = index && index.byExactUrl && index.byExactUrl.get(absString);\n      if (exact) return escapePercentForStaticServersOnce(exact.path);\n\n      const canonicalAbs = \"//\" + abs.host + (abs.pathname || \"\") + (abs.search || \"\");\n      const canonicalExact = index && index.byCanonicalUrl && index.byCanonicalUrl.get(canonicalAbs);\n      if (canonicalExact) return escapePercentForStaticServersOnce(canonicalExact.path);\n\n      const withoutHash = stripHash(absString);\n      if (withoutHash !== absString) {\n        const found = index.byExactUrl.get(withoutHash);\n        if (found) return escapePercentForStaticServersOnce(found.path);\n\n        try {\n          const w = new URL(withoutHash);\n          const canonicalWithoutHash = \"//\" + w.host + (w.pathname || \"\") + (w.search || \"\");\n          const canonicalFound = index && index.byCanonicalUrl && index.byCanonicalUrl.get(canonicalWithoutHash);\n          if (canonicalFound) return escapePercentForStaticServersOnce(canonicalFound.path);\n        } catch {}\n      }\n\n      const pathname = abs.pathname || \"/\";\n      const pathnameVariants = makePathnameVariants(pathname);\n      const search = abs.search || \"\";\n      const pathnameWithSearchVariants = pathnameVariants.map((p) => String(p) + search);\n\n      for (const key of pathnameWithSearchVariants) {\n        const items = toArray(index.byPathnameWithSearch.get(key));\n        const chosen = chooseUnique(items, baseUrl, 99);\n        if (chosen) return escapePercentForStaticServersOnce(chosen.path);\n      }\n\n      for (const key of pathnameVariants) {\n        const items = toArray(index.byPathname.get(key));\n        const chosen = chooseUnique(items, baseUrl, 99);\n        if (chosen) return escapePercentForStaticServersOnce(chosen.path);\n      }\n\n      for (const variant of pathnameVariants) {\n        for (const suffix of makeSuffixes(variant)) {\n          const items = toArray(index.byPathname.get(suffix.key));\n          const chosen = chooseUnique(items, baseUrl, suffix.depth);\n          if (chosen) return escapePercentForStaticServersOnce(chosen.path);\n        }\n      }\n\n      const basename = getBasename(pathname);\n      if (basename) {\n        const items = toArray(index.byBasename.get(basename));\n        const chosen = chooseUnique(items, baseUrl, 1);\n        if (chosen) return escapePercentForStaticServersOnce(chosen.path);\n      }\n\n      return null;\n    };\n\n    return { buildIndex, resolveToLocalPath };\n  })();\n";