@pagepocket/lib 0.7.0 → 0.8.0

package/dist/rewrite-links.js

@@ -1,238 +1,30 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rewriteEntryHtml = exports.rewriteJsText = void 0;
-const cheerio = __importStar(require("cheerio"));
-const css_rewrite_1 = require("./css-rewrite");
-const hack_html_1 = require("./hack-html");
-const replace_elements_1 = require("./replace-elements");
-const shouldSkipValue = (value) => {
-    const trimmed = value.trim();
-    return (!trimmed ||
-        trimmed.startsWith("data:") ||
-        trimmed.startsWith("blob:") ||
-        trimmed.startsWith("mailto:") ||
-        trimmed.startsWith("tel:") ||
-        trimmed.startsWith("javascript:") ||
-        trimmed.startsWith("#"));
-};
-const resolveUrlValue = (value, baseUrl, resolve) => {
-    if (shouldSkipValue(value)) {
-        return null;
-    }
-    try {
-        const absolute = new URL(value, baseUrl).toString();
-        return resolve(absolute);
-    }
-    catch {
-        return null;
-    }
-};
-const isUnsafeSrcsetValue = (value) => {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return false;
-    }
-    // Some sites (notably Substack) emit image transform URLs that contain commas
-    // inside the URL itself (e.g. "/image/fetch/...,$w_40,$h_40,.../https%3A...").
-    //
-    // In the HTML srcset grammar, commas separate candidates, so unescaped commas
-    // inside a URL make the srcset invalid. Browsers will parse it into garbage
-    // URLs like "https%3A%2F%2F...png" and try to fetch them.
-    //
-    // For offline snapshots, it's better to drop srcset entirely and rely on
-    // the already-rewritten img[src].
-    const hasFetchTransform = trimmed.includes("/image/fetch/");
-    const hasEncodedUrlTail = trimmed.includes("https%3A%2F%2F");
-    const hasCommaTokens = trimmed.includes(",w_") ||
-        trimmed.includes(", w_") ||
-        trimmed.includes(",h_") ||
-        trimmed.includes(", h_") ||
-        trimmed.includes(",c_") ||
-        trimmed.includes(", c_");
-    return hasFetchTransform && hasEncodedUrlTail && hasCommaTokens;
-};
-const isDescriptorToken = (token) => {
-    const trimmed = token.trim();
-    if (!trimmed)
-        return false;
-    // Common srcset descriptors: 1x, 2x, 320w
-    return /^\d+(\.\d+)?x$/i.test(trimmed) || /^\d+w$/i.test(trimmed);
-};
-const parseSrcset = (input) => {
-    // Minimal srcset parser:
-    // - Candidates are separated by commas.
-    // - Each candidate is "<url> [descriptor]".
-    // - URLs may contain spaces/commas (e.g. CDN transform strings). To avoid
-    //   breaking those, we locate the descriptor from the *end* of the candidate.
-    const rawCandidates = input
-        .split(",")
-        .map((c) => c.trim())
-        .filter(Boolean);
-    return rawCandidates.map((candidate) => {
-        const tokens = candidate.split(/\s+/).filter(Boolean);
-        if (tokens.length === 0) {
-            return { url: candidate };
-        }
-        const last = tokens[tokens.length - 1] ?? "";
-        if (tokens.length >= 2 && isDescriptorToken(last)) {
-            const descriptor = last;
-            const url = candidate.slice(0, candidate.lastIndexOf(descriptor)).trim();
-            return { url, descriptor };
-        }
-        return { url: candidate };
-    });
-};
-const stringifySrcset = (candidates) => {
-    return (candidates
-        .map((c) => {
-        const url = c.url.trim();
-        if (!c.descriptor)
-            return url;
-        return `${url} ${c.descriptor.trim()}`;
-    })
-        .filter(Boolean)
-        // Don't introduce spaces after commas inside URL tokens.
-        .join(","));
-};
-const rewriteSrcsetValue = (value, baseUrl, resolve) => {
-    if (isUnsafeSrcsetValue(value)) {
-        return "";
-    }
-    const candidates = parseSrcset(value);
-    const rewritten = candidates.map((c) => {
-        const resolved = resolveUrlValue(c.url, baseUrl, resolve);
-        return { url: resolved ?? c.url, descriptor: c.descriptor };
-    });
-    return stringifySrcset(rewritten);
-};
-const rewriteMetaRefresh = (content, baseUrl, resolve) => {
-    const parts = content.split(";");
-    if (parts.length < 2)
-        return content;
-    const urlPartIndex = parts.findIndex((part) => part.trim().toLowerCase().startsWith("url="));
-    if (urlPartIndex === -1)
-        return content;
-    const urlPart = parts[urlPartIndex];
-    let rawUrl = urlPart.split("=").slice(1).join("=").trim();
-    // Some pages quote the URL value (url="/next" or url='/next').
-    // Strip a single pair of surrounding quotes to improve rewrite coverage.
-    if ((rawUrl.startsWith('"') && rawUrl.endsWith('"')) ||
-        (rawUrl.startsWith("'") && rawUrl.endsWith("'"))) {
-        rawUrl = rawUrl.slice(1, -1).trim();
-    }
-    const resolved = resolveUrlValue(rawUrl, baseUrl, resolve);
-    if (!resolved)
-        return content;
-    const next = `url=${resolved}`;
-    const nextParts = parts.slice();
-    nextParts[urlPartIndex] = next;
-    return nextParts.join(";");
-};
-const shouldRewriteLinkHref = ($element) => {
-    const rel = ($element.attr("rel") || "").trim().toLowerCase();
-    if (!rel) {
-        return true;
-    }
-    // Only rewrite link rels that are expected to load a resource.
-    // Avoid rewriting navigational/SEO links like canonical, preconnect, etc.
-    return (rel.includes("stylesheet") ||
-        rel.includes("preload") ||
-        rel.includes("prefetch") ||
-        rel.includes("icon"));
-};
-const rewriteJsText = async (source, resolve, baseUrl) => {
-    const replaceSpecifier = async (specifier) => {
-        const trimmed = specifier.trim();
-        if (shouldSkipValue(trimmed)) {
-            return specifier;
-        }
-        const resolved = resolveUrlValue(trimmed, baseUrl, resolve);
-        return resolved ?? specifier;
-    };
-    const importFromPattern = /(\bimport\s+[^'"]*?\sfrom\s+)(["'])([^"']+)\2/g;
-    const importSideEffectPattern = /(\bimport\s+)(["'])([^"']+)\2/g;
-    const dynamicImportPattern = /(\bimport\s*\(\s*)(["'])([^"']+)\2(\s*\))/g;
-    let replaced = "";
-    let lastIndex = 0;
-    for (const match of source.matchAll(importFromPattern)) {
-        const index = match.index ?? 0;
-        replaced += source.slice(lastIndex, index);
-        const prefix = match[1] || "";
-        const quote = match[2] || "";
-        const specifier = match[3] || "";
-        const next = await replaceSpecifier(specifier);
-        replaced += `${prefix}${quote}${next}${quote}`;
-        lastIndex = index + match[0].length;
-    }
-    replaced += source.slice(lastIndex);
-    let final = "";
-    lastIndex = 0;
-    for (const match of replaced.matchAll(importSideEffectPattern)) {
-        const index = match.index ?? 0;
-        final += replaced.slice(lastIndex, index);
-        const prefix = match[1] || "";
-        const quote = match[2] || "";
-        const specifier = match[3] || "";
-        const next = await replaceSpecifier(specifier);
-        final += `${prefix}${quote}${next}${quote}`;
-        lastIndex = index + match[0].length;
-    }
-    final += replaced.slice(lastIndex);
-    let dynamicFinal = "";
-    lastIndex = 0;
-    for (const match of final.matchAll(dynamicImportPattern)) {
-        const index = match.index ?? 0;
-        dynamicFinal += final.slice(lastIndex, index);
-        const prefix = match[1] || "";
-        const quote = match[2] || "";
-        const specifier = match[3] || "";
-        const suffix = match[4] || "";
-        const next = await replaceSpecifier(specifier);
-        dynamicFinal += `${prefix}${quote}${next}${quote}${suffix}`;
-        lastIndex = index + match[0].length;
-    }
-    dynamicFinal += final.slice(lastIndex);
-    return dynamicFinal;
-};
-exports.rewriteJsText = rewriteJsText;
-const rewriteEntryHtml = async (input) => {
-    const $ = cheerio.load(input.html);
+import * as cheerio from "cheerio";
+import { rewriteCssText } from "./css-rewrite.js";
+import { hackHtml } from "./hack-html.js";
+import { applyReplaceElements } from "./replace-elements.js";
+import { rewriteJsText } from "./rewrite-links/js-imports.js";
+import { shouldRewriteLinkHref } from "./rewrite-links/link-rel.js";
+import { rewriteMetaRefresh } from "./rewrite-links/meta-refresh.js";
+import { rewriteSrcsetValue } from "./rewrite-links/srcset.js";
+import { resolveUrlValue } from "./rewrite-links/url-resolve.js";
+export { rewriteJsText };
+export const rewriteEntryHtml = async (input) => {
     const baseUrl = input.entryUrl;
     const resolve = input.resolve;
     const shouldRewriteLinks = input.rewriteLinks !== false;
+    if (input.html.includes("__pagepocketPatched") ||
+        input.html.includes("__pagepocketOriginalFetch")) {
+        const $title = cheerio.load(input.html)("title").first().text() || undefined;
+        return { html: input.html, title: $title };
+    }
+    const hasPreloadMarker = input.html.includes("__pagepocketPatched");
+    const hasReplayMarker = input.html.includes("__pagepocketOriginalFetch");
+    const hasReplaceElements = Array.isArray(input.replaceElements) && input.replaceElements.length > 0;
+    if (!shouldRewriteLinks && !hasReplaceElements && hasPreloadMarker && hasReplayMarker) {
+        const $title = cheerio.load(input.html)("title").first().text() || undefined;
+        return { html: input.html, title: $title };
+    }
+    const $ = cheerio.load(input.html);
     const rewriteAttr = (selector, attr) => {
         $(selector).each((_, element) => {
             const value = $(element).attr(attr);
@@ -304,7 +96,7 @@ const rewriteEntryHtml = async (input) => {
             const cssText = $(element).html();
             if (!cssText)
                 continue;
-            const rewritten = await (0, css_rewrite_1.rewriteCssText)({
+            const rewritten = await rewriteCssText({
                 cssText,
                 cssUrl: baseUrl,
                 resolveUrl: resolve
@@ -318,7 +110,7 @@ const rewriteEntryHtml = async (input) => {
             const styleText = $(element).attr("style");
             if (!styleText)
                 continue;
-            const rewritten = await (0, css_rewrite_1.rewriteCssText)({
+            const rewritten = await rewriteCssText({
                 cssText: styleText,
                 cssUrl: baseUrl,
                 resolveUrl: resolve
@@ -337,18 +129,18 @@ const rewriteEntryHtml = async (input) => {
             const original = $(element).html();
             if (!original)
                 continue;
-            const rewritten = await (0, exports.rewriteJsText)(original, resolve, baseUrl);
+            const rewritten = await rewriteJsText(original, resolve, baseUrl);
             if (rewritten !== original) {
                 $(element).html(rewritten);
             }
         }
     }
-    (0, hack_html_1.hackHtml)({
+    hackHtml({
         $,
-        baseUrl: baseUrl,
+        baseUrl,
         apiPath: input.apiPath
     });
-    await (0, replace_elements_1.applyReplaceElements)({
+    await applyReplaceElements({
         $,
         entryUrl: input.snapshotEntryUrl ?? baseUrl,
         url: baseUrl,
@@ -356,6 +148,5 @@ const rewriteEntryHtml = async (input) => {
         isEntryDocument: input.isEntryDocument ?? true
     });
     const title = $("title").first().text() || undefined;
-    return { html: $.html(), title };
+    return { html: `${$.html()}\n`, title };
 };
-exports.rewriteEntryHtml = rewriteEntryHtml;

package/dist/snapshot-builder/api.d.ts

@@ -0,0 +1,3 @@
+import type { ApiSnapshot } from "../types.js";
+import type { ApiEntry } from "./types.js";
+export declare const buildApiSnapshot: (url: string, createdAt: number, entries: ApiEntry[]) => ApiSnapshot;

package/dist/snapshot-builder/api.js

@@ -0,0 +1,6 @@
+export const buildApiSnapshot = (url, createdAt, entries) => ({
+    version: "1.0",
+    url,
+    createdAt,
+    records: entries.map((entry) => entry.record)
+});

package/dist/snapshot-builder/build-snapshot.d.ts

@@ -0,0 +1,3 @@
+import type { FileTree } from "../core/file-tree.js";
+import type { BuildOptions } from "./types.js";
+export declare const buildSnapshot: (input: BuildOptions) => Promise<FileTree>;

package/dist/snapshot-builder/build-snapshot.js

@@ -0,0 +1,138 @@
+import { createDefaultPathResolver, resolveCrossOrigin, withPrefixPathResolver } from "../path-resolver.js";
+import { ensureLeadingSlash, sanitizePosixPath } from "../utils.js";
+import { buildApiSnapshot } from "./api.js";
+import { indexCapture } from "./capture-index/index.js";
+import { emitDocumentFile } from "./emit-document.js";
+import { groupResources } from "./grouping.js";
+import { responseMimeType } from "./http.js";
+import { docDirFromUrl, resolveSnapshotPath } from "./path-map.js";
+import { buildResourcesPathSnapshot } from "./resources-path.js";
+import { maybeRewriteScript, maybeRewriteStylesheet } from "./rewrite-resource.js";
+// NOTE: helpers were extracted into snapshot-builder/* modules.
+export const buildSnapshot = async (input) => {
+    const warnings = input.warnings;
+    const contentStore = input.capture.contentStore;
+    const indexed = await indexCapture({
+        capture: input.capture,
+        filter: input.filter,
+        limits: input.limits,
+        warnings
+    });
+    const groups = groupResources({
+        entryUrl: input.entryUrl,
+        resources: indexed.resources,
+        apiEntries: indexed.apiEntries,
+        warnings
+    });
+    const multiDoc = groups.length > 1;
+    const files = [];
+    let entryPath = "";
+    for (const group of groups) {
+        const docDir = multiDoc ? docDirFromUrl(group.url) : "";
+        const baseResolver = input.pathResolver ?? createDefaultPathResolver();
+        const resolver = multiDoc ? withPrefixPathResolver(baseResolver, docDir) : baseResolver;
+        const urlToPath = new Map();
+        for (const resource of group.resources) {
+            const path = resolver.resolve({
+                url: resource.request.url,
+                resourceType: resource.request.resourceType,
+                mimeType: resource.mimeType,
+                suggestedFilename: undefined,
+                isCrossOrigin: resolveCrossOrigin(resource.request.url, group.url),
+                entryUrl: group.url
+            });
+            urlToPath.set(resource.request.url, path);
+        }
+        const resolve = (absoluteUrl) => resolveSnapshotPath(urlToPath, absoluteUrl);
+        const apiPath = ensureLeadingSlash(multiDoc ? `${sanitizePosixPath(docDir)}/api.json` : "/api.json");
+        for (const resource of group.resources) {
+            if (resource.request.resourceType === "document") {
+                const path = urlToPath.get(resource.request.url) ?? "/index.html";
+                const { file } = await emitDocumentFile({
+                    resource,
+                    path,
+                    entryUrl: input.entryUrl,
+                    groupUrl: group.url,
+                    apiPath,
+                    resolve,
+                    rewriteEntry: input.rewriteEntry,
+                    replaceElements: input.replaceElements,
+                    contentStore,
+                    snapshotEntryUrl: input.entryUrl
+                });
+                files.push(file);
+                if (resource.request.url === input.entryUrl || !entryPath) {
+                    entryPath = path;
+                }
+                continue;
+            }
+            const afterCss = await maybeRewriteStylesheet({
+                resource,
+                resolve,
+                contentStore,
+                rewriteCSS: input.rewriteCSS
+            });
+            const afterJs = await maybeRewriteScript({
+                resource: { ...resource, contentRef: afterCss.contentRef, size: afterCss.size },
+                resolve,
+                contentStore
+            });
+            const path = urlToPath.get(resource.request.url) ??
+                resolver.resolve({
+                    url: resource.request.url,
+                    resourceType: resource.request.resourceType,
+                    mimeType: resourceMimeType(resource),
+                    suggestedFilename: undefined,
+                    isCrossOrigin: resolveCrossOrigin(resource.request.url, group.url),
+                    entryUrl: group.url
+                });
+            files.push({
+                path,
+                mimeType: resourceMimeType(resource),
+                size: afterJs.size,
+                source: afterJs.contentRef,
+                originalUrl: resource.request.url,
+                resourceType: resource.request.resourceType,
+                headers: resource.response.headers
+            });
+        }
+        const apiSnapshot = buildApiSnapshot(group.url, input.createdAt, group.apiEntries);
+        const apiBytes = new TextEncoder().encode(`${JSON.stringify(apiSnapshot, null, 2)}\n`);
+        const apiRef = await contentStore.put({ kind: "buffer", data: apiBytes }, { url: apiPath, mimeType: "application/json", sizeHint: apiBytes.byteLength });
+        files.push({
+            path: apiPath,
+            mimeType: "application/json",
+            size: apiBytes.byteLength,
+            source: apiRef,
+            originalUrl: apiPath
+        });
+    }
+    {
+        const resourcesPath = buildResourcesPathSnapshot(input.createdAt, files);
+        const bytes = new TextEncoder().encode(`${JSON.stringify(resourcesPath, null, 2)}\n`);
+        files.push({
+            path: "/resources_path.json",
+            mimeType: "application/json",
+            size: bytes.byteLength,
+            source: { kind: "memory", data: bytes }
+        });
+    }
+    return {
+        root: {
+            kind: "directory",
+            path: "",
+            entries: files.map((file) => ({
+                kind: "file",
+                path: file.path,
+                source: { kind: "content-ref", ref: file.source }
+            }))
+        },
+        content: {
+            open: (ref) => contentStore.open(ref),
+            dispose: async () => {
+                await contentStore.dispose?.();
+            }
+        }
+    };
+};
+const resourceMimeType = (resource) => resource.mimeType || responseMimeType(resource.response) || undefined;

package/dist/snapshot-builder/capture-index/index-capture.d.ts

@@ -0,0 +1,13 @@
+import type { CaptureArtifacts } from "../../core/capture/types.js";
+import type { ResourceFilter } from "../../types.js";
+import type { BuildLimits } from "../types.js";
+import type { ApiEntry, StoredResource } from "./types.js";
+export declare const indexCapture: (input: {
+    capture: CaptureArtifacts;
+    filter: ResourceFilter;
+    limits?: BuildLimits;
+    warnings: string[];
+}) => Promise<{
+    resources: StoredResource[];
+    apiEntries: ApiEntry[];
+}>;

package/dist/snapshot-builder/capture-index/index-capture.js

@@ -0,0 +1,168 @@
+import { streamToUint8Array } from "../../utils/streams.js";
+import { bodyToTextOrBase64 } from "../../utils.js";
+import { headersListToRecord, parseContentLength, responseMimeType } from "../http.js";
+const isApiResource = (request) => {
+    const type = request?.resourceType;
+    return type === "fetch" || type === "xhr";
+};
+const buildByRequestId = (events) => {
+    const byId = new Map();
+    const ensure = (requestId) => {
+        const existing = byId.get(requestId);
+        if (existing)
+            return existing;
+        const created = {};
+        byId.set(requestId, created);
+        return created;
+    };
+    for (const event of events) {
+        if (event.type === "http.request") {
+            ensure(event.requestId).request = event;
+            continue;
+        }
+        if (event.type === "http.response") {
+            ensure(event.requestId).response = event;
+            continue;
+        }
+        if (event.type === "http.failed") {
+            ensure(event.requestId).failed = event;
+        }
+    }
+    return byId;
+};
+export const indexCapture = async (input) => {
+    const byId = buildByRequestId(input.capture.events);
+    const resources = [];
+    const apiEntries = [];
+    const apiSeen = new Set();
+    let totalBytes = 0;
+    const recordApiFailure = (request, failed) => {
+        if (apiSeen.has(request.requestId))
+            return;
+        apiSeen.add(request.requestId);
+        apiEntries.push({
+            request,
+            record: {
+                url: request.url,
+                method: request.method,
+                requestHeaders: request.headers,
+                error: failed.errorText,
+                timestamp: failed.timestamp
+            }
+        });
+    };
+    const recordApiResponse = async (request, response, bodyRef) => {
+        if (apiSeen.has(request.requestId))
+            return;
+        apiSeen.add(request.requestId);
+        const record = {
+            url: request.url,
+            method: request.method,
+            requestHeaders: request.headers,
+            status: response.status,
+            statusText: response.statusText,
+            responseHeaders: response.headers,
+            timestamp: response.timestamp
+        };
+        if (bodyRef) {
+            const stream = await input.capture.contentStore.open(bodyRef);
+            const bytes = await streamToUint8Array(stream);
+            if (bytes.byteLength > 0) {
+                const mimeType = responseMimeType(response);
+                const decoded = bodyToTextOrBase64(bytes, mimeType);
+                if (decoded.encoding === "text") {
+                    record.responseBody = decoded.text;
+                    record.responseEncoding = "text";
+                }
+                else {
+                    record.responseBodyBase64 = decoded.base64;
+                    record.responseEncoding = "base64";
+                }
+            }
+        }
+        apiEntries.push({ request, record });
+    };
+    for (const record of byId.values()) {
+        if (!record.request || record.request.type !== "http.request") {
+            continue;
+        }
+        const requestEvent = record.request;
+        const request = {
+            type: "request",
+            requestId: requestEvent.requestId,
+            url: requestEvent.url,
+            method: requestEvent.method,
+            headers: headersListToRecord(requestEvent.headers),
+            timestamp: requestEvent.timestamp,
+            frameId: requestEvent.frameId,
+            resourceType: requestEvent.resourceType,
+            initiator: requestEvent.initiator
+        };
+        if (record.failed && record.failed.type === "http.failed") {
+            const failedEvent = record.failed;
+            const failed = {
+                type: "failed",
+                requestId: failedEvent.requestId,
+                url: failedEvent.url,
+                errorText: failedEvent.errorText,
+                timestamp: failedEvent.timestamp
+            };
+            if (isApiResource(request)) {
+                recordApiFailure(request, failed);
+            }
+            continue;
+        }
+        if (!record.response || record.response.type !== "http.response") {
+            continue;
+        }
+        const responseEvent = record.response;
+        const response = {
+            type: "response",
+            requestId: responseEvent.requestId,
+            url: responseEvent.url,
+            status: responseEvent.status,
+            statusText: responseEvent.statusText,
+            headers: headersListToRecord(responseEvent.headers),
+            timestamp: responseEvent.timestamp,
+            mimeType: responseEvent.mimeType,
+            fromDiskCache: responseEvent.fromDiskCache,
+            fromServiceWorker: responseEvent.fromServiceWorker,
+            body: undefined
+        };
+        const bodyRef = responseEvent.bodyRef;
+        if (isApiResource(request)) {
+            await recordApiResponse(request, response, bodyRef);
+        }
+        if (!input.filter.shouldSave(request, response)) {
+            continue;
+        }
+        if (!bodyRef) {
+            input.warnings.push(`Missing body for ${request.url}`);
+            continue;
+        }
+        const stream = await input.capture.contentStore.open(bodyRef);
+        const bytes = await streamToUint8Array(stream);
+        const byteLength = bytes.byteLength;
+        if (input.limits?.maxSingleResourceBytes && byteLength > input.limits.maxSingleResourceBytes) {
+            input.warnings.push(`Resource too large: ${request.url}`);
+            continue;
+        }
+        if (input.limits?.maxResources && resources.length >= input.limits.maxResources) {
+            input.warnings.push(`Resource limit reached at ${request.url}`);
+            continue;
+        }
+        if (input.limits?.maxTotalBytes && totalBytes + byteLength > input.limits.maxTotalBytes) {
+            input.warnings.push(`Total byte limit reached at ${request.url}`);
+            continue;
+        }
+        totalBytes += byteLength;
+        resources.push({
+            request,
+            response,
+            contentRef: bodyRef,
+            size: parseContentLength(response.headers || {}) ?? byteLength,
+            mimeType: responseMimeType(response)
+        });
+    }
+    return { resources, apiEntries };
+};

package/dist/snapshot-builder/capture-index/index.d.ts

@@ -0,0 +1,2 @@
+export { indexCapture } from "./index-capture.js";
+export type { ApiEntry, StoredResource } from "./types.js";

package/dist/snapshot-builder/capture-index/index.js

@@ -0,0 +1 @@
+export { indexCapture } from "./index-capture.js";

package/dist/snapshot-builder/capture-index/types.d.ts

@@ -0,0 +1,12 @@
+import type { ApiRecord, ContentRef, NetworkRequestEvent, NetworkResponseEvent } from "../../types.js";
+export type StoredResource = {
+    request: NetworkRequestEvent;
+    response: NetworkResponseEvent;
+    contentRef: ContentRef;
+    size: number;
+    mimeType?: string;
+};
+export type ApiEntry = {
+    record: ApiRecord;
+    request: NetworkRequestEvent;
+};

package/dist/snapshot-builder/capture-index/types.js

@@ -0,0 +1 @@
+export {};