@pagepocket/lib 0.7.1 → 0.8.0

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

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

package/dist/plugin/context.d.ts

@@ -0,0 +1,47 @@
+import type { NetworkEvent } from "@pagepocket/interceptor";
+import type { ReplaceElementsConfig } from "../types";
+import type { CaptureWithPluginsOptions, HtmlArtifact, PagePocketCaptureResult, PagePocketContext, PagePocketPlugin } from "./types";
+type Hook<TArgs extends unknown[] = []> = (...args: TArgs) => void | Promise<void>;
+type FinalizeHook = () => void | PagePocketCaptureResult | Promise<void | PagePocketCaptureResult>;
+export type HookRegistries = {
+    init: Array<Hook>;
+    html: Array<Hook<[payload: {
+        html: HtmlArtifact;
+    }]>>;
+    beforeNetwork: Array<Hook>;
+    networkEvent: Array<Hook<[event: NetworkEvent]>>;
+    afterNetwork: Array<Hook>;
+    finalize: Array<FinalizeHook>;
+};
+export type DeferredTracker = {
+    defer(promise: Promise<unknown>): void;
+    awaitAll(): Promise<void>;
+};
+type HtmlBarrier = {
+    whenHtml(): Promise<HtmlArtifact>;
+    resolveHtml(html: HtmlArtifact): void;
+    rejectHtml(error: Error): void;
+};
+type HtmlHooksDoneBarrier = {
+    whenDone(): Promise<void>;
+    resolve(): void;
+    reject(error: Error): void;
+};
+export type PagePocketContextInternal = PagePocketContext & {
+    _hooks: HookRegistries;
+    _deferred: DeferredTracker;
+    _replaceElements: ReplaceElementsConfig[];
+    _htmlBarrier: HtmlBarrier;
+    _htmlHooksDoneBarrier: HtmlHooksDoneBarrier;
+    _isFinished(): boolean;
+    _setFinished(): void;
+};
+export declare const createDeferredTracker: () => DeferredTracker;
+export declare const createHookRegistries: () => HookRegistries;
+export declare const createPagePocketContext: (input: {
+    entry: PagePocketContext["entry"];
+    options: CaptureWithPluginsOptions;
+    pocketOptions: PagePocketContext["pocketOptions"];
+}) => PagePocketContextInternal;
+export declare const resolveEnabledPlugins: (plugins: PagePocketPlugin[], ctx: PagePocketContext) => Promise<PagePocketPlugin[]>;
+export {};

package/dist/plugin/context.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEnabledPlugins = exports.createPagePocketContext = exports.createHookRegistries = exports.createDeferredTracker = void 0;
+const createBarrier = () => {
+    let resolve = null;
+    let reject = null;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return {
+        promise,
+        resolve: (value) => resolve?.(value),
+        reject: (error) => reject?.(error)
+    };
+};
+const createHtmlBarrier = (ctxRef) => {
+    const barrier = createBarrier();
+    return {
+        whenHtml: async () => {
+            if (ctxRef.html) {
+                return ctxRef.html;
+            }
+            return barrier.promise;
+        },
+        resolveHtml: (html) => {
+            barrier.resolve(html);
+        },
+        rejectHtml: (error) => {
+            barrier.reject(error);
+        }
+    };
+};
+const createHtmlHooksDoneBarrier = () => {
+    const barrier = createBarrier();
+    return {
+        whenDone: async () => barrier.promise,
+        resolve: () => barrier.resolve(undefined),
+        reject: (error) => barrier.reject(error)
+    };
+};
+const createDeferredTracker = () => {
+    const promises = new Set();
+    return {
+        defer(promise) {
+            promises.add(promise);
+            promise.finally(() => promises.delete(promise));
+        },
+        async awaitAll() {
+            await Promise.allSettled(Array.from(promises));
+        }
+    };
+};
+exports.createDeferredTracker = createDeferredTracker;
+const createHookRegistries = () => ({
+    init: [],
+    html: [],
+    beforeNetwork: [],
+    networkEvent: [],
+    afterNetwork: [],
+    finalize: []
+});
+exports.createHookRegistries = createHookRegistries;
+const createPagePocketContext = (input) => {
+    const state = {};
+    const hooks = (0, exports.createHookRegistries)();
+    const deferred = (0, exports.createDeferredTracker)();
+    const replaceElements = [];
+    let finished = false;
+    const ctx = {
+        entry: input.entry,
+        options: input.options,
+        pocketOptions: input.pocketOptions,
+        state,
+        _hooks: hooks,
+        _deferred: deferred,
+        _replaceElements: replaceElements,
+        _isFinished: () => finished,
+        _setFinished: () => {
+            finished = true;
+        }
+    };
+    const htmlBarrier = createHtmlBarrier(ctx);
+    const htmlHooksDoneBarrier = createHtmlHooksDoneBarrier();
+    ctx._htmlBarrier = htmlBarrier;
+    ctx._htmlHooksDoneBarrier = htmlHooksDoneBarrier;
+    ctx.whenHtml = async () => htmlBarrier.whenHtml();
+    ctx.whenHtmlHooksDone = async () => {
+        await htmlBarrier.whenHtml();
+        return htmlHooksDoneBarrier.whenDone();
+    };
+    ctx.onInit = (handler) => {
+        hooks.init.push(handler);
+    };
+    ctx.onHtml = (handler) => {
+        hooks.html.push(handler);
+    };
+    ctx.onBeforeNetwork = (handler) => {
+        hooks.beforeNetwork.push(handler);
+    };
+    ctx.onNetworkEvent = (handler) => {
+        hooks.networkEvent.push(handler);
+    };
+    ctx.onAfterNetwork = (handler) => {
+        hooks.afterNetwork.push(handler);
+    };
+    ctx.onFinalize = (handler) => {
+        hooks.finalize.push(handler);
+    };
+    ctx.setHtml = (next) => {
+        ctx.html = next;
+        htmlBarrier.resolveHtml(next);
+    };
+    ctx.addReplaceElements = (rules) => {
+        replaceElements.push(rules);
+    };
+    ctx.finish = (result) => {
+        if (finished) {
+            return;
+        }
+        ctx.result = result;
+        finished = true;
+    };
+    ctx.defer = (promise) => {
+        deferred.defer(promise);
+    };
+    return ctx;
+};
+exports.createPagePocketContext = createPagePocketContext;
+const resolveEnabledPlugins = async (plugins, ctx) => {
+    const enabled = [];
+    for (const plugin of plugins) {
+        const gate = plugin.enabled;
+        if (gate === false) {
+            continue;
+        }
+        // Default enabled when gate is undefined.
+        enabled.push(plugin);
+    }
+    return enabled;
+};
+exports.resolveEnabledPlugins = resolveEnabledPlugins;

package/dist/plugin/runner.d.ts

@@ -0,0 +1,12 @@
+import type { InterceptTarget, NetworkEvent } from "@pagepocket/interceptor";
+import type { CaptureWithPluginsOptions, PagePocketCaptureResult } from "./types";
+type RunnerInput = {
+    pocket: {
+        interceptedRequestEvents(): AsyncIterable<NetworkEvent>;
+    };
+    pocketOptions: import("../types").PagePocketOptions;
+    target: InterceptTarget;
+    options: CaptureWithPluginsOptions;
+};
+export declare const captureWithPlugins: (input: RunnerInput) => Promise<PagePocketCaptureResult>;
+export {};

package/dist/plugin/runner.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureWithPlugins = void 0;
+const completion_1 = require("../completion");
+const debug_1 = require("../debug");
+const inflight_tracker_1 = require("../inflight-tracker");
+const context_1 = require("./context");
+const runHandlersSequentially = async (handlers, args, ctx) => {
+    for (const handler of handlers) {
+        if (ctx._isFinished()) {
+            return;
+        }
+        await handler(...args);
+    }
+};
+const runFinalizeHandlers = async (ctx) => {
+    for (const handler of ctx._hooks.finalize) {
+        if (ctx._isFinished()) {
+            return;
+        }
+        const result = await handler();
+        if (result) {
+            ctx.finish(result);
+            return;
+        }
+    }
+};
+const pluginLabel = (plugin) => {
+    const ctor = plugin.constructor;
+    const ctorName = ctor && typeof ctor.name === "string" ? ctor.name : undefined;
+    return {
+        name: plugin.name,
+        ctorName,
+        enabled: plugin.enabled
+    };
+};
+const captureWithPlugins = async (input) => {
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] capture start", {
+        targetKind: input.target.kind,
+        adapter: input.options.interceptor?.name,
+        pluginCount: input.options.plugins.length
+    });
+    const plugins = input.options.plugins;
+    const ctx = (0, context_1.createPagePocketContext)({
+        entry: input.target.kind === "url"
+            ? { kind: "url", url: input.target.url }
+            : input.target.kind === "puppeteer-page"
+                ? { kind: "puppeteer-page", page: input.target.page }
+                : input.target.kind === "cdp-tab"
+                    ? { kind: "cdp-tab", tabId: input.target.tabId }
+                    : input.target.kind === "html"
+                        ? { kind: "html-string", baseUrl: input.target.baseUrl, url: input.target.url }
+                        : (() => {
+                            throw new Error(`Unsupported target kind: ${input.target.kind}`);
+                        })(),
+        options: input.options,
+        pocketOptions: input.pocketOptions
+    });
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] plugins configured", plugins.map(pluginLabel));
+    const allPlugins = await (0, context_1.resolveEnabledPlugins)(plugins, ctx);
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] plugins enabled", allPlugins.map(pluginLabel));
+    for (const plugin of allPlugins) {
+        if (ctx._isFinished()) {
+            break;
+        }
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] plugin.apply start", pluginLabel(plugin));
+        await plugin.apply(ctx);
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] plugin.apply done", pluginLabel(plugin));
+    }
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=init start", { count: ctx._hooks.init.length });
+    await runHandlersSequentially(ctx._hooks.init, [], ctx);
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=init done");
+    const interceptor = input.options.interceptor;
+    if (!interceptor) {
+        // HTML-only flow.
+        if (input.target.kind !== "html") {
+            throw new Error("options.interceptor is required for non-HTML entrypoints.");
+        }
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=html (no interceptor) start");
+        ctx.setHtml({
+            htmlString: input.target.htmlString,
+            baseUrl: input.target.baseUrl,
+            url: input.target.url,
+            contentType: "text/html"
+        });
+        try {
+            await runHandlersSequentially(ctx._hooks.html, [{ html: ctx.html }], ctx);
+            ctx._htmlHooksDoneBarrier.resolve();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            ctx._htmlHooksDoneBarrier.reject(err);
+            throw err;
+        }
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=html (no interceptor) done");
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=finalize start", {
+            count: ctx._hooks.finalize.length
+        });
+        await runFinalizeHandlers(ctx);
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=finalize done", { resultKind: ctx.result?.kind });
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] awaiting deferred work");
+        await ctx._deferred.awaitAll();
+        if (!ctx.result) {
+            throw new Error("No plugin produced a terminal result.");
+        }
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] capture done", { resultKind: ctx.result.kind });
+        return ctx.result;
+    }
+    const completionStrategies = (0, completion_1.normalizeCompletion)(input.options.completion);
+    const idleMs = input.options.timeoutMs ?? 5000;
+    const maxDurationMs = input.options.maxDurationMs;
+    const completion = completionStrategies.length > 0
+        ? completionStrategies
+        : [(0, completion_1.networkIdle)(idleMs), ...(maxDurationMs !== undefined ? [(0, completion_1.timeout)(maxDurationMs)] : [])];
+    let stopped = false;
+    const inflightTracker = new inflight_tracker_1.InflightTracker();
+    const onEvent = async (event) => {
+        inflightTracker.handleEvent(event);
+        await runHandlersSequentially(ctx._hooks.networkEvent, [event], ctx);
+    };
+    const handlers = {
+        onEvent(event) {
+            if (ctx._isFinished()) {
+                return;
+            }
+            input.pocket._emitNetworkEvent(event);
+            void onEvent(event);
+        },
+        onError(error) {
+            (0, debug_1.debugLog)("[pagepocket][plugin-runner] interceptor error", error);
+        }
+    };
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=session start");
+    const session = await interceptor.start(input.target, handlers, {
+        timeoutMs: input.options.timeoutMs,
+        maxDurationMs: input.options.maxDurationMs
+    });
+    try {
+        if (input.target.kind === "url" && session.navigate) {
+            (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=navigate start", { url: input.target.url });
+            await session.navigate(input.target.url);
+            (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=navigate done");
+        }
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=waitForHtml start");
+        const html = await session.waitForHtml();
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=waitForHtml done", {
+            url: html.url,
+            baseUrl: html.baseUrl,
+            contentType: html.contentType,
+            htmlBytes: html.htmlString.length
+        });
+        ctx.setHtml(html);
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=html start", { count: ctx._hooks.html.length });
+        try {
+            await runHandlersSequentially(ctx._hooks.html, [{ html }], ctx);
+            ctx._htmlHooksDoneBarrier.resolve();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            ctx._htmlHooksDoneBarrier.reject(err);
+            throw err;
+        }
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=html done");
+        if (ctx._isFinished()) {
+            (0, debug_1.debugLog)("[pagepocket][plugin-runner] early finish after html", {
+                resultKind: ctx.result?.kind
+            });
+            (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=finalize start", {
+                count: ctx._hooks.finalize.length
+            });
+            await runFinalizeHandlers(ctx);
+            (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=finalize done", { resultKind: ctx.result?.kind });
+            (0, debug_1.debugLog)("[pagepocket][plugin-runner] awaiting deferred work");
+            await ctx._deferred.awaitAll();
+            if (!ctx.result) {
+                throw new Error("No plugin produced a terminal result.");
+            }
+            return ctx.result;
+        }
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=beforeNetwork start", {
+            count: ctx._hooks.beforeNetwork.length
+        });
+        await runHandlersSequentially(ctx._hooks.beforeNetwork, [], ctx);
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=beforeNetwork done");
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=startCapture start");
+        await session.startCapture();
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=startCapture done");
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=completion wait start", {
+            strategies: completion.length
+        });
+        if (completion.length === 1) {
+            await completion[0].wait({
+                now: () => Date.now(),
+                getStats: () => inflightTracker.getStats()
+            });
+        }
+        else {
+            await Promise.race(completion.map((strategy) => strategy.wait({
+                now: () => Date.now(),
+                getStats: () => inflightTracker.getStats()
+            })));
+        }
+        (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=completion wait done");
+    }
+    finally {
+        if (!stopped) {
+            stopped = true;
+            (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=session stop start");
+            await session.stop();
+            (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=session stop done");
+        }
+        input.pocket._closeNetworkEventStream();
+    }
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=afterNetwork start", {
+        count: ctx._hooks.afterNetwork.length
+    });
+    await runHandlersSequentially(ctx._hooks.afterNetwork, [], ctx);
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=afterNetwork done");
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=finalize start", {
+        count: ctx._hooks.finalize.length
+    });
+    await runFinalizeHandlers(ctx);
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] phase=finalize done", { resultKind: ctx.result?.kind });
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] awaiting deferred work");
+    await ctx._deferred.awaitAll();
+    if (!ctx.result) {
+        throw new Error("No plugin produced a terminal result.");
+    }
+    (0, debug_1.debugLog)("[pagepocket][plugin-runner] capture done", { resultKind: ctx.result.kind });
+    return ctx.result;
+};
+exports.captureWithPlugins = captureWithPlugins;

package/dist/plugin/types.d.ts

@@ -0,0 +1,108 @@
+import type { NetworkEvent, NetworkInterceptorAdapter } from "@pagepocket/interceptor";
+import type { ContentStore, PagePocketOptions, PathResolver, ReplaceElementsConfig, ResourceFilter } from "../types";
+export type HtmlArtifact = {
+    baseUrl: string;
+    url?: string;
+    contentType?: string;
+    htmlString: string;
+};
+export type EntryInfo = {
+    kind: "url";
+    url: string;
+} | {
+    kind: "puppeteer-page";
+    page: unknown;
+    url?: string;
+} | {
+    kind: "cdp-tab";
+    tabId: number;
+    url?: string;
+} | {
+    kind: "html-string";
+    baseUrl: string;
+    url?: string;
+} | {
+    kind: "document";
+    baseUrl: string;
+    url?: string;
+};
+export type PagePocketCaptureResult = {
+    kind: "raw";
+    outputDir: string;
+    meta?: unknown;
+} | {
+    kind: "zip";
+    zip: {
+        data: Uint8Array | Blob;
+        outputPath: string;
+    };
+    meta?: unknown;
+} | {
+    kind: "html";
+    html: string;
+    meta?: unknown;
+} | {
+    kind: "text";
+    text: string;
+    meta?: unknown;
+} | {
+    kind: "custom";
+    value: unknown;
+};
+export interface CaptureWithPluginsOptions {
+    /** Needed only if plugins rely on network interception. */
+    interceptor?: NetworkInterceptorAdapter;
+    /** Plugins are executed sequentially in this order. */
+    plugins: PagePocketPlugin[];
+    /** Network completion. */
+    completion?: import("../types").CompletionStrategy | import("../types").CompletionStrategy[];
+    timeoutMs?: number;
+    maxDurationMs?: number;
+    /** Snapshot-related config (used by BuildSnapshotPlugin). */
+    filter?: ResourceFilter;
+    blacklist?: RegExp[];
+    pathResolver?: PathResolver;
+    contentStore?: ContentStore;
+    rewriteEntry?: boolean;
+    rewriteCSS?: boolean;
+    limits?: {
+        maxTotalBytes?: number;
+        maxSingleResourceBytes?: number;
+        maxResources?: number;
+    };
+}
+export interface PagePocketPlugin {
+    readonly name: string;
+    enabled?: boolean;
+    /** Register hook handlers on the context. */
+    apply(ctx: PagePocketContext): void | Promise<void>;
+}
+export interface PagePocketContext extends Record<string, unknown> {
+    entry: EntryInfo;
+    options: CaptureWithPluginsOptions;
+    pocketOptions: PagePocketOptions;
+    /** plugin shared mutable bag */
+    state: Record<string, unknown>;
+    html?: HtmlArtifact;
+    whenHtml(): Promise<HtmlArtifact>;
+    whenHtmlHooksDone(): Promise<void>;
+    onInit(handler: () => void | Promise<void>): void;
+    onHtml(handler: (payload: {
+        html: HtmlArtifact;
+    }) => void | Promise<void>): void;
+    onBeforeNetwork(handler: () => void | Promise<void>): void;
+    onNetworkEvent(handler: (event: NetworkEvent) => void | Promise<void>): void;
+    onAfterNetwork(handler: () => void | Promise<void>): void;
+    onFinalize(handler: () => void | PagePocketCaptureResult | Promise<void | PagePocketCaptureResult>): void;
+    /** Allow plugins to update the HTML artifact. */
+    setHtml(next: HtmlArtifact): void;
+    /** Register replaceElements rules for snapshot build. */
+    addReplaceElements(rules: ReplaceElementsConfig): void;
+    /** optional: broadcast network events */
+    network?: {
+        subscribe(): AsyncIterable<NetworkEvent>;
+    };
+    result?: PagePocketCaptureResult;
+    finish(result: PagePocketCaptureResult): void;
+    defer(promise: Promise<unknown>): void;
+}

package/dist/plugin/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/plugins/build-files-from-capture.d.ts

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

package/dist/plugins/build-files-from-capture.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildFilesFromCapturePlugin = void 0;
+const __1 = require("..");
+const capture_1 = require("../capture");
+// Note: This plugin is transitional. It consumes ctx.capture (new contract)
+// but reuses existing snapshot builder logic internally.
+class BuildFilesFromCapturePlugin {
+    constructor() {
+        this.name = "plugin:build-files-from-capture";
+    }
+    apply(ctx) {
+        ctx.onFinalize(async () => {
+            const existingFiles = ctx.files;
+            if (existingFiles) {
+                return;
+            }
+            const capture = ctx.capture;
+            if (!capture) {
+                throw new Error("BuildFilesFromCapturePlugin requires ctx.capture");
+            }
+            const baseFilter = ctx.options.filter ?? (0, __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, __1.debugLog)("[pagepocket] blacklist match (skip save)", req.url);
+                            return false;
+                        }
+                        return baseFilter.shouldSave(req, res);
+                    }
+                };
+            const pathResolver = ctx.options.pathResolver ?? (0, __1.createDefaultPathResolver)();
+            const rewriteEntry = ctx.options.rewriteEntry ?? true;
+            const rewriteCSS = ctx.options.rewriteCSS ?? true;
+            const limits = ctx.options.limits;
+            const store = await (0, capture_1.captureToNetworkStore)({
+                capture,
+                filter,
+                limits
+            });
+            const entryUrl = ctx.entry.kind === "url"
+                ? ctx.entry.url
+                : ctx.entry.kind === "html-string"
+                    ? (ctx.entry.url ?? ctx.entry.baseUrl)
+                    : "";
+            const internal = ctx;
+            const replaceElements = internal._replaceElements && internal._replaceElements.length > 0
+                ? internal._replaceElements
+                : undefined;
+            const replaceElementsMerged = replaceElements
+                ? replaceElements.flat()
+                : undefined;
+            const snapshot = await (0, __1.buildSnapshot)({
+                entryUrl,
+                createdAt: Date.now(),
+                resources: store.getResources(),
+                apiEntries: store.getApiEntries(),
+                contentStore: capture.contentStore,
+                pathResolver,
+                rewriteEntry,
+                rewriteCSS,
+                replaceElements: replaceElementsMerged,
+                warnings: []
+            });
+            const files = {
+                root: {
+                    kind: "directory",
+                    path: "",
+                    entries: snapshot.files.map((file) => ({
+                        kind: "file",
+                        path: file.path,
+                        source: { kind: "content-ref", ref: file.source }
+                    }))
+                },
+                content: snapshot.content
+            };
+            ctx.files = files;
+        });
+    }
+}
+exports.BuildFilesFromCapturePlugin = BuildFilesFromCapturePlugin;

package/dist/plugins/build-warc.d.ts

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