@hraness/sponge 0.4.1 → 0.5.1

package/dist/src/acquisition/runtime.js

@@ -12,7 +12,7 @@ const installDeadlineMs = 30 * 60 * 1000;
 function checkPins(pins) {
     if (!/^[a-z0-9][a-z0-9.-]{0,99}$/.test(pins.id) || hash(pins.lockfile) !== pins.lockSha256)
         throw new SpongeError('invalid-input');
-    for (const pin of [pins.bun, pins.ghostget, pins.wordcell]) {
+    for (const pin of [pins.bun, pins.wordcell]) {
         let url;
         try {
             url = new URL(pin.url);
@@ -36,7 +36,7 @@ function checkPins(pins) {
 }
 export function captureSetupPlan(pins) {
     checkPins(pins);
-    const artifacts = [pins.bun, pins.ghostget, pins.wordcell], downloadBytes = artifacts.reduce((n, a) => n + a.bytes, 0);
+    const artifacts = [pins.bun, pins.wordcell], downloadBytes = artifacts.reduce((n, a) => n + a.bytes, 0);
     return {
         artifacts,
         downloadBytes,
@@ -46,7 +46,7 @@ export function captureSetupPlan(pins) {
         installationDeadlineMs: installDeadlineMs,
         dependencyDownloads: 'frozen-lock',
         requiredFreeBytes: 2 * 1024 ** 3 + budget + stagingBudget + downloadBytes,
-        capabilities: ['article-http', 'selected-ghostget-account', 'selected-attached-browser', 'verified-offline-images'],
+        capabilities: ['article-http', 'selected-attached-browser', 'verified-offline-images'],
     };
 }
 async function download(pin, path, signal) {
@@ -116,7 +116,7 @@ export const runtimeVerification = { fullWalks: 0 };
 async function inspectRuntime(root, pins) {
     checkPins(pins);
     await privateRoot(root);
-    const key = JSON.stringify([root, pins.id, pins.lockSha256, pins.bun.archiveExecutable, pins.bun.executableSha256]), bun = join(root, pins.bun.archiveExecutable), ghostget = join(root, 'node_modules/@hraness/ghostget/src/cli.ts');
+    const key = JSON.stringify([root, pins.id, pins.lockSha256, pins.bun.archiveExecutable, pins.bun.executableSha256]), bun = join(root, pins.bun.archiveExecutable);
     // Stat receipt of the root, its receipt file and every inventoried entry. Each stat precedes any read of its entry, so a later change always shows.
     const head = [
         statLine('.', await lstat(root, { bigint: true })),
@@ -124,7 +124,7 @@ async function inspectRuntime(root, pins) {
     ];
     const cached = verified.get(key);
     if (cached !== undefined && cached === hash([...head, ...(await inventory(root, false)).stats].join('\n')))
-        return { root, bun, ghostget, pins };
+        return { root, bun, pins };
     verified.delete(key);
     runtimeVerification.fullWalks++;
     const receipt = JSON.parse((await readConfined(root, 'runtime-receipt.json', 4096)).toString()), walked = await inventory(root);
@@ -136,7 +136,7 @@ async function inspectRuntime(root, pins) {
     if (hash(await readConfined(root, pins.bun.archiveExecutable, 128 * 1024 ** 2)) !== pins.bun.executableSha256)
         throw new SpongeError('integrity');
     verified.set(key, hash([...head, ...walked.stats].join('\n')));
-    return { root, bun, ghostget, pins };
+    return { root, bun, pins };
 }
 async function provisionRuntime(options) {
     const { pins, signal } = options, plan = captureSetupPlan(pins);
@@ -188,7 +188,7 @@ async function provisionRuntime(options) {
         await download(pins.bun, join(stage, 'bun.zip'), controller.signal);
         const unpack = await runOwned('/usr/bin/unzip', ['-q', join(stage, 'bun.zip'), '-d', stage], {
             cwd: stage,
-            env: isolatedEnvironment(home, home, home),
+            env: isolatedEnvironment(home, home),
             signal: controller.signal,
             deadlineMs: 30000,
             maxOutputBytes: 65536,
@@ -200,16 +200,15 @@ async function provisionRuntime(options) {
         if (hash(await readConfined(stage, pins.bun.archiveExecutable, 128 * 1024 ** 2)) !== pins.bun.executableSha256)
             throw new SpongeError('integrity');
         await chmod(bun, 0o700);
-        await download(pins.ghostget, join(stage, `hraness-ghostget-${pins.ghostget.version}.tgz`), controller.signal);
         await download(pins.wordcell, join(stage, `hraness-wordcell-${pins.wordcell.version}.tgz`), controller.signal);
         await writeFile(join(stage, 'package.json'), JSON.stringify({
             private: true,
-            dependencies: { '@hraness/ghostget': `./hraness-ghostget-${pins.ghostget.version}.tgz` },
+            dependencies: { '@hraness/wordcell': `./hraness-wordcell-${pins.wordcell.version}.tgz` },
         }), { mode: 0o600 });
         await writeFile(join(stage, 'bun.lock'), pins.lockfile, { mode: 0o600 });
         const install = await runOwned(bun, ['install', '--frozen-lockfile', '--ignore-scripts'], {
             cwd: stage,
-            env: isolatedEnvironment(home, home, home),
+            env: isolatedEnvironment(home, home),
             signal: controller.signal,
             deadlineMs: installDeadlineMs,
             maxOutputBytes: 65536,
@@ -219,14 +218,9 @@ async function provisionRuntime(options) {
             throw new SpongeError(limitExceeded ? 'limit-exceeded' : (install.stopped ?? 'unavailable'));
         await rm(home, { recursive: true, force: true });
         await rm(join(stage, 'bun.zip'));
-        for (const [name, pin] of [
-            ['ghostget', pins.ghostget],
-            ['wordcell', pins.wordcell],
-        ]) {
-            const pkg = JSON.parse((await readConfined(stage, `node_modules/@hraness/${name}/package.json`, 65536)).toString());
-            if (pkg.version !== pin.version)
-                throw new SpongeError('integrity');
-        }
+        const pkg = JSON.parse((await readConfined(stage, 'node_modules/@hraness/wordcell/package.json', 65536)).toString());
+        if (pkg.version !== pins.wordcell.version)
+            throw new SpongeError('integrity');
         await writeFile(join(stage, 'runtime-receipt.json'), JSON.stringify({
             schemaVersion: 1,
             pinId: pins.id,

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

@@ -1,5 +1,7 @@
 /** The identity form of an http(s) locator; source keys and shareable URIs both use it. Its output pins every existing source key. */
 export declare function normalizeWebLocator(locator: string): string;
+/** The kind `add` assumes without --kind: PDFs by extension or arXiv path, media by known host or file extension, else an article. */
+export declare function inferKind(input: string): 'article' | 'pdf' | 'media';
 export declare function articleSource(locator: string, realm?: string): {
     sourceKey: string;
     locator: string;

package/dist/src/app/source.js

@@ -31,6 +31,24 @@ export function normalizeWebLocator(locator) {
     // URL normalizes host casing/default ports. Preserve query order, unknown fields and fragments.
     return url.href;
 }
+const mediaHosts = /^(?:(?:www|m|music)\.)?(?:youtube\.com|youtu\.be|vimeo\.com|soundcloud\.com)$/i;
+const mediaExtensions = /\.(?:mp3|m4a|aac|wav|flac|ogg|opus|mp4|m4v|mov|webm)$/i;
+/** The kind `add` assumes without --kind: PDFs by extension or arXiv path, media by known host or file extension, else an article. */
+export function inferKind(input) {
+    if (/\.pdf(?:[?#]|$)/i.test(input) || input.startsWith('file:'))
+        return 'pdf';
+    try {
+        const url = new URL(input);
+        if (/^(?:www\.|export\.)?arxiv\.org$/i.test(url.hostname) && url.pathname.startsWith('/pdf/'))
+            return 'pdf';
+        if (mediaHosts.test(url.hostname) || mediaExtensions.test(url.pathname))
+            return 'media';
+    }
+    catch {
+        // An invalid locator is refused by its source constructor.
+    }
+    return 'article';
+}
 export function articleSource(locator, realm = 'public') {
     return webSource(locator, realm, 'article');
 }

package/dist/src/cli/commands.js

@@ -2,16 +2,17 @@ import { join, isAbsolute } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { readConnections } from './config.js';
 import { pdfSource } from '../pdf/index.js';
-import { articleSource, mediaSource } from '../app/source.js';
+import { articleSource, inferKind, mediaSource } from '../app/source.js';
 import { defaultCapturePins, inspectCaptureRuntime, provisionCapture, captureSetupPlan } from '../acquisition/index.js';
 import { queueAction } from './queue.js';
 import { portabilityAction } from './portability.js';
 import { restoreLibrary } from '../portability/backup.js';
 import { workerAction, serveWorker, hasDueAcquisition, workerDoctor } from './worker.js';
-import { nativeSetupPlan, provisionNative, inspectNative } from '../models/runtime.js';
+import { nativeSetupPlan, provisionNative, inspectNative, optionalNative } from '../models/runtime.js';
 import { digestModel, digestSetupPlan, inspectDigest, provisionDigest } from '../models/digest.js';
 import { withDigestServer } from '../digest/server.js';
 import { nativeDownloadAuthGuidance } from '../models/download.js';
+import { nativePlatformSupported } from '../models/catalog.js';
 import { drainIndexQueue } from '../indexing/runner.js';
 import { indexAction, overviewText } from './indexing.js';
 import { pruneText } from '../indexing/prune-run.js';
@@ -55,6 +56,8 @@ const resolveConnection = (connections) => (realm) => {
     const connection = connections.find((c) => c.realm === realm);
     if (!connection)
         throw new SpongeError('repair-auth');
+    if (!connection.capture)
+        throw new SpongeError('connection-retired');
     return connection.capture;
 };
 /** add/refresh with --wait and run --drain: drain acquisition (one job when given), then queued indexes for run. */
@@ -67,16 +70,9 @@ async function drain(c, jobId, connections) {
             throw jobFailure(store, jobId);
     }
     const runtime = await captureRuntime(c);
-    let asrRuntime;
-    try {
-        asrRuntime = await inspectNative('asr', c.nativeRoot, c.version);
-    }
-    catch (error) {
-        if (!['runtime-missing', 'unsupported'].includes(publicCode(error, 'integrity')))
-            throw error;
-    }
     const results = await drainLibrary(store, {
-        asrRuntime,
+        asrRuntime: await optionalNative('asr', c.nativeRoot, c.version),
+        mediaRuntime: await optionalNative('media', c.nativeRoot, c.version),
         language: args.flags.language,
         forceLocal: args.flags['force-local'] === true,
         runtime,
@@ -154,8 +150,8 @@ export const commands = [
                 c.emit({ digest: 'ready', model: pin.alias, auto: settings.auto, gc }, `Digest model ready: ${pin.alias}. New captures are digested in the background; turn that off with \`sponge digest --auto off\`.`);
                 return 0;
             }
-            if (!c.args.flags.capture) {
-                const kind = c.args.flags.asr ? 'asr' : 'embedding', plan = await nativeSetupPlan(kind, c.version);
+            const installNative = async (kind) => {
+                const plan = await nativeSetupPlan(kind, c.version);
                 process.stderr.write(JSON.stringify({ setup: kind, ...plan }) + '\n');
                 try {
                     await provisionNative(kind, c.nativeRoot, c.version, c.signal);
@@ -165,10 +161,20 @@ export const commands = [
                         process.stderr.write(nativeDownloadAuthGuidance + '\n');
                     throw error;
                 }
+            };
+            if (!c.args.flags.capture) {
+                const kind = c.args.flags.asr ? 'asr' : 'embedding';
+                await installNative(kind);
                 const gc = await setupRuntimeGc(c.store, c.version);
                 c.emit({ [kind]: 'ready', gc });
                 return 0;
             }
+            // Media goes first so a running worker never drains media jobs against a half-finished setup.
+            let media = nativePlatformSupported() ? 'ready' : 'unsupported';
+            if (media === 'ready')
+                await installNative('media').catch((error) => {
+                    media = codeOf(error);
+                });
             const plan = captureSetupPlan(defaultCapturePins);
             process.stderr.write(`Capture setup: ${plan.downloadBytes} pinned artifact bytes, plus frozen dependency downloads. Temporary installation limit: ${plan.stagingBudgetBytes} bytes; retained runtime limit: ${plan.installationBudgetBytes} bytes; dependency installation deadline: ${plan.installationDeadlineMs / 60000} minutes. ${plan.requiredFreeBytes} free bytes required.\n`);
             await provisionCapture({
@@ -176,8 +182,13 @@ export const commands = [
                 pins: defaultCapturePins,
                 signal: c.signal,
             });
-            const gc = await setupRuntimeGc(c.store, c.version);
-            c.emit({ capture: 'ready', gc }, 'skipped' in gc ? `Capture ready\nRuntime GC skipped: ${gc.skipped}` : `Capture ready\n${runtimeGcText(gc)}`);
+            // Articles and PDFs run anywhere; the media helper is a native release asset and is best-effort.
+            const gc = await setupRuntimeGc(c.store, c.version), ready = media === 'ready'
+                ? 'Capture ready'
+                : media === 'unsupported'
+                    ? 'Capture ready (media capture needs macOS 26 on Apple Silicon)'
+                    : `Capture ready; media helper not installed (${media}). Articles and PDFs work; rerun \`sponge setup --capture\` for media.`;
+            c.emit({ capture: 'ready', media, gc }, 'skipped' in gc ? `${ready}\nRuntime GC skipped: ${gc.skipped}` : `${ready}\n${runtimeGcText(gc)}`);
             return 0;
         },
     },
@@ -193,8 +204,7 @@ export const commands = [
             const connection = args.flags.connection ? connections.find((x) => x.id === args.flags.connection) : undefined;
             if (args.flags.connection && !connection)
                 throw new SpongeError('invalid-input');
-            const input = args.positional[0], kind = (args.flags.kind ??
-                (/\.pdf(?:[?#]|$)/i.test(input) || input.startsWith('file:') ? 'pdf' : 'article'));
+            const input = args.positional[0], kind = (args.flags.kind ?? inferKind(input));
             const source = (kind === 'pdf' ? pdfSource : kind === 'media' ? mediaSource : articleSource)(input, connection?.realm ?? 'public');
             const submission = store.queue.submit({ kind, ...source, idempotencyKey: 'save:' + source.sourceKey }), { jobId, itemId } = submission;
             const job = store.queue.list().find((j) => j.id === jobId);
@@ -436,7 +446,7 @@ export const commands = [
                 capture = publicCode(error, 'runtime-missing');
             }
             const states = {};
-            for (const kind of ['asr', 'embedding']) {
+            for (const kind of ['asr', 'embedding', 'media']) {
                 try {
                     await inspectNative(kind, c.nativeRoot, c.version);
                     states[kind] = 'ready';

package/dist/src/cli/config.d.ts

@@ -2,7 +2,8 @@ import type { CaptureConnection } from '../acquisition/index.js';
 export interface Connection {
     id: string;
     realm: string;
-    capture: CaptureConnection;
+    /** Absent for a retired GhostGet account connection: it still names its items' realm, but cannot capture. */
+    capture?: CaptureConnection;
 }
 /** Local references only. Tokens, cookies and passwords never belong in this file. */
 export declare function readConnections(root: string): Promise<Connection[]>;

package/dist/src/cli/config.js

@@ -32,17 +32,17 @@ export async function readConnections(root) {
         if (!entry || typeof entry.id !== 'string' || !/^[a-zA-Z0-9_-]{1,64}$/.test(entry.id) || ids.has(entry.id))
             throw new SpongeError('invalid-input');
         ids.add(entry.id);
-        let capture;
         if (entry.kind === 'account' &&
             typeof entry.stateHome === 'string' &&
             entry.stateHome.startsWith('/') &&
-            typeof entry.accountId === 'string')
-            capture = { kind: 'account', stateHome: entry.stateHome, accountId: entry.accountId };
-        else if (entry.kind === 'cdp' && typeof entry.endpoint === 'string')
-            capture = { kind: 'cdp', endpoint: entry.endpoint };
-        else
+            typeof entry.accountId === 'string') {
+            // The realm keeps its original derivation, so items captured through it keep their access class.
+            const legacy = { kind: 'account', stateHome: entry.stateHome, accountId: entry.accountId };
+            return { id: entry.id, realm: 'connection:' + sha256(JSON.stringify([entry.id, legacy])) };
+        }
+        if (entry.kind !== 'cdp' || typeof entry.endpoint !== 'string')
             throw new SpongeError('invalid-input');
-        const realm = 'connection:' + sha256(JSON.stringify([entry.id, capture]));
-        return { id: entry.id, realm, capture };
+        const capture = { kind: 'cdp', endpoint: entry.endpoint };
+        return { id: entry.id, realm: 'connection:' + sha256(JSON.stringify([entry.id, capture])), capture };
     });
 }

package/dist/src/cli/runtimes.js

@@ -11,7 +11,7 @@ async function installedReferences(version) {
         const catalog = await loadNativeCatalog(version);
         models = {
             fingerprints: [
-                ...['asr', 'embedding'].map((kind) => modelSetupPlan(nativeModelPackage(catalog, kind)).fingerprint),
+                ...['asr', 'embedding', 'media'].map((kind) => modelSetupPlan(nativeModelPackage(catalog, kind)).fingerprint),
                 ...digestFingerprints(),
             ],
         };

package/dist/src/cli/worker.js

@@ -1,5 +1,5 @@
 import { join } from 'node:path';
-import { inspectNative } from '../models/runtime.js';
+import { inspectNative, optionalNative } from '../models/runtime.js';
 import { drainIndexQueue } from '../indexing/runner.js';
 import { drainDigestQueue } from '../digest/runner.js';
 import { drainLibrary } from '../worker/basic.js';
@@ -63,15 +63,18 @@ export async function drainServiceQueues(store, options, version, signal) {
             const runtime = options.runtime ?? (await options.resolveCaptureRuntime?.());
             if (!runtime)
                 throw new SpongeError('runtime-missing');
-            let asrRuntime = options.asrRuntime;
-            try {
-                asrRuntime ??= await inspectNative('asr', join(store.root, 'runtime', 'models'), version);
-            }
-            catch (error) {
-                if (!['runtime-missing', 'unsupported'].includes(codeOf(error)))
-                    throw error;
-            }
-            results.push(...(await drainLibrary(store, { ...options, runtime, asrRuntime, signal, allowPrivateNetwork: false })));
+            const models = join(store.root, 'runtime', 'models');
+            // Media jobs report a missing helper themselves; articles and PDFs still drain.
+            const asrRuntime = options.asrRuntime ?? (await optionalNative('asr', models, version));
+            const mediaRuntime = options.mediaRuntime ?? (await optionalNative('media', models, version));
+            results.push(...(await drainLibrary(store, {
+                ...options,
+                runtime,
+                asrRuntime,
+                mediaRuntime,
+                signal,
+                allowPrivateNetwork: false,
+            })));
         }
         catch (error) {
             acquisitionError = error;

package/dist/src/errors.d.ts

@@ -22,6 +22,7 @@ declare const parents: {
     readonly 'source-too-thin': "unavailable";
     readonly 'parent-missing': "invalid-input";
     readonly 'target-exists': "invalid-input";
+    readonly 'connection-retired': "unsupported";
 };
 export type DetailCode = keyof typeof parents;
 export type SpongeCode = ErrorCode | DetailCode;

package/dist/src/errors.js

@@ -36,6 +36,7 @@ const parents = {
     'source-too-thin': 'unavailable',
     'parent-missing': 'invalid-input',
     'target-exists': 'invalid-input',
+    'connection-retired': 'unsupported',
 };
 export const indexCodes = [
     'invalid-index',
@@ -86,6 +87,7 @@ export const detailHints = {
     'draft-rejected': 'The model draft failed the digest checks listed above, even after one repair. Drafting is deterministic, so the same capture and model fail again; refresh the item or use another model.',
     'model-unavailable': 'The model server did not answer or returned an error. Check that it is still running and has free GPU memory (another loaded model can exhaust it), then retry.',
     'source-too-thin': 'The capture holds too little text to digest: under 20 words of prose, or only an archive’s metadata. Refresh the item when a fuller capture is possible.',
+    'connection-retired': 'Saved GhostGet account connections were retired in Sponge 0.5.0. Attach a signed-in browser over CDP and add it to connections.json instead.',
     'model-busy': 'Another llama-server is running, and two loaded models can exhaust GPU memory. Wait for it to exit, then retry.',
 };
 /** The one error type. `message` is the code, so bare `String(error)` never carries detail, paths or causes. */

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

@@ -1,13 +1,17 @@
 import type { Asset, ErrorEnvelope } from '../../contracts/index.js';
-import { type CaptureRuntime } from '../acquisition/runtime.js';
 import { runOwned } from '../acquisition/process.js';
 import type { CaptureConnection } from '../acquisition/index.js';
 import type { AudioInput } from '../inference/asr/runtime.js';
 import type { CaptionInput } from './transcribe.js';
+/** The installed private media helper and the release hash it must match before it runs. */
+export interface MediaRuntime {
+    helper: string;
+    helperSha256: string;
+}
 export interface MediaCaptureRequest {
     requestId: string;
     sourceUrl: string;
-    runtime: CaptureRuntime;
+    mediaRuntime?: MediaRuntime;
     stagingRoot: string;
     connection?: CaptureConnection;
     language?: string;

package/dist/src/media/capture.js

@@ -1,17 +1,22 @@
 import { constants } from 'node:fs';
-import { open, mkdir, mkdtemp, writeFile, statfs, realpath } from 'node:fs/promises';
+import { open, mkdir, mkdtemp, readFile, writeFile, statfs, realpath } from 'node:fs/promises';
 import { join, relative, isAbsolute } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { homedir } from 'node:os';
 import { createHash } from 'node:crypto';
 import { sha256 as hash } from '../util/hash.js';
 import { limits } from '../../contracts/index.js';
 import { failure } from '../acquisition/errors.js';
-import { inspectCaptureRuntime } from '../acquisition/runtime.js';
 import { privateRoot, physicalBytes, readConfined } from '../acquisition/files.js';
 import { runOwned, isolatedEnvironment } from '../acquisition/process.js';
 import { settleCaptureRoot } from '../acquisition/cleanup.js';
 import { SpongeError, publicCode, codeOf } from '../errors.js';
+import { nativePlatformSupported } from '../models/catalog.js';
+async function verifyHelper(runtime) {
+    if (!isAbsolute(runtime.helper) || (await realpath(runtime.helper)) !== runtime.helper)
+        throw new SpongeError('integrity');
+    const data = await readFile(runtime.helper);
+    if (data.length > 32 * 1024 ** 2 || hash(data) !== runtime.helperSha256)
+        throw new SpongeError('integrity');
+}
 /** All ephemeral bytes remain below one capture owner; deletion requires a settled process tree. */
 export async function captureMedia(request) {
     const { requestId, signal } = request;
@@ -27,13 +32,16 @@ export async function captureMedia(request) {
         return failure(requestId, 'invalid-input');
     }
     url.hash = '';
-    if (request.connection?.kind === 'cdp')
+    if (request.connection)
         return failure(requestId, 'unsupported');
     if (signal?.aborted)
         return failure(requestId, 'cancelled');
-    let runtime, base;
+    const runtime = request.mediaRuntime;
+    if (!runtime)
+        return failure(requestId, nativePlatformSupported() ? 'runtime-missing' : 'unsupported');
+    let base;
     try {
-        runtime = await inspectCaptureRuntime(request.runtime.root, request.runtime.pins);
+        await verifyHelper(runtime);
         base = await privateRoot(request.stagingRoot);
         const disk = await statfs(base);
         if (disk.bavail * disk.bsize < limits.stagingBytes + limits.freeReserveBytes)
@@ -42,17 +50,6 @@ export async function captureMedia(request) {
     catch (error) {
         return failure(requestId, publicCode(error, 'invalid-input'));
     }
-    let selectedState;
-    if (request.connection?.kind === 'account') {
-        if (!/^[A-Za-z0-9_.-]{1,128}$/.test(request.connection.accountId))
-            return failure(requestId, 'invalid-input');
-        try {
-            selectedState = await privateRoot(request.connection.stateHome);
-        }
-        catch {
-            return failure(requestId, 'repair-auth');
-        }
-    }
     const root = await realpath(await mkdtemp(join(base, 'capture-'))), home = join(root, 'home');
     let cleanup = 'settled', keep = false, checking = false, quota = false;
     const controller = new AbortController(), abort = () => controller.abort();
@@ -84,28 +81,26 @@ export async function captureMedia(request) {
         });
         const requestFile = join(root, 'request.json');
         await writeFile(requestFile, JSON.stringify({
-            runtimeRoot: runtime.root,
-            requestId,
-            request: {
-                url: request.sourceUrl,
-                stagingParent: root,
-                accountId: request.connection?.kind === 'account' ? request.connection.accountId : undefined,
-                language: request.language ?? 'en',
-                preferAudio: request.forceLocal === true,
-                maxBytes: 512 * 1024 ** 2,
-                maxDurationSeconds: 3600,
-                timeoutMs: limits.captureDeadlineMs,
-            },
+            url: url.href,
+            stagingParent: root,
+            language: request.language ?? 'en',
+            preferAudio: request.forceLocal === true,
+            maxBytes: 512 * 1024 ** 2,
+            maxDurationSeconds: 3600,
         }), { mode: 0o600, flag: 'wx' });
-        const entry = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? './capture-helper.ts' : './capture-helper.js', import.meta.url));
-        const environment = isolatedEnvironment(home, home, selectedState ?? join(home, 'state'));
+        const environment = isolatedEnvironment(home, home);
         environment.XDG_CACHE_HOME = home;
         environment.XDG_CONFIG_HOME = home;
         environment.XDG_STATE_HOME = home;
-        if (selectedState)
-            environment.HOME = homedir();
+        // yt-dlp, FFmpeg and yt-dlp's JavaScript runtime come from the user's PATH.
+        environment.PATH = [
+            ...new Set([
+                ...(process.env.PATH ?? '').split(':').filter((d) => isAbsolute(d)),
+                ...environment.PATH.split(':'),
+            ]),
+        ].join(':');
         cleanup = 'pending';
-        const result = await (request.runProcess ?? runOwned)(runtime.bun, [entry, requestFile], {
+        const result = await (request.runProcess ?? runOwned)(runtime.helper, [requestFile], {
             cwd: root,
             env: environment,
             signal: controller.signal,
@@ -121,22 +116,18 @@ export async function captureMedia(request) {
             return failure(requestId, result.stopped);
         const parsed = JSON.parse(result.stdout);
         if (parsed.ok !== true) {
-            if (parsed.code === 'cleanup-required')
-                cleanup = 'pending';
             const mapping = {
-                'permission-or-provider-failure': 'grant-permission',
-                timeout: 'unavailable',
-                'cleanup-required': 'cleanup-required',
+                'permission-or-provider-failure': 'unavailable',
                 'invalid-input': 'invalid-input',
+                'tool-unavailable': 'runtime-missing',
                 unsupported: 'unsupported',
                 unavailable: 'unavailable',
                 'limit-exceeded': 'limit-exceeded',
-                cancelled: 'cancelled',
                 integrity: 'integrity',
             };
             return failure(requestId, mapping[parsed.code] ?? 'unclassified');
         }
-        const manifest = parsed.manifest, mediaRoot = parsed.receipt?.root;
+        const manifest = parsed.manifest, mediaRoot = parsed.root;
         if (result.code !== 0 ||
             typeof mediaRoot !== 'string' ||
             !mediaRoot.startsWith(root + '/media-') ||

package/dist/src/models/catalog.d.ts

@@ -1,6 +1,6 @@
 import type { ModelPackage } from './artifacts.js';
-export type NativeKind = 'asr' | 'embedding';
-export type NativeRole = 'asr-helper' | 'embedding-helper' | 'embedding-library' | 'notices';
+export type NativeKind = 'asr' | 'embedding' | 'media';
+export type NativeRole = 'asr-helper' | 'embedding-helper' | 'embedding-library' | 'media-helper' | 'notices';
 export declare const nativeAssetNames: Record<NativeRole, string>;
 interface NativeArtifact {
     role: NativeRole;
@@ -19,8 +19,10 @@ export interface NativeCatalog {
     build: {
         asrSourceSha256: string;
         embeddingSourceSha256: string;
+        mediaSourceSha256: string;
         swiftVersion: string;
         clangVersion: string;
+        rustcVersion: string;
     };
 }
 /** Package-embedded release hashes are authority; local probe helper hashes never enter this catalog. */

package/dist/src/models/catalog.js

@@ -10,6 +10,7 @@ export const nativeAssetNames = {
     'asr-helper': 'sponge-speech-macos26-arm64',
     'embedding-helper': 'sponge-embedding-macos26-arm64',
     'embedding-library': 'libCLiteRTLM_mac.dylib',
+    'media-helper': 'sponge-media-macos26-arm64',
     notices: 'native-NOTICES.txt',
 };
 const fail = () => {
@@ -43,7 +44,7 @@ export function parseNativeCatalog(value, expectedVersion) {
         r.architecture !== 'arm64' ||
         r.minimumMacOS !== '26.0' ||
         !Array.isArray(r.artifacts) ||
-        r.artifacts.length !== 4)
+        r.artifacts.length !== Object.keys(nativeAssetNames).length)
         fail();
     const roles = new Set();
     const artifacts = r.artifacts.map((value) => {
@@ -64,10 +65,18 @@ export function parseNativeCatalog(value, expectedVersion) {
             fail();
         return a;
     });
-    const build = object(r.build, ['asrSourceSha256', 'embeddingSourceSha256', 'swiftVersion', 'clangVersion']);
+    const build = object(r.build, [
+        'asrSourceSha256',
+        'embeddingSourceSha256',
+        'mediaSourceSha256',
+        'swiftVersion',
+        'clangVersion',
+        'rustcVersion',
+    ]);
     if (!sha(build.asrSourceSha256) ||
         !sha(build.embeddingSourceSha256) ||
-        ['swiftVersion', 'clangVersion'].some((k) => typeof build[k] !== 'string' || !build[k] || Buffer.byteLength(String(build[k])) > 2048))
+        !sha(build.mediaSourceSha256) ||
+        ['swiftVersion', 'clangVersion', 'rustcVersion'].some((k) => typeof build[k] !== 'string' || !build[k] || Buffer.byteLength(String(build[k])) > 2048))
         fail();
     return { ...r, artifacts, build };
 }
@@ -104,37 +113,47 @@ export async function loadNativeCatalog(expectedVersion, path = nativeCatalogPat
         await file.close();
     }
 }
+const helperNames = {
+    'asr-helper': 'sponge-speech',
+    'embedding-helper': 'sponge-embedding',
+    'media-helper': 'sponge-media',
+};
 export function nativeModelPackage(catalog, kind) {
     parseNativeCatalog(catalog, catalog.packageVersion);
-    if (kind !== 'asr' && kind !== 'embedding')
+    const roles = {
+        asr: ['asr-helper', 'notices'],
+        embedding: ['embedding-helper', 'embedding-library', 'notices'],
+        media: ['media-helper', 'notices'],
+    }[kind];
+    if (!roles)
         fail();
-    const roles = kind === 'asr' ? ['asr-helper', 'notices'] : ['embedding-helper', 'embedding-library', 'notices'];
     const artifacts = roles.map((role) => {
         const a = catalog.artifacts.find((a) => a.role === role);
         return {
-            name: role === 'asr-helper' ? 'sponge-speech' : role === 'embedding-helper' ? 'sponge-embedding' : a.name,
+            name: role.endsWith('helper') ? helperNames[role] : a.name,
             url: `https://github.com/hraness/sponge/releases/download/v${catalog.packageVersion}/${a.name}`,
             sha256: a.sha256,
             bytes: a.bytes,
             ...(role.endsWith('helper') ? { executable: true } : {}),
         };
     });
-    artifacts.push(kind === 'asr'
-        ? {
-            name: 'whistle.cact',
-            url: 'https://huggingface.co/Cactus-Compute/whistle/resolve/ca5287601bef25af26dcf2e1b2bdc0843a7c19e5/whistle.cact',
-            sha256: asrIdentity.modelSha256,
-            bytes: asrIdentity.modelBytes,
-        }
-        : {
-            name: 'embeddinggemma-2-text-vision-440m.litertlm',
-            url: 'https://huggingface.co/litert-community/embeddinggemma-2-text-vision-440m-litert-lm/resolve/e301f74d5551b0c2641bd5cb4652a76239d5c5f8/embeddinggemma-2-text-vision-440m.litertlm',
-            sha256: embeddingIdentity.modelSha256,
-            bytes: 387710976,
-        });
+    if (kind !== 'media')
+        artifacts.push(kind === 'asr'
+            ? {
+                name: 'whistle.cact',
+                url: 'https://huggingface.co/Cactus-Compute/whistle/resolve/ca5287601bef25af26dcf2e1b2bdc0843a7c19e5/whistle.cact',
+                sha256: asrIdentity.modelSha256,
+                bytes: asrIdentity.modelBytes,
+            }
+            : {
+                name: 'embeddinggemma-2-text-vision-440m.litertlm',
+                url: 'https://huggingface.co/litert-community/embeddinggemma-2-text-vision-440m-litert-lm/resolve/e301f74d5551b0c2641bd5cb4652a76239d5c5f8/embeddinggemma-2-text-vision-440m.litertlm',
+                sha256: embeddingIdentity.modelSha256,
+                bytes: 387710976,
+            });
     return {
         id: `sponge-${kind}-${catalog.packageVersion}-macos26-arm64`,
-        license: 'Sponge helpers: proprietary; Needle, Whistle, LiteRT-LM and model: Apache-2.0; see native-NOTICES.txt',
+        license: 'Sponge helpers: proprietary; Needle, Whistle, LiteRT-LM and model: Apache-2.0; Rust crates: MIT or Apache-2.0; see native-NOTICES.txt',
         artifacts,
     };
 }