@hraness/sponge 0.6.8 → 0.6.10

package/dist/contracts/index.d.ts

@@ -60,6 +60,8 @@ export interface CaptureResult extends Envelope {
         text: 'complete' | 'partial';
         images: 'complete' | 'partial' | 'not-requested';
     };
+    /** The page came through the reader's own browser and sign-ins. */
+    browser?: true;
 }
 export interface Transcript extends Envelope {
     source: 'human-captions' | 'automatic-captions' | 'local-asr';

package/dist/src/acquisition/capture.d.ts

@@ -11,6 +11,10 @@ export interface CaptureRequest {
     sourceUrl: string;
     requestId: string;
     connection?: CaptureConnection;
+    browser?: {
+        socket: string;
+        mode: 'always' | 'fallback';
+    };
     signal?: AbortSignal;
     deadlineMs?: number;
     allowPrivateNetwork?: boolean;

package/dist/src/acquisition/capture.js

@@ -12,10 +12,15 @@ function validSource(sourceUrl) {
     }
 }
 export function captureArticle(request) {
-    const endpoint = request.connection?.endpoint;
+    const endpoint = request.connection?.endpoint, browser = request.browser;
     return superviseChild({
         ...request,
-        valid: validSource(request.sourceUrl) && (endpoint === undefined || loopbackEndpoint.test(endpoint)),
+        valid: validSource(request.sourceUrl) &&
+            (endpoint === undefined || loopbackEndpoint.test(endpoint)) &&
+            (browser === undefined ||
+                (browser.socket.startsWith('/') &&
+                    browser.socket.length < 104 &&
+                    ['always', 'fallback'].includes(browser.mode))),
         prepare: async ({ output, deadline }) => ({
             schemaVersion: 1,
             kind: 'article',
@@ -28,6 +33,7 @@ export function captureArticle(request) {
             maxTotalAssetBytes: 500 * 1024 ** 2,
             allowPrivateNetwork: request.allowPrivateNetwork === true,
             ...(endpoint === undefined ? {} : { cdp: endpoint }),
+            ...(browser === undefined ? {} : { browser: { socket: browser.socket, mode: browser.mode } }),
         }),
         verify: (bundleRoot) => normalizeBundle({ bundleRoot, requestId: request.requestId, sourceUrl: request.sourceUrl }),
     });

package/dist/src/acquisition/child-request.d.ts

@@ -14,6 +14,11 @@ export interface ArticleChildRequest extends ChildRequestBase {
     maxHtmlBytes: number;
     /** A loopback DevTools endpoint of the user's attached signed-in browser. */
     cdp?: string;
+    /** The Sponge browser bridge socket: `always` captures only through it, `fallback` when the public page is thin. */
+    browser?: {
+        socket: string;
+        mode: 'always' | 'fallback';
+    };
 }
 export interface PdfChildRequest extends ChildRequestBase {
     kind: 'pdf';

package/dist/src/acquisition/normalize.js

@@ -93,6 +93,9 @@ export async function normalizeBundle(input) {
         extractor: { ...captureExtractor },
         manifestSha256: hash(manifestBytes),
         completeness: { text, images: imageStatus },
+        ...(/^browser-(?:fetch|render)$/.test(String(manifest.acquisition?.method))
+            ? { browser: true }
+            : {}),
     };
     validateCapture(capture);
     return capture;

package/dist/src/app/article.d.ts

@@ -16,6 +16,8 @@ export interface ArticleOptions {
     checkpoint?: (stage: JobCheckpoint['stage']) => Promise<void>;
     runProcess?: CaptureRequest['runProcess'];
     connection?: CaptureConnection;
+    /** The Sponge browser bridge socket: a thin public page is retried there, and `--browser` sources only use it. */
+    browser?: string;
     signal?: AbortSignal;
     allowPrivateNetwork?: boolean;
     capture?: (request: CaptureRequest) => Promise<CaptureOutcome>;

package/dist/src/app/article.js

@@ -25,9 +25,7 @@ export function ingestArticle(store, token, options) {
         if (!source || source.kind !== 'article')
             throw new SpongeError('invalid-input');
         // An archived copy is public: it is fetched directly, never through a signed-in browser.
-        const snapshot = source.archive
-            ? await (options.snapshot ?? waybackSnapshot)(source.locator, token.attemptId)
-            : null;
+        const snapshot = source.via === 'archive' ? await (options.snapshot ?? waybackSnapshot)(source.locator, token.attemptId) : null;
         if (snapshot && 'ok' in snapshot)
             return snapshot;
         const fetched = snapshot?.url ?? source.locator;
@@ -37,6 +35,10 @@ export function ingestArticle(store, token, options) {
             sourceUrl: fetched,
             requestId: token.attemptId,
             connection: snapshot ? undefined : options.connection,
+            // An archived copy or an attached connection already names its route; the browser is never asked for it.
+            ...(snapshot || options.connection || !options.browser
+                ? {}
+                : { browser: { socket: options.browser, mode: source.via === 'browser' ? 'always' : 'fallback' } }),
             signal: options.signal,
             allowPrivateNetwork: options.allowPrivateNetwork,
         });
@@ -83,6 +85,8 @@ export function ingestArticle(store, token, options) {
                     assets: pdf.assets,
                     warnings: pdf.warnings,
                 });
+                if (capture.browser)
+                    keepPrivate(store, source.itemId);
                 return { ok: true, itemId: source.itemId, revisionId: revision.revisionId, status: pdf.status };
             }
             // Without the paper, the landing page is still what the reader saved.
@@ -118,9 +122,19 @@ export function ingestArticle(store, token, options) {
             assets,
             warnings: [...new Set([...capture.warnings, ...(localized.missingImages ? ['partial'] : [])])],
         });
+        if (capture.browser)
+            keepPrivate(store, source.itemId);
         return { ok: true, itemId: source.itemId, revisionId: revision.revisionId, status };
     });
 }
+/**
+ * A page read with the reader's sign-ins is private, even when the item was shared before: what the browser read may
+ * be the subscriber's text. `sponge visibility ITEM public` shares it again deliberately.
+ */
+function keepPrivate(store, itemId) {
+    if (store.identity(itemId).visibility.override !== 'private')
+        store.setVisibility(itemId, 'private');
+}
 /** Prose words under which a page that names its paper's PDF is only a landing page: a title, authors and abstract. */
 const landingPageWords = 1000;
 /**

package/dist/src/browser/bridge.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The Sponge browser bridge. The Sponge extension in the reader's own browser opens a native-messaging port; the
+ * browser starts `host.ts`, which listens on a private local socket. A capture asks over that socket, and the
+ * extension loads the page with the reader's own sign-ins. Cookies and passwords never leave the browser: Sponge
+ * receives only the page.
+ */
+export declare const hostName = "com.hraness.sponge";
+/** Derived from the public key in extension/manifest.json, so an unpacked or store install keeps one identity. */
+export declare const extensionId = "pcekakbinokokbcfdpgdljpeoiceoejf";
+/** `fetch` asks with the reader's cookies and reads the HTML; `render` loads the page in a background window. */
+export type BrowserOperation = 'fetch' | 'render';
+export interface BrowserPage {
+    ok: true;
+    html: string;
+    finalUrl: string;
+    title?: string;
+}
+/** `disabled`: the reader turned background captures off. `offline`: no browser has the extension running. */
+export interface BrowserRefusal {
+    ok: false;
+    code: 'disabled' | 'offline' | 'failed' | 'timeout' | 'not-html' | 'too-large';
+    status?: number;
+}
+export interface BrowserStatus {
+    ok: true;
+    extension: string;
+    background: boolean;
+}
+/** One bridge per library: a short path, because a Unix socket path is limited to 104 bytes on macOS. */
+export declare function bridgeSocket(libraryRoot: string, home?: string): string;
+/** Native messaging frames: a 32-bit length in the host's byte order (little-endian on every supported Mac), then JSON. */
+export declare function encodeFrame(message: unknown): Buffer;
+/** Splits complete frames off `buffer`; the rest waits for more bytes. A frame over `maxBytes` is refused. */
+export declare function decodeFrames(buffer: Buffer, maxBytes: number): {
+    messages: unknown[];
+    rest: Buffer;
+};
+/** Requests over the socket are one JSON line each way; the bridge closes after its answer. */
+export declare function askBridge(socket: string, request: {
+    op: 'status';
+} | {
+    op: BrowserOperation;
+    url: string;
+    timeoutMs: number;
+}, options: {
+    timeoutMs: number;
+    maxBytes: number;
+}): Promise<BrowserPage | BrowserRefusal | BrowserStatus>;

package/dist/src/browser/bridge.js

@@ -0,0 +1,90 @@
+import { createConnection } from 'node:net';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { sha256 } from '../util/hash.js';
+/**
+ * The Sponge browser bridge. The Sponge extension in the reader's own browser opens a native-messaging port; the
+ * browser starts `host.ts`, which listens on a private local socket. A capture asks over that socket, and the
+ * extension loads the page with the reader's own sign-ins. Cookies and passwords never leave the browser: Sponge
+ * receives only the page.
+ */
+export const hostName = 'com.hraness.sponge';
+/** Derived from the public key in extension/manifest.json, so an unpacked or store install keeps one identity. */
+export const extensionId = 'pcekakbinokokbcfdpgdljpeoiceoejf';
+/** One bridge per library: a short path, because a Unix socket path is limited to 104 bytes on macOS. */
+export function bridgeSocket(libraryRoot, home = homedir()) {
+    return join(home, '.local', 'state', 'sponge', sha256(libraryRoot).slice(0, 16) + '.sock');
+}
+/** Native messaging frames: a 32-bit length in the host's byte order (little-endian on every supported Mac), then JSON. */
+export function encodeFrame(message) {
+    const body = Buffer.from(JSON.stringify(message), 'utf8'), frame = Buffer.alloc(4 + body.length);
+    frame.writeUInt32LE(body.length, 0);
+    body.copy(frame, 4);
+    return frame;
+}
+/** Splits complete frames off `buffer`; the rest waits for more bytes. A frame over `maxBytes` is refused. */
+export function decodeFrames(buffer, maxBytes) {
+    const messages = [];
+    let offset = 0;
+    while (buffer.length - offset >= 4) {
+        const length = buffer.readUInt32LE(offset);
+        if (length > maxBytes)
+            throw new Error('native message exceeds its limit');
+        if (buffer.length - offset - 4 < length)
+            break;
+        messages.push(JSON.parse(buffer.subarray(offset + 4, offset + 4 + length).toString('utf8')));
+        offset += 4 + length;
+    }
+    return { messages, rest: buffer.subarray(offset) };
+}
+/** Requests over the socket are one JSON line each way; the bridge closes after its answer. */
+export function askBridge(socket, request, options) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        let bytes = 0, settled = false;
+        const done = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            connection.destroy();
+            resolve(value);
+        };
+        const connection = createConnection(socket);
+        const timer = setTimeout(() => done({ ok: false, code: 'timeout' }), options.timeoutMs);
+        connection.on('connect', () => connection.write(JSON.stringify(request) + '\n'));
+        connection.on('data', (chunk) => {
+            bytes += chunk.length;
+            if (bytes > options.maxBytes)
+                return done({ ok: false, code: 'too-large' });
+            chunks.push(chunk);
+            const text = Buffer.concat(chunks).toString('utf8'), end = text.indexOf('\n');
+            if (end < 0)
+                return;
+            try {
+                done(answer(JSON.parse(text.slice(0, end))));
+            }
+            catch {
+                done({ ok: false, code: 'failed' });
+            }
+        });
+        connection.on('error', () => done({ ok: false, code: 'offline' }));
+        connection.on('close', () => done({ ok: false, code: 'failed' }));
+    });
+}
+const refusals = new Set(['disabled', 'offline', 'failed', 'timeout', 'not-html', 'too-large']);
+/** The bridge relays what the extension says; only these shapes pass. */
+function answer(value) {
+    if (value?.ok === true && typeof value.html === 'string' && typeof value.finalUrl === 'string')
+        return {
+            ok: true,
+            html: value.html,
+            finalUrl: value.finalUrl,
+            ...(typeof value.title === 'string' ? { title: value.title } : {}),
+        };
+    if (value?.ok === true && typeof value.extension === 'string' && typeof value.background === 'boolean')
+        return { ok: true, extension: value.extension, background: value.background };
+    if (value?.ok === false && refusals.has(value.code))
+        return { ok: false, code: value.code, ...(Number.isInteger(value.status) ? { status: value.status } : {}) };
+    return { ok: false, code: 'failed' };
+}

package/dist/src/browser/host.d.ts

@@ -0,0 +1,10 @@
+export interface HostOptions {
+    library: string;
+    socket: string;
+    input: NodeJS.ReadableStream;
+    output: NodeJS.WritableStream;
+    /** The caller's origin, as the browser passes it; anything but the Sponge extension is refused. */
+    origin?: string;
+}
+/** Relays capture requests from the socket to the extension and saves the pages the reader sends. */
+export declare function runHost(options: HostOptions): Promise<void>;

package/dist/src/browser/host.js

@@ -0,0 +1,147 @@
+// The native-messaging host the browser starts for the Sponge extension. stdout carries only frames to the extension.
+import { randomUUID } from 'node:crypto';
+import { chmodSync, mkdirSync, realpathSync, rmSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { dirname } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { decodeFrames, encodeFrame, extensionId } from './bridge.js';
+import { inferKind, articleSource } from '../app/source.js';
+import { pdfSource } from '../pdf/source.js';
+import { openLibrary } from '../store/open.js';
+/** Chrome accepts messages to the extension up to 1 MB and sends up to 64 MiB; Sponge caps a page lower. */
+const maxInboundBytes = 32 * 1024 ** 2;
+/** Relays capture requests from the socket to the extension and saves the pages the reader sends. */
+export function runHost(options) {
+    if (options.origin !== undefined && options.origin !== `chrome-extension://${extensionId}/`)
+        return Promise.reject(new Error('unexpected caller'));
+    const pending = new Map();
+    let hello;
+    const send = (message) => options.output.write(encodeFrame(message));
+    mkdirSync(dirname(options.socket), { recursive: true, mode: 0o700 });
+    chmodSync(dirname(options.socket), 0o700);
+    // The newest browser to start the host serves the library; a stale socket from a crash is replaced.
+    rmSync(options.socket, { force: true });
+    const server = createServer((client) => serve(client));
+    server.listen(options.socket, () => chmodSync(options.socket, 0o600));
+    function serve(client) {
+        let buffered = '';
+        const reply = (value) => client.end(JSON.stringify(value) + '\n');
+        client.setEncoding('utf8');
+        client.on('error', () => undefined);
+        client.on('data', (chunk) => {
+            buffered += chunk;
+            if (buffered.length > 64 * 1024)
+                return client.destroy();
+            const end = buffered.indexOf('\n');
+            if (end < 0)
+                return;
+            let request;
+            try {
+                request = JSON.parse(buffered.slice(0, end));
+            }
+            catch {
+                return reply({ ok: false, code: 'failed' });
+            }
+            if (request?.op === 'status')
+                return reply(hello ? { ok: true, ...hello } : { ok: false, code: 'offline' });
+            const op = request?.op;
+            if ((op !== 'fetch' && op !== 'render') || !web(request.url) || !Number.isInteger(request.timeoutMs))
+                return reply({ ok: false, code: 'failed' });
+            if (!hello)
+                return reply({ ok: false, code: 'offline' });
+            if (!hello.background)
+                return reply({ ok: false, code: 'disabled' });
+            const id = randomUUID(), timeoutMs = Math.min(Math.max(request.timeoutMs, 1000), 120_000), timer = setTimeout(() => finish({ ok: false, code: 'timeout' }), timeoutMs + 5000);
+            const finish = (value) => {
+                clearTimeout(timer);
+                pending.delete(id);
+                reply(value);
+            };
+            pending.set(id, { reply: finish });
+            send({ id, op, url: request.url, timeoutMs });
+        });
+    }
+    async function save(requestId, url) {
+        if (typeof requestId !== 'string' || requestId.length > 64)
+            return;
+        const kind = typeof url === 'string' && web(url) ? inferKind(url) : 'media';
+        if (kind === 'media')
+            return send({ type: 'saved', requestId, ok: false, code: 'unsupported' });
+        try {
+            const store = await openLibrary(options.library);
+            try {
+                const source = (kind === 'pdf' ? pdfSource : articleSource)(url);
+                // A page saved from the browser captures through it: the reader is looking at the page they want kept.
+                const submission = store.queue.submit({
+                    kind,
+                    ...source,
+                    intent: kind === 'article' ? 'browser' : 'save',
+                    idempotencyKey: randomUUID(),
+                });
+                send({ type: 'saved', requestId, ok: true, itemId: submission.itemId });
+            }
+            finally {
+                store.close();
+            }
+        }
+        catch {
+            send({ type: 'saved', requestId, ok: false, code: 'failed' });
+        }
+    }
+    return new Promise((resolve) => {
+        let buffer = Buffer.alloc(0);
+        options.input.on('data', (chunk) => {
+            let decoded;
+            try {
+                decoded = decodeFrames(Buffer.concat([buffer, chunk]), maxInboundBytes);
+            }
+            catch {
+                return stop();
+            }
+            buffer = decoded.rest;
+            for (const message of decoded.messages) {
+                if (message?.type === 'hello' || message?.type === 'settings')
+                    hello = {
+                        extension: String(message.version ?? hello?.extension ?? ''),
+                        background: message.background !== false,
+                    };
+                else if (message?.type === 'save')
+                    void save(message.requestId, message.url);
+                else if (typeof message?.id === 'string')
+                    pending.get(message.id)?.reply(message.ok ? message : refusal(message));
+            }
+        });
+        const stop = () => {
+            for (const { reply } of pending.values())
+                reply({ ok: false, code: 'offline' });
+            server.close();
+            rmSync(options.socket, { force: true });
+            resolve();
+        };
+        options.input.on('end', stop);
+        options.input.on('error', stop);
+    });
+}
+const web = (value) => {
+    if (typeof value !== 'string' || value.length > 16384)
+        return false;
+    try {
+        const url = new URL(value);
+        return (url.protocol === 'https:' || url.protocol === 'http:') && !url.username && !url.password;
+    }
+    catch {
+        return false;
+    }
+};
+const refusal = (message) => ({
+    ok: false,
+    code: message.code,
+    ...(Number.isInteger(message.status) ? { status: message.status } : {}),
+});
+// Started by the wrapper `sponge browser setup` writes: --library ROOT --socket PATH, then the browser's own arguments.
+if (process.argv[1] && import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href) {
+    const [, , flag1, library, flag2, socket, origin] = process.argv;
+    if (flag1 !== '--library' || flag2 !== '--socket' || !library || !socket)
+        process.exit(2);
+    runHost({ library, socket, origin, input: process.stdin, output: process.stdout }).then(() => process.exit(0), () => process.exit(1));
+}

package/dist/src/browser/setup.d.ts

@@ -0,0 +1,26 @@
+export interface BrowserSetupOptions {
+    home?: string;
+    /** Extra NativeMessagingHosts directories, such as a custom `--user-data-dir`'s. */
+    hostsDirs?: string[];
+}
+/**
+ * Registers the native host with each installed browser for one library. The host is a wrapper script, since a
+ * manifest names one executable and takes no arguments; it runs this Node and this Sponge's host.
+ */
+export declare function setupBrowser(libraryRoot: string, options?: BrowserSetupOptions): Promise<{
+    registered: string[];
+    extension: string;
+    extensionId: string;
+}>;
+/** Which browsers have the host registered, and whether an extension is connected for this library now. */
+export declare function browserStatus(libraryRoot: string, options?: BrowserSetupOptions): Promise<{
+    extension?: string | undefined;
+    background?: boolean | undefined;
+    registered: string[];
+    bound: boolean;
+    connected: boolean;
+}>;
+/** Removes the registrations that point at Sponge's host; another program's manifest is left alone. */
+export declare function removeBrowser(options?: BrowserSetupOptions): Promise<{
+    removed: string[];
+}>;

package/dist/src/browser/setup.js

@@ -0,0 +1,103 @@
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { askBridge, bridgeSocket, extensionId, hostName } from './bridge.js';
+/** Where each Chromium browser on macOS looks for user-level native messaging hosts. */
+const browsers = {
+    Chrome: 'Google/Chrome',
+    'Chrome Beta': 'Google/Chrome Beta',
+    'Chrome Canary': 'Google/Chrome Canary',
+    Chromium: 'Chromium',
+    Brave: 'BraveSoftware/Brave-Browser',
+    Edge: 'Microsoft Edge',
+    Arc: 'Arc/User Data',
+    Vivaldi: 'Vivaldi',
+};
+const manifestName = `${hostName}.json`;
+/** The installed browsers' host directories, plus any the reader named. */
+function hostDirectories(options) {
+    const support = join(options.home ?? homedir(), 'Library', 'Application Support');
+    return [
+        ...Object.entries(browsers)
+            .filter(([, data]) => existsSync(join(support, data)))
+            .map(([browser, data]) => ({ browser, dir: join(support, data, 'NativeMessagingHosts') })),
+        ...(options.hostsDirs ?? []).map((dir) => ({ browser: 'custom', dir })),
+    ];
+}
+const wrapperPath = (home) => join(home, '.local', 'state', 'sponge', 'browser-host');
+/** The unpacked extension that ships with this Sponge. */
+function extensionDirectory() {
+    return fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? '../../extension/' : '../../../extension/', import.meta.url));
+}
+const quote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+/**
+ * Registers the native host with each installed browser for one library. The host is a wrapper script, since a
+ * manifest names one executable and takes no arguments; it runs this Node and this Sponge's host.
+ */
+export async function setupBrowser(libraryRoot, options = {}) {
+    const home = options.home ?? homedir(), wrapper = wrapperPath(home), host = fileURLToPath(new URL('./host.js', import.meta.url));
+    await mkdir(dirname(wrapper), { recursive: true, mode: 0o700 });
+    await writeFile(wrapper, `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(host)} --library ${quote(libraryRoot)} --socket ${quote(bridgeSocket(libraryRoot, home))} "$@"\n`, { mode: 0o700 });
+    await chmod(wrapper, 0o700);
+    const manifest = JSON.stringify({
+        name: hostName,
+        description: 'Sponge: save pages with your own sign-ins',
+        path: wrapper,
+        type: 'stdio',
+        allowed_origins: [`chrome-extension://${extensionId}/`],
+    }, null, 2);
+    const registered = [];
+    for (const { browser, dir } of hostDirectories(options)) {
+        await mkdir(dir, { recursive: true });
+        await writeFile(join(dir, manifestName), manifest + '\n', { mode: 0o644 });
+        registered.push(browser);
+    }
+    return { registered, extension: extensionDirectory(), extensionId };
+}
+/** Which browsers have the host registered, and whether an extension is connected for this library now. */
+export async function browserStatus(libraryRoot, options = {}) {
+    const home = options.home ?? homedir(), wrapper = wrapperPath(home), registered = [];
+    for (const { browser, dir } of hostDirectories(options)) {
+        try {
+            if (JSON.parse(await readFile(join(dir, manifestName), 'utf8')).path === wrapper)
+                registered.push(browser);
+        }
+        catch {
+            // Not registered with this browser.
+        }
+    }
+    let bound = false;
+    try {
+        bound = (await readFile(wrapper, 'utf8')).includes(quote(bridgeSocket(libraryRoot, home)));
+    }
+    catch {
+        bound = false;
+    }
+    const answer = await askBridge(bridgeSocket(libraryRoot, home), { op: 'status' }, { timeoutMs: 3000, maxBytes: 4096 });
+    return {
+        registered,
+        bound,
+        connected: answer.ok,
+        ...(answer.ok && 'background' in answer ? { extension: answer.extension, background: answer.background } : {}),
+    };
+}
+/** Removes the registrations that point at Sponge's host; another program's manifest is left alone. */
+export async function removeBrowser(options = {}) {
+    const home = options.home ?? homedir(), wrapper = wrapperPath(home), removed = [];
+    for (const { browser, dir } of hostDirectories(options)) {
+        const file = join(dir, manifestName);
+        try {
+            if (JSON.parse(await readFile(file, 'utf8')).path !== wrapper)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        await rm(file, { force: true });
+        removed.push(browser);
+    }
+    await rm(wrapper, { force: true });
+    return { removed };
+}

package/dist/src/capture/types.d.ts

@@ -1,5 +1,5 @@
 export type CaptureScope = 'auto' | 'page' | 'thread' | 'comments';
-export type AcquisitionMethod = 'http' | 'hacker-news-api' | 'bluesky-api' | 'reddit-json' | 'browser-cdp';
+export type AcquisitionMethod = 'http' | 'hacker-news-api' | 'bluesky-api' | 'reddit-json' | 'browser-cdp' | 'browser-fetch' | 'browser-render';
 export type AcquiredPage = {
     readonly body: string;
     readonly contentType: string | null;