@pagepocket/lib 0.7.1 → 0.8.1

package/dist/index.js

@@ -1,44 +1,23 @@
-"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyReplaceElements = exports.toZip = exports.writeToFS = exports.rewriteCssText = exports.rewriteJsText = exports.rewriteEntryHtml = exports.buildPreloadScript = exports.buildReplayScript = exports.timeout = exports.networkIdle = exports.createDefaultResourceFilter = exports.withPrefixPathResolver = exports.createDefaultPathResolver = exports.HybridContentStore = exports.PagePocket = void 0;
-var pagepocket_1 = require("./pagepocket");
-Object.defineProperty(exports, "PagePocket", { enumerable: true, get: function () { return pagepocket_1.PagePocket; } });
-var content_store_1 = require("./content-store");
-Object.defineProperty(exports, "HybridContentStore", { enumerable: true, get: function () { return content_store_1.HybridContentStore; } });
-var path_resolver_1 = require("./path-resolver");
-Object.defineProperty(exports, "createDefaultPathResolver", { enumerable: true, get: function () { return path_resolver_1.createDefaultPathResolver; } });
-Object.defineProperty(exports, "withPrefixPathResolver", { enumerable: true, get: function () { return path_resolver_1.withPrefixPathResolver; } });
-var resource_filter_1 = require("./resource-filter");
-Object.defineProperty(exports, "createDefaultResourceFilter", { enumerable: true, get: function () { return resource_filter_1.createDefaultResourceFilter; } });
-__exportStar(require("./builtin-blacklist"), exports);
-var completion_1 = require("./completion");
-Object.defineProperty(exports, "networkIdle", { enumerable: true, get: function () { return completion_1.networkIdle; } });
-Object.defineProperty(exports, "timeout", { enumerable: true, get: function () { return completion_1.timeout; } });
-var replay_script_1 = require("./replay-script");
-Object.defineProperty(exports, "buildReplayScript", { enumerable: true, get: function () { return replay_script_1.buildReplayScript; } });
-var preload_1 = require("./preload");
-Object.defineProperty(exports, "buildPreloadScript", { enumerable: true, get: function () { return preload_1.buildPreloadScript; } });
-var rewrite_links_1 = require("./rewrite-links");
-Object.defineProperty(exports, "rewriteEntryHtml", { enumerable: true, get: function () { return rewrite_links_1.rewriteEntryHtml; } });
-Object.defineProperty(exports, "rewriteJsText", { enumerable: true, get: function () { return rewrite_links_1.rewriteJsText; } });
-var css_rewrite_1 = require("./css-rewrite");
-Object.defineProperty(exports, "rewriteCssText", { enumerable: true, get: function () { return css_rewrite_1.rewriteCssText; } });
-var writers_1 = require("./writers");
-Object.defineProperty(exports, "writeToFS", { enumerable: true, get: function () { return writers_1.writeToFS; } });
-Object.defineProperty(exports, "toZip", { enumerable: true, get: function () { return writers_1.toZip; } });
-var replace_elements_1 = require("./replace-elements");
-Object.defineProperty(exports, "applyReplaceElements", { enumerable: true, get: function () { return replace_elements_1.applyReplaceElements; } });
+export { PagePocket } from "./core/pagepocket.js";
+// New Units/Plugins API (break change).
+export * from "./units/index.js";
+export { TERMINAL_RESULT_KEY } from "./units/contracts-bridge.js";
+export { TriggerActionValues } from "./types.js";
+export { HybridContentStore } from "./core/content-store.js";
+export { createDefaultPathResolver, withPrefixPathResolver } from "./path-resolver.js";
+export { createDefaultResourceFilter } from "./resource-filter.js";
+export { buildSnapshot } from "./snapshot-builder/index.js";
+export * from "./builtin-blacklist.js";
+export { networkIdle, timeout } from "./core/completion.js";
+export { normalizeCompletion } from "./core/completion.js";
+export { debugLog } from "./core/debug.js";
+export { InflightTracker } from "./core/inflight-tracker.js";
+export { mergeFileTrees } from "./core/file-tree-merge.js";
+export { createMemoryContentStore } from "./core/capture/memory-content-store.js";
+export { buildReplayScript } from "./replay-script.js";
+export { buildPreloadScript } from "./preload.js";
+export { rewriteEntryHtml, rewriteJsText } from "./rewrite-links.js";
+export { rewriteCssText } from "./css-rewrite.js";
+export { applyReplaceElements } from "./replace-elements.js";
+export { streamToUint8Array, streamFromUint8Array } from "./utils/streams.js";
+export { mapKind, requiredEntryKindError, throwRequiredEntryKind, throwUnsupportedEntryKind, unsupportedEntryKindError } from "./kind-map.js";

package/dist/kind-map.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Partial mapping from a discriminated union member to a result.
+ *
+ * Keys are the union's `kind` values; each value is a lazy builder function.
+ */
+export type KindBuilders<Entry extends {
+    kind: string;
+}, Result> = Partial<{
+    [K in Entry["kind"]]: (entry: Extract<Entry, {
+        kind: K;
+    }>) => Result;
+}>;
+type BuilderReturn<F> = F extends (...args: any[]) => infer R ? R : never;
+type BuildersResult<Builders> = BuilderReturn<NonNullable<Builders[keyof Builders]>>;
+/**
+ * Generic helper for mapping discriminated unions by `kind`.
+ *
+ * This is useful when you want an object-based alternative to a switch statement.
+ * It preserves runtime safety by delegating unsupported kinds to a handler.
+ *
+ * Notes:
+ * - The builder map is intentionally partial: unsupported kinds are handled via
+ *   `onUnsupportedKind` (typically: throw).
+ * - The values should be functions (lazy) to avoid reading fields that do not
+ *   exist on other union members.
+ */
+export declare const mapKind: <Entry extends {
+    kind: string;
+}, Builders extends KindBuilders<Entry, unknown>>(entry: Entry, builders: Builders, options: {
+    /**
+     * Called when `entry.kind` is not present in `builders`.
+     * Should throw.
+     */
+    onUnsupportedKind: (kind: Entry["kind"], entry: Entry) => never;
+}) => BuildersResult<Builders>;
+/**
+ * Standard error for capture units that build an InterceptTarget from runtime entry.
+ *
+ * Format matches existing unit errors:
+ *   "<UnitName> does not support entry kind: <kind>"
+ */
+export declare const unsupportedEntryKindError: (unitName: string, entry: {
+    kind: unknown;
+}) => Error;
+/**
+ * Standard error for capture units that *require* a specific entry kind.
+ *
+ * Format matches existing unit errors:
+ *   "<UnitName> requires entry kind \"<required>\" (got <kind>)"
+ */
+export declare const requiredEntryKindError: (unitName: string, requiredKind: string, entry: {
+    kind: unknown;
+}) => Error;
+/**
+ * Convenience handler for `mapKind` that throws a standardized
+ * "does not support entry kind" error.
+ */
+export declare const throwUnsupportedEntryKind: (unitName: string) => (_kind: string, entry: {
+    kind: unknown;
+}) => never;
+/**
+ * Convenience handler for `mapKind` that throws a standardized
+ * "requires entry kind" error.
+ */
+export declare const throwRequiredEntryKind: (unitName: string, requiredKind: string) => (_kind: string, entry: {
+    kind: unknown;
+}) => never;
+export {};

package/dist/kind-map.js

@@ -0,0 +1,58 @@
+/**
+ * Generic helper for mapping discriminated unions by `kind`.
+ *
+ * This is useful when you want an object-based alternative to a switch statement.
+ * It preserves runtime safety by delegating unsupported kinds to a handler.
+ *
+ * Notes:
+ * - The builder map is intentionally partial: unsupported kinds are handled via
+ *   `onUnsupportedKind` (typically: throw).
+ * - The values should be functions (lazy) to avoid reading fields that do not
+ *   exist on other union members.
+ */
+export const mapKind = (entry, builders, options) => {
+    const hasBuilder = Object.prototype.hasOwnProperty.call(builders, entry.kind);
+    const builder = hasBuilder ? builders[entry.kind] : undefined;
+    if (!builder) {
+        return options.onUnsupportedKind(entry.kind, entry);
+    }
+    return builder(entry);
+};
+/**
+ * Standard error for capture units that build an InterceptTarget from runtime entry.
+ *
+ * Format matches existing unit errors:
+ *   "<UnitName> does not support entry kind: <kind>"
+ */
+export const unsupportedEntryKindError = (unitName, entry) => {
+    const kind = entry.kind;
+    return new Error(`${unitName} does not support entry kind: ${String(kind)}`);
+};
+/**
+ * Standard error for capture units that *require* a specific entry kind.
+ *
+ * Format matches existing unit errors:
+ *   "<UnitName> requires entry kind \"<required>\" (got <kind>)"
+ */
+export const requiredEntryKindError = (unitName, requiredKind, entry) => {
+    const kind = entry.kind;
+    return new Error(`${unitName} requires entry kind "${requiredKind}" (got ${String(kind)})`);
+};
+/**
+ * Convenience handler for `mapKind` that throws a standardized
+ * "does not support entry kind" error.
+ */
+export const throwUnsupportedEntryKind = (unitName) => {
+    return (_kind, entry) => {
+        throw unsupportedEntryKindError(unitName, entry);
+    };
+};
+/**
+ * Convenience handler for `mapKind` that throws a standardized
+ * "requires entry kind" error.
+ */
+export const throwRequiredEntryKind = (unitName, requiredKind) => {
+    return (_kind, entry) => {
+        throw requiredEntryKindError(unitName, requiredKind, entry);
+    };
+};

package/dist/network-store.js

@@ -15,6 +15,17 @@ const getHeaderValue = (headers, name) => {
     }
     return undefined;
 };
+const parseContentLength = (headers) => {
+    const raw = getHeaderValue(headers, "content-length");
+    if (!raw) {
+        return undefined;
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return undefined;
+    }
+    return parsed;
+};
 const responseMimeType = (response) => response.mimeType || getHeaderValue(response.headers || {}, "content-type");
 class NetworkStore {
     constructor(options) {
@@ -107,7 +118,7 @@ class NetworkStore {
             request,
             response,
             contentRef,
-            size: bodyBytes.byteLength,
+            size: parseContentLength(response.headers || {}) ?? bodyBytes.byteLength,
             mimeType: responseMimeType(response)
         };
         this.storedResources.push(stored);

package/dist/pagepocket.d.ts

@@ -1,12 +1,27 @@
-import type { InterceptTarget } from "@pagepocket/interceptor";
-import type { CaptureOptions, NetworkEventStream, PagePocketOptions, PageSnapshot } from "./types";
+import type { NetworkEvent } from "@pagepocket/interceptor";
+import type { NetworkEventStream, PagePocketOptions } from "./types";
+import type { CaptureWithPluginsOptions, PagePocketCaptureResult } from "./plugin/types";
 export declare class PagePocket {
     private target;
     private options;
     private eventStream;
     private constructor();
     static fromURL(url: string, options?: PagePocketOptions): PagePocket;
-    static fromTarget(target: InterceptTarget, options?: PagePocketOptions): PagePocket;
+    static fromPuppeteerPage(page: unknown, options?: PagePocketOptions): PagePocket;
+    static fromCDPTab(tabId: number, options?: PagePocketOptions): PagePocket;
+    static fromHTMLString(htmlString: string, options: {
+        baseUrl: string;
+        url?: string;
+    } & PagePocketOptions): PagePocket;
     interceptedRequestEvents(): NetworkEventStream;
-    capture(options?: CaptureOptions): Promise<PageSnapshot>;
+    /** @internal */
+    _emitNetworkEvent(event: NetworkEvent): void;
+    /** @internal */
+    _closeNetworkEventStream(): void;
+    static fromDocument(doc: unknown, options: {
+        baseUrl: string;
+        url?: string;
+        serialize?: (doc: unknown) => string;
+    } & PagePocketOptions): PagePocket;
+    capture(options: CaptureWithPluginsOptions): Promise<PagePocketCaptureResult>;
 }

package/dist/pagepocket.js

@@ -1,14 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PagePocket = void 0;
-const completion_1 = require("./completion");
-const content_store_1 = require("./content-store");
-const debug_1 = require("./debug");
-const inflight_tracker_1 = require("./inflight-tracker");
-const network_store_1 = require("./network-store");
-const path_resolver_1 = require("./path-resolver");
-const resource_filter_1 = require("./resource-filter");
-const snapshot_builder_1 = require("./snapshot-builder");
+const runner_1 = require("./plugin/runner");
 class AsyncEventQueue {
     constructor() {
         this.values = [];
@@ -114,107 +107,48 @@ class PagePocket {
     static fromURL(url, options) {
         return new PagePocket({ kind: "url", url }, options);
     }
-    static fromTarget(target, options) {
-        return new PagePocket(target, options);
+    static fromPuppeteerPage(page, options) {
+        return new PagePocket({ kind: "puppeteer-page", page }, options);
+    }
+    static fromCDPTab(tabId, options) {
+        return new PagePocket({ kind: "cdp-tab", tabId }, options);
+    }
+    static fromHTMLString(htmlString, options) {
+        const { baseUrl, url, ...rest } = options;
+        return new PagePocket({ kind: "html", htmlString, baseUrl, ...(url ? { url } : {}) }, rest);
     }
     interceptedRequestEvents() {
         return this.eventStream.subscribe();
     }
-    async capture(options) {
-        if (!options?.interceptor) {
-            throw new Error("CaptureOptions.interceptor is required.");
-        }
-        const contentStore = options?.contentStore ?? new content_store_1.HybridContentStore();
-        const baseFilter = options?.filter ?? (0, resource_filter_1.createDefaultResourceFilter)();
-        const blacklist = options?.blacklist ?? [];
-        const isBlacklisted = (url) => typeof url === "string" && blacklist.some((pattern) => pattern.test(url));
-        const filter = blacklist.length === 0
-            ? baseFilter
-            : {
-                shouldSave(req, res) {
-                    if (isBlacklisted(req.url)) {
-                        (0, debug_1.debug_log)("[pagepocket] blacklist match (skip save)", req.url);
-                        return false;
+    /** @internal */
+    _emitNetworkEvent(event) {
+        this.eventStream.emit(event);
+    }
+    /** @internal */
+    _closeNetworkEventStream() {
+        this.eventStream.close();
+    }
+    static fromDocument(doc, options) {
+        const serialize = options.serialize ??
+            ((value) => {
+                if (value && typeof value === "object" && "documentElement" in value) {
+                    const el = value.documentElement;
+                    if (el && typeof el.outerHTML === "string") {
+                        return el.outerHTML;
                     }
-                    return baseFilter.shouldSave(req, res);
-                }
-            };
-        const pathResolver = options?.pathResolver ?? (0, path_resolver_1.createDefaultPathResolver)();
-        const rewriteEntry = options?.rewriteEntry ?? true;
-        const rewriteCSS = options?.rewriteCSS ?? true;
-        const replaceElements = options?.replaceElements;
-        const limits = options?.limits;
-        const completionStrategies = (0, completion_1.normalizeCompletion)(options?.completion);
-        const idleMs = options?.timeoutMs ?? 5000;
-        const maxDurationMs = options?.maxDurationMs;
-        const completion = completionStrategies.length > 0
-            ? completionStrategies
-            : [(0, completion_1.networkIdle)(idleMs), ...(maxDurationMs !== undefined ? [(0, completion_1.timeout)(maxDurationMs)] : [])];
-        const store = new network_store_1.NetworkStore({
-            contentStore,
-            filter,
-            limits
-        });
-        const inflightTracker = new inflight_tracker_1.InflightTracker({
-            shouldIgnore: (event) => {
-                if (!isBlacklisted(event.url)) {
-                    return false;
                 }
-                (0, debug_1.debug_log)("[pagepocket] blacklist match (ignore inflight)", event.url);
-                return true;
-            }
-        });
-        const getStats = () => {
-            const stats = inflightTracker.getStats();
-            (0, debug_1.debug_log)("[pagepocket] stats", stats);
-            return stats;
-        };
-        const pendingEvents = new Set();
-        const onEvent = (event) => {
-            this.eventStream.emit(event);
-            const stats = inflightTracker.handleEvent(event);
-            (0, debug_1.debug_log)("[pagepocket] inflight", stats.inflightRequests, "event", event.type, event.requestId, event.url);
-            const task = store.handleEvent(event);
-            pendingEvents.add(task);
-            task.finally(() => pendingEvents.delete(task));
-        };
-        (0, debug_1.debug_log)("[pagepocket] session start");
-        const session = await options.interceptor.start(this.target, { onEvent }, { timeoutMs: options?.timeoutMs, maxDurationMs: options?.maxDurationMs });
-        (0, debug_1.debug_log)("[pagepocket] session started");
-        if (this.target.kind === "url" && session?.navigate) {
-            (0, debug_1.debug_log)("[pagepocket] navigate", this.target.url);
-            await session.navigate(this.target.url);
-            (0, debug_1.debug_log)("[pagepocket] navigated");
-        }
-        if (completion.length === 1) {
-            await completion[0].wait({
-                now: () => Date.now(),
-                getStats
+                throw new Error("fromDocument requires options.serialize(doc) or doc.documentElement.outerHTML");
             });
-        }
-        else if (completion.length > 1) {
-            await Promise.race(completion.map((strategy) => strategy.wait({
-                now: () => Date.now(),
-                getStats
-            })));
-        }
-        (0, debug_1.debug_log)("[pagepocket] session stop");
-        await session.stop();
-        (0, debug_1.debug_log)("[pagepocket] session stopped");
-        await Promise.all(pendingEvents);
-        this.eventStream.close();
-        const entryUrl = this.target.kind === "url" ? this.target.url : "";
-        return (0, snapshot_builder_1.buildSnapshot)({
-            entryUrl,
-            createdAt: Date.now(),
-            resources: store.getResources(),
-            apiEntries: store.getApiEntries(),
-            contentStore,
-            pathResolver,
-            rewriteEntry,
-            rewriteCSS,
-            replaceElements,
-            warnings: store.getWarnings()
+        const htmlString = serialize(doc);
+        const { baseUrl, url, serialize: _serialize, ...rest } = options;
+        return new PagePocket({ kind: "html", htmlString, baseUrl, ...(url ? { url } : {}) }, rest);
+    }
+    async capture(options) {
+        return (0, runner_1.captureWithPlugins)({
+            pocket: this,
+            pocketOptions: this.options,
+            target: this.target,
+            options
         });
     }
 }

package/dist/path-resolver.d.ts

@@ -1,5 +1,4 @@
-import type { ResourceType } from "@pagepocket/interceptor";
-import type { PathResolver } from "./types";
+import type { PathResolver, ResourceType } from "./types.js";
 export declare const createDefaultPathResolver: () => PathResolver;
 export declare const resolveCrossOrigin: (url: string, entryUrl: string) => boolean;
 export declare const withPrefixPathResolver: (resolver: PathResolver, prefix: string) => PathResolver;

package/dist/path-resolver.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDocumentType = exports.withPrefixPathResolver = exports.resolveCrossOrigin = exports.createDefaultPathResolver = void 0;
-const utils_1 = require("./utils");
+import { hashString, sanitizePosixPath } from "./utils.js";
 const normalizePathname = (pathname) => {
     const normalized = pathname || "/";
     const hasTrailingSlash = normalized.endsWith("/");
-    const clean = (0, utils_1.sanitizePosixPath)(normalized);
+    const clean = sanitizePosixPath(normalized);
     const parts = clean.split("/").filter(Boolean);
     if (hasTrailingSlash) {
         parts.push("index");
@@ -30,7 +27,7 @@ const withSuffix = (path, suffix) => {
     return `${path}${suffix}`;
 };
 const sameDomain = (left, right) => left.hostname === right.hostname;
-const createDefaultPathResolver = () => {
+export const createDefaultPathResolver = () => {
     const resolvedByUrl = new Map();
     const usedPaths = new Map();
     return {
@@ -52,13 +49,13 @@ const createDefaultPathResolver = () => {
             }
             const pathname = normalizePathname(parsed?.pathname || "/");
             const queryHash = `${parsed?.search || ""}${parsed?.hash || ""}`;
-            const suffix = queryHash ? `__ppq_${(0, utils_1.hashString)(queryHash)}` : "";
+            const suffix = queryHash ? `__ppq_${hashString(queryHash)}` : "";
             const basePath = input.isCrossOrigin ? `/external_resources${pathname}` : `${pathname}`;
             let resolvedPath = suffix ? withSuffix(basePath, suffix) : basePath;
             const collisionKey = resolvedPath;
             const existingUrl = usedPaths.get(collisionKey);
             if (existingUrl && existingUrl !== input.url) {
-                const collisionSuffix = `__ppc_${(0, utils_1.hashString)(input.url)}`;
+                const collisionSuffix = `__ppc_${hashString(input.url)}`;
                 resolvedPath = withSuffix(resolvedPath, collisionSuffix);
             }
             usedPaths.set(resolvedPath, input.url);
@@ -67,8 +64,7 @@ const createDefaultPathResolver = () => {
         }
     };
 };
-exports.createDefaultPathResolver = createDefaultPathResolver;
-const resolveCrossOrigin = (url, entryUrl) => {
+export const resolveCrossOrigin = (url, entryUrl) => {
     try {
         const parsed = new URL(url);
         const entry = new URL(entryUrl);
@@ -78,9 +74,8 @@ const resolveCrossOrigin = (url, entryUrl) => {
         return false;
     }
 };
-exports.resolveCrossOrigin = resolveCrossOrigin;
-const withPrefixPathResolver = (resolver, prefix) => {
-    const normalizedPrefix = (0, utils_1.sanitizePosixPath)(prefix);
+export const withPrefixPathResolver = (resolver, prefix) => {
+    const normalizedPrefix = sanitizePosixPath(prefix);
     if (!normalizedPrefix) {
         return resolver;
     }
@@ -95,6 +90,4 @@ const withPrefixPathResolver = (resolver, prefix) => {
         }
     };
 };
-exports.withPrefixPathResolver = withPrefixPathResolver;
-const isDocumentType = (resourceType) => resourceType === "document";
-exports.isDocumentType = isDocumentType;
+export const isDocumentType = (resourceType) => resourceType === "document";

package/dist/plugin/builtins/build-snapshot-plugin.d.ts

@@ -0,0 +1,5 @@
+import type { PagePocketContext, PagePocketPlugin } from "../types";
+export declare class BuildSnapshotPlugin implements PagePocketPlugin {
+    readonly name = "built-in:build-snapshot";
+    apply(ctx: PagePocketContext): void;
+}

package/dist/plugin/builtins/build-snapshot-plugin.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildSnapshotPlugin = void 0;
+const content_store_1 = require("../../content-store");
+const debug_1 = require("../../debug");
+const inflight_tracker_1 = require("../../inflight-tracker");
+const network_store_1 = require("../../network-store");
+const path_resolver_1 = require("../../path-resolver");
+const resource_filter_1 = require("../../resource-filter");
+const snapshot_builder_1 = require("../../snapshot-builder");
+class BuildSnapshotPlugin {
+    constructor() {
+        this.name = "built-in:build-snapshot";
+    }
+    apply(ctx) {
+        const ctxInternal = ctx;
+        const contentStore = ctx.options.contentStore ?? new content_store_1.HybridContentStore();
+        const baseFilter = ctx.options.filter ?? (0, resource_filter_1.createDefaultResourceFilter)();
+        const blacklist = ctx.options.blacklist ?? [];
+        const isBlacklisted = (url) => typeof url === "string" && blacklist.some((pattern) => pattern.test(url));
+        const filter = blacklist.length === 0
+            ? baseFilter
+            : {
+                shouldSave(req, res) {
+                    if (isBlacklisted(req.url)) {
+                        (0, debug_1.debug_log)("[pagepocket] blacklist match (skip save)", req.url);
+                        return false;
+                    }
+                    return baseFilter.shouldSave(req, res);
+                }
+            };
+        const pathResolver = ctx.options.pathResolver ?? (0, path_resolver_1.createDefaultPathResolver)();
+        const rewriteEntry = ctx.options.rewriteEntry ?? true;
+        const rewriteCSS = ctx.options.rewriteCSS ?? true;
+        const limits = ctx.options.limits;
+        const store = new network_store_1.NetworkStore({
+            contentStore,
+            filter,
+            limits
+        });
+        const inflightTracker = new inflight_tracker_1.InflightTracker({
+            shouldIgnore: (event) => {
+                if (!isBlacklisted(event.url)) {
+                    return false;
+                }
+                (0, debug_1.debug_log)("[pagepocket] blacklist match (ignore inflight)", event.url);
+                return true;
+            }
+        });
+        ctx.onNetworkEvent(async (event) => {
+            inflightTracker.handleEvent(event);
+            await store.handleEvent(event);
+        });
+        ctx.onFinalize(async () => {
+            if (ctx.snapshot) {
+                return;
+            }
+            const entryUrl = ctx.entry.kind === "url"
+                ? ctx.entry.url
+                : ctx.entry.kind === "html-string"
+                    ? (ctx.entry.url ?? ctx.entry.baseUrl)
+                    : "";
+            const replaceElements = ctxInternal._replaceElements.length > 0 ? ctxInternal._replaceElements : undefined;
+            const replaceElementsMerged = replaceElements
+                ? replaceElements.flat()
+                : undefined;
+            const snapshot = await (0, snapshot_builder_1.buildSnapshot)({
+                entryUrl,
+                createdAt: Date.now(),
+                resources: store.getResources(),
+                apiEntries: store.getApiEntries(),
+                contentStore,
+                pathResolver,
+                rewriteEntry,
+                rewriteCSS,
+                replaceElements: replaceElementsMerged,
+                warnings: []
+            });
+            ctx.snapshot = snapshot;
+            return { kind: "snapshot", snapshot };
+        });
+    }
+}
+exports.BuildSnapshotPlugin = BuildSnapshotPlugin;

package/dist/plugin/builtins/replace-elements-plugin.d.ts

@@ -0,0 +1,8 @@
+import type { ReplaceElementsConfig } from "../../types";
+import type { PagePocketPlugin } from "../types";
+export declare class ReplaceElementsPlugin implements PagePocketPlugin {
+    readonly name = "built-in:replace-elements";
+    private rules;
+    constructor(rules: ReplaceElementsConfig);
+    apply(ctx: import("../types").PagePocketContext): void;
+}

package/dist/plugin/builtins/replace-elements-plugin.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplaceElementsPlugin = void 0;
+class ReplaceElementsPlugin {
+    constructor(rules) {
+        this.name = "built-in:replace-elements";
+        this.rules = rules;
+    }
+    apply(ctx) {
+        ctx.addReplaceElements(this.rules);
+    }
+}
+exports.ReplaceElementsPlugin = ReplaceElementsPlugin;

package/dist/plugin/builtins/to-directory-plugin.d.ts

@@ -0,0 +1,7 @@
+import type { PagePocketContext, PagePocketPlugin } from "../types";
+export declare class ToDirectoryPlugin implements PagePocketPlugin {
+    readonly name = "built-in:to-directory";
+    private outputDir;
+    constructor(outputDir: string);
+    apply(ctx: PagePocketContext): void;
+}

package/dist/plugin/builtins/to-directory-plugin.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToDirectoryPlugin = void 0;
+const writers_1 = require("../../writers");
+class ToDirectoryPlugin {
+    constructor(outputDir) {
+        this.name = "built-in:to-directory";
+        this.outputDir = outputDir;
+    }
+    apply(ctx) {
+        ctx.onFinalize(async () => {
+            if (!ctx.snapshot) {
+                throw new Error("ToDirectoryPlugin requires ctx.snapshot");
+            }
+            await (0, writers_1.writeToFS)(ctx.snapshot, this.outputDir);
+            return { kind: "directory", outputDir: this.outputDir };
+        });
+    }
+}
+exports.ToDirectoryPlugin = ToDirectoryPlugin;

package/dist/plugin/builtins/to-zip-plugin.d.ts

@@ -0,0 +1,5 @@
+import type { PagePocketContext, PagePocketPlugin } from "../types";
+export declare class ToZipPlugin implements PagePocketPlugin {
+    readonly name = "built-in:to-zip";
+    apply(ctx: PagePocketContext): void;
+}