@pagepocket/lib 0.7.0 → 0.8.0

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

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

package/dist/core/plugin/runner-utils.d.ts

@@ -0,0 +1,9 @@
+import type { PagePocketContextInternal } from "./context.js";
+import type { PagePocketPlugin } from "./types.js";
+export declare const runHandlersSequentially: <TArgs extends unknown[]>(handlers: Array<(...args: TArgs) => void | Promise<void>>, args: TArgs, ctx: PagePocketContextInternal) => Promise<void>;
+export declare const runFinalizeHandlers: (ctx: PagePocketContextInternal) => Promise<void>;
+export declare const pluginLabel: (plugin: PagePocketPlugin) => {
+    name: string;
+    ctorName: string | undefined;
+    enabled: boolean;
+};

package/dist/core/plugin/runner-utils.js

@@ -0,0 +1,29 @@
+export const runHandlersSequentially = async (handlers, args, ctx) => {
+    for (const handler of handlers) {
+        if (ctx._isFinished()) {
+            return;
+        }
+        await handler(...args);
+    }
+};
+export 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;
+        }
+    }
+};
+export const pluginLabel = (plugin) => {
+    const ctor = plugin.constructor;
+    const ctorName = ctor && typeof ctor.name === "string" ? ctor.name : undefined;
+    return {
+        name: plugin.name,
+        ctorName,
+        enabled: true
+    };
+};

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

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

package/dist/core/plugin/runner.js

@@ -0,0 +1,118 @@
+import { debugLog } from "../debug.js";
+import { createPagePocketContext, resolveEnabledPlugins } from "./context.js";
+import { pluginLabel, runFinalizeHandlers, runHandlersSequentially } from "./runner-utils.js";
+// helpers moved to ./runner-utils
+export const captureWithPlugins = async (input) => {
+    debugLog("[pagepocket][plugin-runner] capture start", {
+        targetKind: input.target.kind,
+        pluginCount: input.options.plugins.length
+    });
+    const plugins = input.options.plugins;
+    const ctx = 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
+    });
+    // For pure-HTML entrypoints, provide the HTML artifact immediately so plugins
+    // can rely on ctx.whenHtml() during init.
+    if (input.target.kind === "html") {
+        ctx.setHtml({
+            htmlString: input.target.htmlString,
+            baseUrl: input.target.baseUrl,
+            url: input.target.url,
+            contentType: "text/html"
+        });
+    }
+    // Allow http capture plugins to broadcast events into both:
+    // - ctx.onNetworkEvent hooks
+    // - PagePocket.interceptedRequestEvents() subscribers
+    ctx.emitNetworkEvent = (event) => {
+        void runHandlersSequentially(ctx._hooks.networkEvent, [event], ctx);
+        input.pocket._emitNetworkEvent?.(event);
+    };
+    debugLog("[pagepocket][plugin-runner] plugins configured", plugins.map(pluginLabel));
+    const allPlugins = await resolveEnabledPlugins(plugins, ctx);
+    debugLog("[pagepocket][plugin-runner] plugins resolved", allPlugins.map(pluginLabel));
+    for (const plugin of allPlugins) {
+        if (ctx._isFinished()) {
+            break;
+        }
+        debugLog("[pagepocket][plugin-runner] plugin.apply start", pluginLabel(plugin));
+        await plugin.apply(ctx);
+        debugLog("[pagepocket][plugin-runner] plugin.apply done", pluginLabel(plugin));
+    }
+    debugLog("[pagepocket][plugin-runner] phase=init start", { count: ctx._hooks.init.length });
+    await runHandlersSequentially(ctx._hooks.init, [], ctx);
+    debugLog("[pagepocket][plugin-runner] phase=init done");
+    debugLog("[pagepocket][plugin-runner] phase=waitForHtml start");
+    const html = await ctx.whenHtml();
+    debugLog("[pagepocket][plugin-runner] phase=waitForHtml done", {
+        url: html.url,
+        baseUrl: html.baseUrl,
+        contentType: html.contentType,
+        htmlBytes: html.htmlString.length
+    });
+    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;
+    }
+    debugLog("[pagepocket][plugin-runner] phase=html done");
+    if (ctx._isFinished()) {
+        debugLog("[pagepocket][plugin-runner] early finish after html", {
+            resultKind: ctx.result?.kind
+        });
+        debugLog("[pagepocket][plugin-runner] phase=finalize start", {
+            count: ctx._hooks.finalize.length
+        });
+        await runFinalizeHandlers(ctx);
+        debugLog("[pagepocket][plugin-runner] phase=finalize done", { resultKind: ctx.result?.kind });
+        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;
+    }
+    debugLog("[pagepocket][plugin-runner] phase=beforeNetwork start", {
+        count: ctx._hooks.beforeNetwork.length
+    });
+    await runHandlersSequentially(ctx._hooks.beforeNetwork, [], ctx);
+    debugLog("[pagepocket][plugin-runner] phase=beforeNetwork done");
+    // Note: completion waiting and inflight tracking are now the responsibility
+    // of the http capture plugins (they own interception).
+    debugLog("[pagepocket][plugin-runner] phase=afterNetwork start", {
+        count: ctx._hooks.afterNetwork.length
+    });
+    await runHandlersSequentially(ctx._hooks.afterNetwork, [], ctx);
+    debugLog("[pagepocket][plugin-runner] phase=afterNetwork done");
+    debugLog("[pagepocket][plugin-runner] phase=finalize start", {
+        count: ctx._hooks.finalize.length
+    });
+    await runFinalizeHandlers(ctx);
+    debugLog("[pagepocket][plugin-runner] phase=finalize done", { resultKind: ctx.result?.kind });
+    debugLog("[pagepocket][plugin-runner] awaiting deferred work");
+    await ctx._deferred.awaitAll();
+    if (!ctx.result) {
+        throw new Error("No plugin produced a terminal result.");
+    }
+    debugLog("[pagepocket][plugin-runner] capture done", { resultKind: ctx.result.kind });
+    // Close any external observers.
+    input.pocket._closeNetworkEventStream?.();
+    return ctx.result;
+};

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

@@ -0,0 +1,117 @@
+import type { NetworkEvent } from "../../types.js";
+import type { ContentStore, PagePocketOptions, PathResolver, ReplaceElementsConfig, ResourceFilter } from "../../types.js";
+export type CaptureTarget = import("../pagepocket.js").CaptureTarget;
+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 {
+    /** Plugins are executed sequentially in this order. */
+    plugins: PagePocketPlugin[];
+    /**
+     * Break-change: Units/Plugins API (v3 runner).
+     *
+     * If `units` is provided (or `pluginsV3`), PagePocket.capture() will run the
+     * units runner and ignore legacy `plugins`.
+     */
+    units?: import("../../v3/contracts-bridge.js").Unit[];
+    /** v3 plugins (isolated, contributes replace-elements only). */
+    pluginsV3?: import("../../v3/contracts-bridge.js").Plugin[];
+    /** Network completion. */
+    completion?: import("../../types.js").CompletionStrategy | import("../../types.js").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;
+    /** 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>;
+    };
+    /** optional: emit a network event to observers */
+    emitNetworkEvent?: (event: NetworkEvent) => void;
+    result?: PagePocketCaptureResult;
+    finish(result: PagePocketCaptureResult): void;
+    defer(promise: Promise<unknown>): void;
+}

package/dist/core/plugin/types.js

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

package/dist/core/runtime/types.d.ts

@@ -0,0 +1,14 @@
+import type { CaptureCapabilities, CaptureEvent } from "../capture/types";
+import type { HtmlArtifact } from "../plugin/types";
+export type CaptureRuntimeSession = {
+    /** Resolve the HTML milestone for this capture run. */
+    waitForHtml(): Promise<HtmlArtifact>;
+    /** Begin network capture. Runner calls this after beforeNetwork hooks. */
+    startCapture(): Promise<void>;
+    /** Stream of capture events produced by the runtime. */
+    events(): AsyncIterable<CaptureEvent>;
+    /** Stop the runtime and release any held resources. */
+    stop(): Promise<void>;
+    /** Optional fidelity/capabilities metadata for downstream plugins. */
+    capabilities?: CaptureCapabilities;
+};

package/dist/core/runtime/types.js

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

package/dist/css-rewrite.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rewriteCssText = void 0;
 const URL_PATTERN = /url\(\s*(['"]?)([^'")]+)\1\s*\)/g;
 const IMPORT_PATTERN = /@import\s+(?:url\()?['"]?([^'")]+)['"]?\)?/g;
 const shouldSkipValue = (value) => {
@@ -13,7 +10,7 @@ const shouldSkipValue = (value) => {
         trimmed.startsWith("javascript:") ||
         trimmed.startsWith("#"));
 };
-const rewriteCssText = async (input) => {
+export const rewriteCssText = async (input) => {
     const { cssText, cssUrl, resolveUrl } = input;
     let updated = "";
     let lastIndex = 0;
@@ -72,4 +69,3 @@ const rewriteCssText = async (input) => {
     final += updated.slice(lastIndex);
     return final;
 };
-exports.rewriteCssText = rewriteCssText;

package/dist/debug.d.ts

@@ -1,2 +1 @@
-export declare const debug_log: (...args: unknown[]) => void;
 export declare const debugLog: (...args: unknown[]) => void;

package/dist/debug.js

@@ -1,18 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.debugLog = exports.debug_log = void 0;
+exports.debugLog = void 0;
 const isDebugEnabled = () => {
     const globalProcess = globalThis
         .process;
     const value = globalProcess?.env?.PAGEPOCKET_DEBUG;
     return Boolean(value);
 };
-const debug_log = (...args) => {
+const debugLog = (...args) => {
     if (!isDebugEnabled()) {
         return;
     }
-    // eslint-disable-next-line no-console
     console.log(...args);
 };
-exports.debug_log = debug_log;
-exports.debugLog = exports.debug_log;
+exports.debugLog = debugLog;

package/dist/files/types.d.ts

@@ -0,0 +1,41 @@
+import type { ContentRef } from "../types";
+export type FileTreeSource = {
+    kind: "bytes";
+    data: Uint8Array;
+} | {
+    kind: "text";
+    text: string;
+} | {
+    kind: "content-ref";
+    ref: ContentRef;
+};
+export type FileTreeFile = {
+    kind: "file";
+    /** Path relative to the root (posix-ish, may include '/'). */
+    path: string;
+    source: FileTreeSource;
+};
+export type FileTreeDirectory = {
+    kind: "directory";
+    /** Path relative to the root (posix-ish, may include '/'). */
+    path: string;
+    entries: FileTreeEntry[];
+};
+export type FileTreeEntry = FileTreeFile | FileTreeDirectory;
+/**
+ * Generic, plugin-agnostic filesystem tree.
+ *
+ * Capture/build plugins should populate `ctx.files` using this shape.
+ * Writer plugins (raw/zip) should consume it.
+ */
+export type FileTree = {
+    /** Virtual root directory; its path should be "". */
+    root: FileTreeDirectory;
+    /**
+     * Optional content store handle used when entries reference `{ kind: "content-ref" }`.
+     */
+    content?: {
+        open(ref: ContentRef): Promise<ReadableStream<Uint8Array>>;
+        dispose?(): Promise<void>;
+    };
+};

package/dist/files/types.js

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

package/dist/hack-html.js

@@ -1,20 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hackHtml = void 0;
-const preload_1 = require("./preload");
-const replay_script_1 = require("./replay-script");
-const hackHtml = (input) => {
-    const replayScript = (0, replay_script_1.buildReplayScript)(input.apiPath, input.baseUrl);
-    const preloadScript = `<script>${(0, preload_1.buildPreloadScript)()}</script>`;
+import { buildPreloadScript } from "./preload.js";
+import { buildReplayScript } from "./replay-script.js";
+export const hackHtml = (input) => {
+    const replayScript = buildReplayScript(input.apiPath, input.baseUrl);
+    const preloadScript = `<script>${buildPreloadScript()}</script>`;
     const head = input.$("head");
     const root = input.$.root();
+    const scriptNodes = input.$("script").toArray();
+    const hasPreload = scriptNodes.some((node) => (input.$(node).html() || "").includes("__pagepocketPatched"));
+    const hasReplay = scriptNodes.some((node) => (input.$(node).html() || "").includes("__pagepocketOriginalFetch"));
     if (head.length) {
-        head.prepend(replayScript);
-        head.prepend(preloadScript);
+        if (!hasReplay) {
+            head.prepend(replayScript);
+        }
+        if (!hasPreload) {
+            head.prepend(preloadScript);
+        }
     }
     else {
-        root.prepend(replayScript);
-        root.prepend(preloadScript);
+        if (!hasReplay) {
+            root.prepend(replayScript);
+        }
+        if (!hasPreload) {
+            root.prepend(preloadScript);
+        }
     }
     if (input.faviconDataUrl) {
         const existingIcon = input.$('link[rel="icon"]');
@@ -29,4 +37,3 @@ const hackHtml = (input) => {
         }
     }
 };
-exports.hackHtml = hackHtml;

package/dist/hackers/index.d.ts

@@ -1,3 +1,3 @@
-import type { ScriptHacker } from "./types";
+import type { ScriptHacker } from "./types.js";
 export declare const preloadHackers: ScriptHacker[];
 export declare const replayHackers: ScriptHacker[];

package/dist/hackers/index.js

@@ -1,28 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replayHackers = exports.preloadHackers = void 0;
-const preload_fetch_1 = require("./preload-fetch");
-const preload_xhr_1 = require("./preload-xhr");
-const replay_beacon_1 = require("./replay-beacon");
-const replay_block_text_fragment_1 = require("./replay-block-text-fragment");
-const replay_css_proxy_1 = require("./replay-css-proxy");
-const replay_dom_rewrite_1 = require("./replay-dom-rewrite");
-const replay_eventsource_1 = require("./replay-eventsource");
-const replay_fetch_1 = require("./replay-fetch");
-const replay_history_path_1 = require("./replay-history-path");
-const replay_svg_image_1 = require("./replay-svg-image");
-const replay_websocket_1 = require("./replay-websocket");
-const replay_xhr_1 = require("./replay-xhr");
-exports.preloadHackers = [preload_fetch_1.preloadFetchRecorder, preload_xhr_1.preloadXhrRecorder];
-exports.replayHackers = [
-    replay_block_text_fragment_1.replayBlockTextFragment,
-    replay_history_path_1.replayHistoryPath,
-    replay_fetch_1.replayFetchResponder,
-    replay_xhr_1.replayXhrResponder,
-    replay_css_proxy_1.replayCssProxy,
-    replay_dom_rewrite_1.replayDomRewriter,
-    replay_svg_image_1.replaySvgImageRewriter,
-    replay_beacon_1.replayBeaconStub,
-    replay_websocket_1.replayWebSocketStub,
-    replay_eventsource_1.replayEventSourceStub
+import { preloadFetchRecorder } from "./preload-fetch.js";
+import { preloadXhrRecorder } from "./preload-xhr.js";
+import { replayBeaconStub } from "./replay-beacon.js";
+import { replayBlockTextFragment } from "./replay-block-text-fragment.js";
+import { replayCssProxy } from "./replay-css-proxy.js";
+import { replayDomRewriter } from "./replay-dom-rewrite.js";
+import { replayEventSourceStub } from "./replay-eventsource.js";
+import { replayFetchResponder } from "./replay-fetch.js";
+import { replayHistoryPath } from "./replay-history-path.js";
+import { replaySvgImageRewriter } from "./replay-svg-image.js";
+import { replayWebSocketStub } from "./replay-websocket.js";
+import { replayXhrResponder } from "./replay-xhr.js";
+export const preloadHackers = [preloadFetchRecorder, preloadXhrRecorder];
+export const replayHackers = [
+    replayBlockTextFragment,
+    replayHistoryPath,
+    replayFetchResponder,
+    replayXhrResponder,
+    replayCssProxy,
+    replayDomRewriter,
+    replaySvgImageRewriter,
+    replayBeaconStub,
+    replayWebSocketStub,
+    replayEventSourceStub
 ];

package/dist/hackers/preload-fetch.d.ts

@@ -1,2 +1,2 @@
-import type { ScriptHacker } from "./types";
+import type { ScriptHacker } from "./types.js";
 export declare const preloadFetchRecorder: ScriptHacker;

package/dist/hackers/preload-fetch.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preloadFetchRecorder = void 0;
-exports.preloadFetchRecorder = {
+export const preloadFetchRecorder = {
     id: "preload-fetch-recorder",
     stage: "preload",
     build: () => `

package/dist/hackers/preload-xhr.d.ts

@@ -1,2 +1,2 @@
-import type { ScriptHacker } from "./types";
+import type { ScriptHacker } from "./types.js";
 export declare const preloadXhrRecorder: ScriptHacker;

package/dist/hackers/preload-xhr.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.preloadXhrRecorder = void 0;
-exports.preloadXhrRecorder = {
+export const preloadXhrRecorder = {
     id: "preload-xhr-recorder",
     stage: "preload",
     build: () => `

package/dist/hackers/replay-beacon.d.ts

@@ -1,2 +1,2 @@
-import type { ScriptHacker } from "./types";
+import type { ScriptHacker } from "./types.js";
 export declare const replayBeaconStub: ScriptHacker;