@hraness/sponge 0.4.0 → 0.5.0

package/dist/src/errors.js

@@ -33,8 +33,10 @@ const parents = {
     'draft-rejected': 'unavailable',
     'model-unavailable': 'unavailable',
     'model-busy': 'unavailable',
+    'source-too-thin': 'unavailable',
     'parent-missing': 'invalid-input',
     'target-exists': 'invalid-input',
+    'connection-retired': 'unsupported',
 };
 export const indexCodes = [
     'invalid-index',
@@ -84,6 +86,8 @@ export const hints = {
 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,
     };
 }

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

@@ -1,5 +1,6 @@
 import type { AsrRuntime } from '../inference/asr/runtime.js';
 import type { EmbeddingRuntime } from '../inference/embedding/index.js';
+import type { MediaRuntime } from '../media/capture.js';
 import { type NativeCatalog, type NativeKind } from './catalog.js';
 export declare function nativeSetupPlan(kind: NativeKind, version: string): Promise<{
     supported: boolean;
@@ -11,12 +12,19 @@ export declare function nativeSetupPlan(kind: NativeKind, version: string): Prom
     requiredFreeBytes: number;
     artifacts: readonly import("./artifacts.js").ModelArtifact[];
 }>;
+type NativeRuntime = AsrRuntime | EmbeddingRuntime | MediaRuntime;
 export declare function setupNativeRuntime(cacheRoot: string, catalog: NativeCatalog, kind: NativeKind, options?: {
     signal?: AbortSignal;
-}): Promise<AsrRuntime | EmbeddingRuntime>;
+}): Promise<NativeRuntime>;
 export declare function provisionNative(kind: 'asr', cacheRoot: string, version: string, signal?: AbortSignal): Promise<AsrRuntime>;
 export declare function provisionNative(kind: 'embedding', cacheRoot: string, version: string, signal?: AbortSignal): Promise<EmbeddingRuntime>;
-export declare function provisionNative(kind: NativeKind, cacheRoot: string, version: string, signal?: AbortSignal): Promise<AsrRuntime | EmbeddingRuntime>;
+export declare function provisionNative(kind: 'media', cacheRoot: string, version: string, signal?: AbortSignal): Promise<MediaRuntime>;
+export declare function provisionNative(kind: NativeKind, cacheRoot: string, version: string, signal?: AbortSignal): Promise<NativeRuntime>;
 export declare function inspectNative(kind: 'asr', cacheRoot: string, version: string): Promise<AsrRuntime>;
 export declare function inspectNative(kind: 'embedding', cacheRoot: string, version: string): Promise<EmbeddingRuntime>;
-export declare function inspectNative(kind: NativeKind, cacheRoot: string, version: string): Promise<AsrRuntime | EmbeddingRuntime>;
+export declare function inspectNative(kind: 'media', cacheRoot: string, version: string): Promise<MediaRuntime>;
+export declare function inspectNative(kind: NativeKind, cacheRoot: string, version: string): Promise<NativeRuntime>;
+type RuntimeOf<K extends NativeKind> = K extends 'asr' ? AsrRuntime : K extends 'embedding' ? EmbeddingRuntime : MediaRuntime;
+/** An installed runtime, or undefined when it is not installed or this platform cannot run it. */
+export declare function optionalNative<K extends NativeKind>(kind: K, cacheRoot: string, version: string): Promise<RuntimeOf<K> | undefined>;
+export {};

package/dist/src/models/runtime.js

@@ -4,7 +4,7 @@ import { privateRoot } from '../acquisition/files.js';
 import { nativeArtifactFetch } from './download.js';
 import { inspectInstalledModelPackage, provisionModelPackage, recoverModelPackage, modelSetupPlan, } from './artifacts.js';
 import { nativePlatformSupported, nativeModelPackage, loadNativeCatalog, } from './catalog.js';
-import { SpongeError } from '../errors.js';
+import { SpongeError, publicCode } from '../errors.js';
 export async function nativeSetupPlan(kind, version) {
     const catalog = await loadNativeCatalog(version);
     return {
@@ -24,6 +24,10 @@ function asr(c, p) {
         model: p['whistle.cact'],
     };
 }
+function media(c, p) {
+    return { helper: p['sponge-media'], helperSha256: c.artifacts.find((a) => a.role === 'media-helper').sha256 };
+}
+const runtimeOf = (kind, c, p) => kind === 'asr' ? asr(c, p) : kind === 'embedding' ? embedding(c, p) : media(c, p);
 function embedding(c, p) {
     return {
         helper: p['sponge-embedding'],
@@ -48,7 +52,7 @@ export async function setupNativeRuntime(cacheRoot, catalog, kind, options = {})
     await privateRoot(cacheRoot);
     await recoverModelPackage(cacheRoot, manifest);
     const paths = await provisionModelPackage(cacheRoot, manifest, { ...options, fetch: nativeArtifactFetch(manifest) });
-    return kind === 'asr' ? asr(catalog, paths) : embedding(catalog, paths);
+    return runtimeOf(kind, catalog, paths);
 }
 async function installed(cacheRoot, catalog, kind) {
     const paths = await inspectInstalledModelPackage(cacheRoot, nativeModelPackage(catalog, kind));
@@ -56,18 +60,21 @@ async function installed(cacheRoot, catalog, kind) {
         throw new SpongeError('runtime-missing');
     return paths;
 }
-async function inspectAsrRuntime(cacheRoot, catalog) {
-    supported();
-    return asr(catalog, await installed(cacheRoot, catalog, 'asr'));
-}
-async function inspectEmbeddingRuntime(cacheRoot, catalog) {
-    supported();
-    return embedding(catalog, await installed(cacheRoot, catalog, 'embedding'));
-}
 export async function provisionNative(kind, cacheRoot, version, signal) {
     return setupNativeRuntime(cacheRoot, await loadNativeCatalog(version), kind, { signal });
 }
 export async function inspectNative(kind, cacheRoot, version) {
+    supported();
     const catalog = await loadNativeCatalog(version);
-    return kind === 'asr' ? inspectAsrRuntime(cacheRoot, catalog) : inspectEmbeddingRuntime(cacheRoot, catalog);
+    return runtimeOf(kind, catalog, await installed(cacheRoot, catalog, kind));
+}
+/** An installed runtime, or undefined when it is not installed or this platform cannot run it. */
+export async function optionalNative(kind, cacheRoot, version) {
+    try {
+        return (await inspectNative(kind, cacheRoot, version));
+    }
+    catch (error) {
+        if (!['runtime-missing', 'unsupported'].includes(publicCode(error, 'integrity')))
+            throw error;
+    }
 }

package/dist/src/pdf/capture-helper.js

@@ -1,10 +1,11 @@
-// Pinned public SDK bridge. Native subprocesses inherit the supervisor's group.
+// Pinned public Wordcell bridge. Native subprocesses inherit the supervisor's group.
 const runtime = process.argv[2], args = process.argv.slice(3);
 try {
-    const { runPdfAcquisition } = await import(import.meta.resolve('@hraness/ghostget/pdf-acquisition', `${runtime}/package.json`));
-    const { runPdfToolCommand } = await import(import.meta.resolve('@hraness/wordcell/pdf', `${runtime}/package.json`));
-    process.exitCode = await runPdfAcquisition(args, process.env, { stdout: (value) => process.stdout.write(value), stderr: (value) => process.stderr.write(value) }, {
-        runTool: (specification) => runPdfToolCommand({ ...specification, processGroup: 'inherit' }),
+    const { runPdfCommand, runPdfToolCommand } = await import(import.meta.resolve('@hraness/wordcell/pdf', `${runtime}/package.json`));
+    process.exitCode = await runPdfCommand(args, process.env, { stdout: (value) => process.stdout.write(value), stderr: (value) => process.stderr.write(value) }, {
+        captureDependencies: {
+            runTool: (specification) => runPdfToolCommand({ ...specification, processGroup: 'inherit' }),
+        },
     });
 }
 catch {

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

@@ -2,10 +2,6 @@ import type { CaptureResult, ErrorEnvelope } from '../../contracts/index.js';
 import { runOwned } from '../acquisition/process.js';
 import { type CaptureRuntime } from '../acquisition/runtime.js';
 type CaptureConnection = {
-    kind: 'account';
-    stateHome: string;
-    accountId: string;
-} | {
     kind: 'cdp';
     endpoint: string;
 };

package/dist/src/pdf/capture.js

@@ -52,7 +52,7 @@ export async function capturePdf(request) {
         return failure(requestId, 'invalid-input');
     if (url.protocol === 'file:' && (url.host || url.search || url.hash || request.connection))
         return failure(requestId, 'invalid-input');
-    if (request.connection?.kind === 'cdp' || request.allowPrivateNetwork)
+    if (request.connection || request.allowPrivateNetwork)
         return failure(requestId, 'unsupported');
     const captureHelper = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? './capture-helper.ts' : './capture-helper.js', import.meta.url));
     const args = [
@@ -76,21 +76,9 @@ export async function capturePdf(request) {
         '--quiet',
         '--json',
     ];
-    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');
-        }
-        args.push('--auth', request.connection.accountId);
-    }
     const root = await realpath(await mkdtemp(join(base, 'capture-'))), home = join(root, 'home'), output = join(root, 'bundles');
     args.push('--output', output);
-    const env = isolatedEnvironment(home, home, selectedState ?? join(home, 'state'));
+    const env = isolatedEnvironment(home, home);
     const controller = new AbortController();
     const abort = () => controller.abort();
     signal?.addEventListener('abort', abort, { once: true });

package/dist/src/pdf/errors.js

@@ -1,4 +1,4 @@
-import { failure, upstreamFailure } from '../acquisition/errors.js';
+import { failure } from '../acquisition/errors.js';
 /** Wordcell's pinned PDF code field is authoritative; prose is never classified. */
 export function pdfFailure(value, requestId) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -6,8 +6,6 @@ export function pdfFailure(value, requestId) {
     const record = value;
     if (record.ok !== false)
         return failure(requestId, 'unclassified');
-    if (record.captureError)
-        return upstreamFailure(value, requestId);
     const codes = {
         'invalid-input': 'invalid-input',
         encrypted: 'unsupported',

package/dist/src/store/digest-jobs.d.ts

@@ -20,8 +20,11 @@ export type DigestOutcome = {
     notBefore?: string;
     countAttempt?: boolean;
 };
-/** Queue a digest of a newly captured revision when auto-digest is on. Runs inside the capture commit's transaction. */
-export declare function enqueueDigest(db: DatabaseSync, itemId: string, revisionId: string): void;
+/**
+ * Queue a digest of a newly captured revision when auto-digest is on and the capture has enough text to digest. Runs
+ * inside the capture commit's transaction.
+ */
+export declare function enqueueDigest(db: DatabaseSync, itemId: string, revisionId: string, markdown: string): void;
 /**
  * Digest jobs under the shared worker lease. A job names one revision; when its item moves on or is deleted before the
  * worker reaches it, the job is cancelled as `superseded`, since the newer revision has a job of its own. The drafting

package/dist/src/store/digest-jobs.js

@@ -3,12 +3,16 @@ import { text } from './files.js';
 import { checkOwner } from './lease.js';
 import { now, transaction } from './context.js';
 import { SpongeError } from '../errors.js';
+import { undigestible } from '../digest/pipeline.js';
 /** Automatic retries a retryable failure gets before it stays failed. */
 const maxAttempts = 3;
 const alias = /^[\w.:/@+-]{1,256}$/;
-/** Queue a digest of a newly captured revision when auto-digest is on. Runs inside the capture commit's transaction. */
-export function enqueueDigest(db, itemId, revisionId) {
-    if (db.prepare('SELECT auto FROM digest_settings WHERE id=1').get()?.auto !== 1)
+/**
+ * Queue a digest of a newly captured revision when auto-digest is on and the capture has enough text to digest. Runs
+ * inside the capture commit's transaction.
+ */
+export function enqueueDigest(db, itemId, revisionId, markdown) {
+    if (db.prepare('SELECT auto FROM digest_settings WHERE id=1').get()?.auto !== 1 || undigestible(markdown))
         return;
     db.prepare("INSERT INTO digest_jobs(id,item_id,revision_id,state,created_at) VALUES(?,?,?,'queued',?) ON CONFLICT(revision_id) DO NOTHING").run(randomUUID(), itemId, revisionId, now());
 }

package/dist/src/store/revisions.js

@@ -154,7 +154,7 @@ export class Revisions {
                 trackLibrary(db);
                 // A capture, not an import: imported libraries are digested on purpose, not as a side effect.
                 if (!imported)
-                    enqueueDigest(db, input.itemId, revisionId);
+                    enqueueDigest(db, input.itemId, revisionId, String(stored.markdown));
             }
             if (imported) {
                 const receipt = importReceipt(db, imported.namespace, imported.sourceKey, imported.sourceHash);

package/dist/src/worker/basic.d.ts

@@ -2,7 +2,7 @@ import type { LibraryStore } from '../store/index.js';
 import { type ArticleOptions, type ArticleOutcome } from '../app/article.js';
 import { type MediaOptions } from '../media/handler.js';
 /** Content handlers over the durable sequential worker and its process supervisor. */
-export declare function drainLibrary(store: LibraryStore, options: ArticleOptions & Pick<MediaOptions, 'asrRuntime' | 'language' | 'forceLocal'> & {
+export declare function drainLibrary(store: LibraryStore, options: ArticleOptions & Pick<MediaOptions, 'asrRuntime' | 'mediaRuntime' | 'language' | 'forceLocal'> & {
     jobId?: string;
     resolveConnection?: (realm: string) => ArticleOptions['connection'];
     onResult?: (result: ArticleOutcome) => void;

package/dist/src/worker/basic.js

@@ -1,4 +1,5 @@
 import { failure } from '../acquisition/errors.js';
+import { codeOf, publicCode } from '../errors.js';
 import { ingestArticle } from '../app/article.js';
 import { ingestPdf } from '../pdf/index.js';
 import { ingestMedia } from '../media/handler.js';
@@ -11,10 +12,11 @@ export async function drainLibrary(store, options) {
         try {
             connection = options.resolveConnection?.(source?.realm ?? 'public') ?? options.connection;
         }
-        catch {
-            store.queue.fail(context.attempt, 'repair-auth');
+        catch (error) {
+            const code = codeOf(error) === 'connection-retired' ? 'connection-retired' : 'repair-auth';
+            store.queue.fail(context.attempt, code);
             store.queue.settle(context.attempt);
-            return { ...failure(context.attempt.attemptId, 'repair-auth', 'acquisition'), cleanup: 'settled' };
+            return { ...failure(context.attempt.attemptId, publicCode(code), 'acquisition'), cleanup: 'settled' };
         }
         if (source?.kind === 'media') {
             const { capture: _articleCapture, ...mediaOptions } = options;

package/native/runtime-manifest.json

@@ -20,21 +20,29 @@
       "sha256": "9526db9ee35e7eb4a5a58ac1e53330032f22a13890bd4ee01818fb380a57a362"
     },
     {
-      "bytes": 23486,
+      "bytes": 534912,
+      "name": "sponge-media-macos26-arm64",
+      "role": "media-helper",
+      "sha256": "4e01a12d163abcf8489feaf87e8050bcc1c260dcc39c6318f0bb7b1bbfffdc67"
+    },
+    {
+      "bytes": 23606,
       "name": "native-NOTICES.txt",
       "role": "notices",
-      "sha256": "6e62f14bd094001b8da42af6fc42877e51b0d5616ae960917ef214fc45767088"
+      "sha256": "f56e55503bebba456ce7a8bcc4bcab3a5c34fa71d57c1e0243179dd4ba429fbf"
     }
   ],
   "build": {
-    "asrSourceSha256": "21a284b38eca324015bc9d03efb14335a5a73f8b3761b0f547180bf851fce2a3",
+    "asrSourceSha256": "8b977f8131ed154f517dab2eb7abd95fd2d4e31d22f526f544af79587fe88f5e",
     "clangVersion": "Apple clang version 21.0.0 (clang-2100.1.1.101)",
-    "embeddingSourceSha256": "ff0a27cefa0ddc23e1d8bea7a70a49a112865ee730500a1da69ca9b8e6104adc",
+    "embeddingSourceSha256": "8fb22c36a2dc5dc849abd16040d839f170c12ee30ce85bf956227102def8a349",
+    "mediaSourceSha256": "288bfdea3eba7c21434ae4188b77dd75ab0aced83a662ade802890a59bcdf101",
+    "rustcVersion": "rustc 1.97.1 (8bab26f4f 2026-07-14)",
     "swiftVersion": "Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)"
   },
   "minimumMacOS": "26.0",
-  "packageVersion": "0.4.0",
+  "packageVersion": "0.5.0",
   "platform": "darwin",
   "schemaVersion": 1,
-  "sourceCommit": "307210823c8523059f896fb64ff92dade3760b59"
+  "sourceCommit": "bbfe2485826242f7a314735a9a788ab3311096eb"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hraness/sponge",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A local library for captured articles and verified offline assets.",
   "repository": {
     "type": "git",

package/dist/src/media/capture-helper.js

@@ -1,21 +0,0 @@
-/** Public Ghostget SDK bridge; its complete inherited group belongs to the caller. */
-import { readFile } from 'node:fs/promises';
-import { processIdentity } from '../worker/identity.js';
-import { SpongeError } from '../errors.js';
-try {
-    const config = JSON.parse(await readFile(process.argv[2], 'utf8'));
-    const sdk = await import(import.meta.resolve('@hraness/ghostget/media-acquisition', `${config.runtimeRoot}/package.json`));
-    const identity = await processIdentity(process.pid);
-    if (!identity)
-        throw new SpongeError('unavailable');
-    const result = await sdk.acquireEphemeralMedia({
-        ...config.request,
-        processGroup: 'inherit',
-        supervisor: { requestId: config.requestId, processGroupId: process.pid, processStartIdentity: identity.started },
-    });
-    process.stdout.write(JSON.stringify(result));
-}
-catch {
-    process.stdout.write(JSON.stringify({ ok: false, code: 'unavailable', cleanup: 'settled' }));
-    process.exitCode = 1;
-}