@pagepocket/lib 0.7.0 → 0.8.0

package/README.md

@@ -14,14 +14,15 @@ pnpm add @pagepocket/lib
 
 ```ts
 import { PagePocket } from "@pagepocket/lib";
-import { CdpAdapter } from "@pagepocket/cdp-adapter";
+import { CaptureHttpCdpUnit } from "@pagepocket/capture-http-cdp-unit";
+import { BuildSnapshotUnit } from "@pagepocket/build-snapshot-unit";
+import { WriteDownUnit } from "@pagepocket/write-down-unit";
 
-const interceptor = new CdpAdapter();
-const snapshot = await PagePocket.fromTarget({ kind: "cdp-tab", tabId: 123 }).capture({
-  interceptor
+const result = await PagePocket.fromCDPTab(123).capture({
+  units: [new CaptureHttpCdpUnit(), new BuildSnapshotUnit(), new WriteDownUnit({ type: "raw", outputPath: "./out" })]
 });
 
-await snapshot.toDirectory("./out");
+// result.kind === "raw" | "zip" | ...
 ```
 
 ## API
@@ -30,7 +31,7 @@ await snapshot.toDirectory("./out");
 class PagePocket {
   static fromURL(url: string, options?: PagePocketOptions): PagePocket;
   static fromTarget(target: InterceptTarget, options?: PagePocketOptions): PagePocket;
-  interceptedRequestEvents(): NetworkEventStream;
+// Network progress events are available via the units runner channel (network@1).
   capture(options?: CaptureOptions): Promise<PageSnapshot>;
 }
 ```

package/dist/build-snapshot-from-bundle.d.ts

@@ -0,0 +1,23 @@
+import type { CaptureBundle } from "./bundle/types";
+import type { ContentStore, PageSnapshot, ReplaceElementsConfig } from "./types";
+export type SnapshotBuildOptions = {
+    rewriteEntry?: boolean;
+    rewriteCSS?: boolean;
+    replaceElements?: ReplaceElementsConfig;
+    /**
+     * Replay-mode snapshot features:
+     * - inject preload/replay scripts (hackers)
+     * - emit /resources_path.json
+     */
+    emitReplayArtifacts?: boolean;
+};
+type BundleContentStore = ContentStore & {
+    /**
+     * Internal-only extension used by snapshot build to store rewritten assets.
+     * Bundle capture itself does not require this.
+     */
+    __pagepocketKind: "bundle-content-store";
+};
+export declare const createBundleContentStore: (bundle: CaptureBundle) => BundleContentStore;
+export declare const buildSnapshotFromBundle: (bundle: CaptureBundle, options: SnapshotBuildOptions) => Promise<PageSnapshot>;
+export {};

package/dist/build-snapshot-from-bundle.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSnapshotFromBundle = exports.createBundleContentStore = void 0;
+const snapshot_builder_1 = require("./snapshot-builder");
+const createBundleContentStore = (bundle) => {
+    const store = {
+        __pagepocketKind: "bundle-content-store",
+        name: "bundle",
+        async put(body) {
+            // Snapshot building rewrites HTML/CSS/JS, which requires creating new ContentRef.
+            // In v1, we store these rewritten bytes in-memory.
+            // (Spec allows breaking changes; this is an internal implementation detail.)
+            if (body.kind === "buffer") {
+                return { kind: "memory", data: body.data };
+            }
+            if (body.kind === "stream") {
+                const reader = body.stream.getReader();
+                const chunks = [];
+                let total = 0;
+                while (true) {
+                    const r = await reader.read();
+                    if (r.done)
+                        break;
+                    if (r.value) {
+                        chunks.push(r.value);
+                        total += r.value.byteLength;
+                    }
+                }
+                const out = new Uint8Array(total);
+                let offset = 0;
+                for (const c of chunks) {
+                    out.set(c, offset);
+                    offset += c.byteLength;
+                }
+                return { kind: "memory", data: out };
+            }
+            if (body.kind === "late") {
+                const bytes = await body.read();
+                return { kind: "memory", data: bytes };
+            }
+            return { kind: "memory", data: new Uint8Array() };
+        },
+        open(ref) {
+            return bundle.content.open(ref);
+        },
+        async dispose() {
+            await bundle.content.dispose?.();
+        }
+    };
+    return store;
+};
+exports.createBundleContentStore = createBundleContentStore;
+const buildSnapshotFromBundle = async (bundle, options) => {
+    const contentStore = (0, exports.createBundleContentStore)(bundle);
+    return (0, snapshot_builder_1.buildSnapshot)({
+        entryUrl: bundle.entryUrl,
+        createdAt: bundle.createdAt,
+        resources: bundle.resources,
+        apiEntries: [],
+        contentStore,
+        rewriteEntry: options.rewriteEntry ?? true,
+        rewriteCSS: options.rewriteCSS ?? true,
+        replaceElements: options.replaceElements,
+        emitReplayArtifacts: options.emitReplayArtifacts,
+        warnings: bundle.warnings ?? []
+    });
+};
+exports.buildSnapshotFromBundle = buildSnapshotFromBundle;

package/dist/builtin-blacklist.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ns = exports.sw_iframe = exports.ga = void 0;
-exports.ga = [/google-analytics/i, /analytics\.google/i];
-exports.sw_iframe = [/sw_iframe\.html/i];
-exports.ns = [/googletagmanager/i];
+export const ga = [/google-analytics/i, /analytics\.google/i];
+export const sw_iframe = [/sw_iframe\.html/i];
+export const ns = [/googletagmanager/i];

package/dist/bundle/from-network-store.d.ts

@@ -0,0 +1,10 @@
+import type { NetworkStore } from "../network-store";
+import type { ContentStoreHandle } from "../types";
+import type { CaptureBundle } from "./types";
+export declare const captureBundleFromNetworkStore: (input: {
+    store: NetworkStore;
+    createdAt: number;
+    entryUrl: string;
+    finalUrl?: string;
+    content: ContentStoreHandle;
+}) => CaptureBundle;

package/dist/bundle/from-network-store.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureBundleFromNetworkStore = void 0;
+const captureBundleFromNetworkStore = (input) => {
+    const requests = input.store.getRequestRecords();
+    const resources = input.store.getResources();
+    const apiRecords = input.store.getApiRecords();
+    const warnings = input.store.getWarnings();
+    const totals = input.store.getTotals();
+    return {
+        version: "1.0",
+        createdAt: input.createdAt,
+        entryUrl: input.entryUrl,
+        finalUrl: input.finalUrl,
+        requests,
+        resources,
+        apiRecords,
+        warnings: warnings.length ? warnings : undefined,
+        totals: {
+            totalBytes: totals.totalBytes,
+            totalResources: resources.length
+        },
+        content: input.content
+    };
+};
+exports.captureBundleFromNetworkStore = captureBundleFromNetworkStore;

package/dist/bundle/types.d.ts

@@ -0,0 +1,32 @@
+import type { NetworkRequestEvent, NetworkRequestFailedEvent, NetworkResponseEvent } from "@pagepocket/interceptor";
+import type { ContentRef, ContentStoreHandle } from "../types";
+export type RequestRecord = {
+    request: NetworkRequestEvent;
+    response?: NetworkResponseEvent;
+    failed?: NetworkRequestFailedEvent;
+};
+export type CapturedResource = {
+    request: NetworkRequestEvent;
+    response: NetworkResponseEvent;
+    contentRef: ContentRef;
+    size: number;
+    mimeType?: string;
+};
+export interface CaptureBundle {
+    version: "1.0";
+    createdAt: number;
+    entryUrl: string;
+    finalUrl?: string;
+    /** requestId -> record */
+    requests: Map<string, RequestRecord>;
+    /** Resources that have bodies stored in ContentStore. */
+    resources: CapturedResource[];
+    /** Structured API records derived from xhr/fetch. */
+    apiRecords: unknown[];
+    warnings?: string[];
+    totals: {
+        totalBytes: number;
+        totalResources: number;
+    };
+    content: ContentStoreHandle;
+}

package/dist/bundle/types.js

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

package/dist/capture/index.d.ts

@@ -0,0 +1,14 @@
+import { NetworkStore } from "../network-store";
+import type { CaptureArtifacts } from "./types";
+/**
+ * Converts `ctx.capture` artifacts into a legacy NetworkStore populated with
+ * request/response/failed events.
+ *
+ * This is a transitional helper so builders can stay pure and reusable while
+ * snapshot building is still implemented in terms of NetworkStore resources.
+ */
+export declare const captureToNetworkStore: (input: {
+    capture: CaptureArtifacts;
+    filter: import("../types").ResourceFilter;
+    limits?: import("../plugin/types").CaptureWithPluginsOptions["limits"];
+}) => Promise<NetworkStore>;

package/dist/capture/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureToNetworkStore = void 0;
+const network_store_1 = require("../network-store");
+const streamToUint8Array = async (stream) => {
+    const reader = stream.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const result = await reader.read();
+        if (result.done)
+            break;
+        if (result.value) {
+            chunks.push(result.value);
+            total += result.value.byteLength;
+        }
+    }
+    const output = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        output.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return output;
+};
+/**
+ * Converts `ctx.capture` artifacts into a legacy NetworkStore populated with
+ * request/response/failed events.
+ *
+ * This is a transitional helper so builders can stay pure and reusable while
+ * snapshot building is still implemented in terms of NetworkStore resources.
+ */
+const captureToNetworkStore = async (input) => {
+    const store = new network_store_1.NetworkStore({
+        contentStore: input.capture.contentStore,
+        filter: input.filter,
+        limits: input.limits
+    });
+    for (const event of input.capture.events) {
+        if (event.type === "http.request") {
+            await store.handleEvent({
+                type: "request",
+                requestId: event.requestId,
+                url: event.url,
+                method: event.method,
+                headers: Object.fromEntries(event.headers.map((h) => [h.name, h.value])),
+                frameId: event.frameId,
+                resourceType: event.resourceType,
+                initiator: event.initiator,
+                timestamp: event.timestamp
+            });
+            continue;
+        }
+        if (event.type === "http.failed") {
+            await store.handleEvent({
+                type: "failed",
+                requestId: event.requestId,
+                url: event.url,
+                errorText: event.errorText,
+                timestamp: event.timestamp
+            });
+            continue;
+        }
+        const bodySource = event.bodyRef
+            ? {
+                kind: "late",
+                read: async () => streamToUint8Array(await input.capture.contentStore.open(event.bodyRef))
+            }
+            : undefined;
+        await store.handleEvent({
+            type: "response",
+            requestId: event.requestId,
+            url: event.url,
+            status: event.status,
+            statusText: event.statusText,
+            headers: Object.fromEntries(event.headers.map((h) => [h.name, h.value])),
+            mimeType: event.mimeType,
+            fromDiskCache: event.fromDiskCache,
+            fromServiceWorker: event.fromServiceWorker,
+            timestamp: event.timestamp,
+            ...(bodySource ? { body: bodySource } : {})
+        });
+    }
+    return store;
+};
+exports.captureToNetworkStore = captureToNetworkStore;

package/dist/capture/memory-content-store.d.ts

@@ -0,0 +1,4 @@
+import type { ContentStore } from "../types";
+export declare const createMemoryContentStore: (name?: string) => (ContentStore & {
+    _bytes: Map<string, Uint8Array>;
+}) | ContentStore;

package/dist/capture/memory-content-store.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryContentStore = void 0;
+const streams_1 = require("../utils/streams");
+const utils_1 = require("../utils");
+const createMemoryContentStore = (name = "memory") => {
+    const bytesById = new Map();
+    let nextId = 1;
+    const storeBytes = (bytes) => {
+        const id = String(nextId);
+        nextId += 1;
+        bytesById.set(id, bytes);
+        return id;
+    };
+    const getStoredBytes = (id) => {
+        const bytes = bytesById.get(id);
+        if (!bytes) {
+            throw new Error(`Missing memory content for ref id=${id}`);
+        }
+        return bytes;
+    };
+    return {
+        name,
+        _bytes: bytesById,
+        async put(body, _meta) {
+            const bytes = await (0, utils_1.toUint8Array)(body);
+            const id = storeBytes(bytes);
+            return { kind: "store-ref", id };
+        },
+        async open(ref) {
+            if (ref.kind === "memory") {
+                return (0, streams_1.streamFromUint8Array)(ref.data);
+            }
+            const bytes = getStoredBytes(ref.id);
+            return (0, streams_1.streamFromUint8Array)(bytes);
+        },
+        async dispose() {
+            bytesById.clear();
+        }
+    };
+};
+exports.createMemoryContentStore = createMemoryContentStore;

package/dist/capture/types.d.ts

@@ -0,0 +1,61 @@
+import type { ContentRef, ContentStore, ResourceType } from "../types";
+export type Header = {
+    name: string;
+    value: string;
+};
+export type CaptureBodyRef = ContentRef;
+export type CaptureCapabilities = {
+    requestHeaders: "sent" | "approx" | "none";
+    responseHeaders: "raw" | "approx" | "none";
+    requestBodies: boolean;
+    responseBodies: "decoded" | "wire" | "none";
+    httpVersion: boolean;
+    remoteIp: boolean;
+    headerOrderPreserved: boolean;
+};
+export type CaptureRequestEvent = {
+    type: "http.request";
+    requestId: string;
+    url: string;
+    method: string;
+    headers: Header[];
+    timestamp: number;
+    frameId?: string;
+    resourceType?: ResourceType;
+    initiator?: {
+        type?: string;
+        url?: string;
+    };
+};
+export type CaptureResponseEvent = {
+    type: "http.response";
+    requestId: string;
+    url: string;
+    status: number;
+    statusText?: string;
+    headers: Header[];
+    timestamp: number;
+    mimeType?: string;
+    fromDiskCache?: boolean;
+    fromServiceWorker?: boolean;
+    bodyRef?: CaptureBodyRef;
+    bodySize?: number;
+};
+export type CaptureFailedEvent = {
+    type: "http.failed";
+    requestId: string;
+    url: string;
+    errorText: string;
+    timestamp: number;
+};
+export type CaptureEvent = CaptureRequestEvent | CaptureResponseEvent | CaptureFailedEvent;
+export type CaptureArtifacts = {
+    /** Ordered list of captured network events. */
+    events: CaptureEvent[];
+    /** Content store containing captured bodies referenced by events. */
+    contentStore: ContentStore;
+    capabilities: CaptureCapabilities;
+};
+export type CaptureContext = {
+    capture?: CaptureArtifacts;
+};

package/dist/capture/types.js

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

package/dist/content-store.js

@@ -36,15 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HybridContentStore = void 0;
 const uni_fs_1 = require("@pagepocket/uni-fs");
 const utils_1 = require("./utils");
+const streams_1 = require("./utils/streams");
 const DEFAULT_THRESHOLD = 256 * 1024;
 const DEFAULT_BASE_DIR = ".pagepocket_store";
 const nowId = () => `${Date.now()}_${Math.random().toString(16).slice(2)}`;
-const streamFromBytes = (data) => new ReadableStream({
-    start(controller) {
-        controller.enqueue(data);
-        controller.close();
-    }
-});
 const isNodeEnvironment = () => {
     const globalProcess = globalThis.process;
     return typeof globalProcess?.versions?.node === "string";
@@ -69,10 +64,10 @@ class HybridContentStore {
     }
     async open(ref) {
         if (ref.kind === "memory") {
-            return streamFromBytes(ref.data);
+            return (0, streams_1.streamFromUint8Array)(ref.data);
         }
         const data = await (0, uni_fs_1.readBinary)(`${this.baseDir}/${ref.id}`, "bin");
-        return streamFromBytes(data);
+        return (0, streams_1.streamFromUint8Array)(data);
     }
     async dispose() {
         const entries = Array.from(this.storedIds);

package/dist/content-type.d.ts

@@ -1,2 +1,2 @@
-export declare const extensionFromContentType: (contentType?: string | null) => "" | ".css" | ".js" | ".png" | ".jpg" | ".gif" | ".svg" | ".woff2" | ".woff";
+export { extensionFromContentType } from "@pagepocket/shared";
 export declare const isTextResponse: (contentType: string) => boolean;

package/dist/content-type.js

@@ -1,30 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTextResponse = exports.extensionFromContentType = void 0;
-const extensionFromContentType = (contentType) => {
-    if (!contentType) {
-        return "";
-    }
-    if (contentType.includes("text/css"))
-        return ".css";
-    if (contentType.includes("javascript"))
-        return ".js";
-    if (contentType.includes("image/png"))
-        return ".png";
-    if (contentType.includes("image/jpeg"))
-        return ".jpg";
-    if (contentType.includes("image/gif"))
-        return ".gif";
-    if (contentType.includes("image/svg"))
-        return ".svg";
-    if (contentType.includes("font/woff2"))
-        return ".woff2";
-    if (contentType.includes("font/woff"))
-        return ".woff";
-    return "";
-};
-exports.extensionFromContentType = extensionFromContentType;
-const isTextResponse = (contentType) => {
+export { extensionFromContentType } from "@pagepocket/shared";
+export const isTextResponse = (contentType) => {
     const lowered = contentType.toLowerCase();
     return (lowered.startsWith("text/") ||
         lowered.includes("json") ||
@@ -33,4 +8,3 @@ const isTextResponse = (contentType) => {
         lowered.includes("svg") ||
         lowered.includes("html"));
 };
-exports.isTextResponse = isTextResponse;

package/dist/core/_impl/completion.d.ts

@@ -0,0 +1,4 @@
+import type { CompletionStrategy } from "../../types";
+export declare const timeout: (ms: number) => CompletionStrategy;
+export declare const networkIdle: (ms: number, checkInterval?: number) => CompletionStrategy;
+export declare const normalizeCompletion: (completion?: CompletionStrategy | CompletionStrategy[]) => CompletionStrategy[];

package/dist/core/_impl/completion.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCompletion = exports.networkIdle = exports.timeout = void 0;
+const utils_1 = require("../../utils");
+const timeout = (ms) => ({
+    async wait() {
+        await (0, utils_1.sleep)(ms);
+    }
+});
+exports.timeout = timeout;
+const networkIdle = (ms, checkInterval = 100) => ({
+    async wait(ctx) {
+        while (true) {
+            const stats = ctx.getStats();
+            const idleFor = ctx.now() - stats.lastNetworkTs;
+            if (stats.inflightRequests === 0 && idleFor >= ms) {
+                return;
+            }
+            await (0, utils_1.sleep)(Math.min(checkInterval, ms));
+        }
+    }
+});
+exports.networkIdle = networkIdle;
+const normalizeCompletion = (completion) => {
+    if (!completion)
+        return [];
+    return Array.isArray(completion) ? completion : [completion];
+};
+exports.normalizeCompletion = normalizeCompletion;

package/dist/core/_impl/content-store.d.ts

@@ -0,0 +1,21 @@
+import type { BodySource, ContentRef, ContentStore } from "../../types";
+type HybridContentStoreOptions = {
+    thresholdBytes?: number;
+    baseDir?: string;
+};
+export declare class HybridContentStore implements ContentStore {
+    name: string;
+    private thresholdBytes;
+    private baseDir;
+    private storedIds;
+    constructor(options?: HybridContentStoreOptions);
+    put(body: BodySource, meta: {
+        url: string;
+        mimeType?: string;
+        sizeHint?: number;
+    }): Promise<ContentRef>;
+    open(ref: ContentRef): Promise<ReadableStream<Uint8Array>>;
+    dispose(): Promise<void>;
+    private removeBaseDir;
+}
+export {};

package/dist/core/_impl/content-store.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridContentStore = void 0;
+const uni_fs_1 = require("@pagepocket/uni-fs");
+const utils_1 = require("../../utils");
+const streams_1 = require("../../utils/streams");
+const DEFAULT_THRESHOLD = 256 * 1024;
+const DEFAULT_BASE_DIR = ".pagepocket_store";
+const nowId = () => `${Date.now()}_${Math.random().toString(16).slice(2)}`;
+const isNodeEnvironment = () => {
+    const globalProcess = globalThis.process;
+    return typeof globalProcess?.versions?.node === "string";
+};
+class HybridContentStore {
+    constructor(options) {
+        this.name = "hybrid";
+        this.storedIds = new Set();
+        this.thresholdBytes = options?.thresholdBytes ?? DEFAULT_THRESHOLD;
+        this.baseDir = options?.baseDir ?? DEFAULT_BASE_DIR;
+    }
+    async put(body, meta) {
+        const data = await (0, utils_1.toUint8Array)(body);
+        const size = data.byteLength;
+        if (size <= this.thresholdBytes) {
+            return { kind: "memory", data };
+        }
+        const id = `${(0, utils_1.hashString)(meta.url)}_${nowId()}`;
+        await (0, uni_fs_1.write)(`${this.baseDir}/${id}`, "bin", data);
+        this.storedIds.add(id);
+        return { kind: "store-ref", id };
+    }
+    async open(ref) {
+        if (ref.kind === "memory") {
+            return (0, streams_1.streamFromUint8Array)(ref.data);
+        }
+        const data = await (0, uni_fs_1.readBinary)(`${this.baseDir}/${ref.id}`, "bin");
+        return (0, streams_1.streamFromUint8Array)(data);
+    }
+    async dispose() {
+        const entries = Array.from(this.storedIds);
+        this.storedIds.clear();
+        await Promise.all(entries.map((id) => (0, uni_fs_1.remove)(`${this.baseDir}/${id}`, "bin").catch(() => { })));
+        await this.removeBaseDir().catch(() => { });
+    }
+    async removeBaseDir() {
+        if (!isNodeEnvironment()) {
+            return;
+        }
+        if (!this.baseDir || this.baseDir === "/" || this.baseDir === ".") {
+            return;
+        }
+        const { resolve, isAbsolute } = await Promise.resolve().then(() => __importStar(require("node:path")));
+        const { rm } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+        const target = isAbsolute(this.baseDir) ? this.baseDir : resolve(this.baseDir);
+        await rm(target, { recursive: true, force: true });
+    }
+}
+exports.HybridContentStore = HybridContentStore;

package/dist/core/_impl/debug.d.ts

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

package/dist/core/_impl/debug.js

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