@pagepocket/lib 0.7.1 → 0.8.0

package/dist/core/pagepocket.js

@@ -0,0 +1,57 @@
+import { runCapture } from "../units/index.js";
+export class PagePocket {
+    constructor(target, options) {
+        this.target = target;
+        this.options = options ?? {};
+    }
+    static fromURL(url, options) {
+        return new PagePocket({ kind: "url", url }, 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);
+    }
+    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;
+                    }
+                }
+                throw new Error("fromDocument requires options.serialize(doc) or doc.documentElement.outerHTML");
+            });
+        const htmlString = serialize(doc);
+        const { baseUrl, url, serialize: _serialize, ...rest } = options;
+        return new PagePocket({ kind: "html", htmlString, baseUrl, ...(url ? { url } : {}) }, rest);
+    }
+    async capture(options) {
+        const entry = this.target.kind === "url"
+            ? { kind: "url", url: this.target.url }
+            : this.target.kind === "puppeteer-page"
+                ? { kind: "puppeteer-page", page: this.target.page }
+                : this.target.kind === "cdp-tab"
+                    ? { kind: "cdp-tab", tabId: this.target.tabId }
+                    : {
+                        kind: "html-string",
+                        baseUrl: this.target.baseUrl,
+                        htmlString: this.target.htmlString,
+                        ...(this.target.url ? { url: this.target.url } : {})
+                    };
+        const result = await runCapture({
+            entry,
+            pocketOptions: this.options,
+            options,
+            units: options.units,
+            plugins: options.plugins
+        });
+        return result;
+    }
+}

package/dist/core/plugin/_impl/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/core/plugin/_impl/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/core/plugin/_impl/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/core/plugin/_impl/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/core/plugin/_impl/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/core/plugin/_impl/types.js

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

package/dist/core/plugin/context.d.ts

@@ -0,0 +1,47 @@
+import type { NetworkEvent } from "../../types.js";
+import type { ReplaceElementsConfig } from "../../types.js";
+import type { CaptureWithPluginsOptions, HtmlArtifact, PagePocketCaptureResult, PagePocketContext, PagePocketPlugin } from "./types.js";
+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 {};