@hraness/sponge 0.2.6 → 0.3.1

package/dist/src/models/catalog.js

@@ -4,35 +4,79 @@ import { fileURLToPath } from 'node:url';
 import { release } from 'node:os';
 import { asrIdentity } from '../inference/asr/protocol.js';
 import { embeddingIdentity } from '../inference/embedding/index.js';
-export const nativeAssetNames = { 'asr-helper': 'sponge-speech-macos26-arm64', 'embedding-helper': 'sponge-embedding-macos26-arm64', 'embedding-library': 'libCLiteRTLM_mac.dylib', notices: 'native-NOTICES.txt' };
-export class NativeCatalogError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-    }
-}
-const fail = () => { throw new NativeCatalogError('integrity'); };
-function object(value, keys) { if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).sort().join(',') !== keys.sort().join(','))
-    fail(); return value; }
+import { exactKeys } from '../util/exact.js';
+import { SpongeError } from '../errors.js';
+export const nativeAssetNames = {
+    'asr-helper': 'sponge-speech-macos26-arm64',
+    'embedding-helper': 'sponge-embedding-macos26-arm64',
+    'embedding-library': 'libCLiteRTLM_mac.dylib',
+    notices: 'native-NOTICES.txt',
+};
+const fail = () => {
+    throw new SpongeError('integrity');
+};
+const object = (value, keys) => exactKeys(value, keys, fail);
 const sha = (v) => typeof v === 'string' && /^[a-f0-9]{64}$/u.test(v);
-function version(v) { return typeof v === 'string' && /^(0|[1-9]\d{0,15})\.(0|[1-9]\d{0,15})\.(0|[1-9]\d{0,15})$/u.test(v) && v.split('.').every(n => Number.isSafeInteger(Number(n))); }
+function version(v) {
+    return (typeof v === 'string' &&
+        /^(0|[1-9]\d{0,15})\.(0|[1-9]\d{0,15})\.(0|[1-9]\d{0,15})$/u.test(v) &&
+        v.split('.').every((n) => Number.isSafeInteger(Number(n))));
+}
 /** Package-embedded release hashes are authority; local probe helper hashes never enter this catalog. */
 export function parseNativeCatalog(value, expectedVersion) {
-    const r = object(value, ['schemaVersion', 'packageVersion', 'sourceCommit', 'platform', 'architecture', 'minimumMacOS', 'artifacts', 'build']);
-    if (r.schemaVersion !== 1 || !version(expectedVersion) || r.packageVersion !== expectedVersion || typeof r.sourceCommit !== 'string' || !/^[a-f0-9]{40}$/u.test(r.sourceCommit) || r.platform !== 'darwin' || r.architecture !== 'arm64' || r.minimumMacOS !== '26.0' || !Array.isArray(r.artifacts) || r.artifacts.length !== 4)
+    const r = object(value, [
+        'schemaVersion',
+        'packageVersion',
+        'sourceCommit',
+        'platform',
+        'architecture',
+        'minimumMacOS',
+        'artifacts',
+        'build',
+    ]);
+    if (r.schemaVersion !== 1 ||
+        !version(expectedVersion) ||
+        r.packageVersion !== expectedVersion ||
+        typeof r.sourceCommit !== 'string' ||
+        !/^[a-f0-9]{40}$/u.test(r.sourceCommit) ||
+        r.platform !== 'darwin' ||
+        r.architecture !== 'arm64' ||
+        r.minimumMacOS !== '26.0' ||
+        !Array.isArray(r.artifacts) ||
+        r.artifacts.length !== 4)
         fail();
     const roles = new Set();
-    const artifacts = r.artifacts.map((value) => { const a = object(value, ['role', 'name', 'bytes', 'sha256']); if (typeof a.role !== 'string' || !Object.hasOwn(nativeAssetNames, a.role) || roles.has(a.role) || a.name !== nativeAssetNames[a.role] || typeof a.bytes !== 'number' || !Number.isSafeInteger(a.bytes) || a.bytes < 1 || a.bytes > (a.role === 'embedding-library' ? 160 * 1024 ** 2 : a.role === 'notices' ? 1024 ** 2 : 32 * 1024 ** 2) || !sha(a.sha256))
-        fail(); roles.add(a.role); if (a.role === 'embedding-library' && a.sha256 !== embeddingIdentity.librarySha256)
-        fail(); return a; });
+    const artifacts = r.artifacts.map((value) => {
+        const a = object(value, ['role', 'name', 'bytes', 'sha256']);
+        if (typeof a.role !== 'string' ||
+            !Object.hasOwn(nativeAssetNames, a.role) ||
+            roles.has(a.role) ||
+            a.name !== nativeAssetNames[a.role] ||
+            typeof a.bytes !== 'number' ||
+            !Number.isSafeInteger(a.bytes) ||
+            a.bytes < 1 ||
+            a.bytes >
+                (a.role === 'embedding-library' ? 160 * 1024 ** 2 : a.role === 'notices' ? 1024 ** 2 : 32 * 1024 ** 2) ||
+            !sha(a.sha256))
+            fail();
+        roles.add(a.role);
+        if (a.role === 'embedding-library' && a.sha256 !== embeddingIdentity.librarySha256)
+            fail();
+        return a;
+    });
     const build = object(r.build, ['asrSourceSha256', 'embeddingSourceSha256', 'swiftVersion', 'clangVersion']);
-    if (!sha(build.asrSourceSha256) || !sha(build.embeddingSourceSha256) || ['swiftVersion', 'clangVersion'].some(k => typeof build[k] !== 'string' || !build[k] || Buffer.byteLength(String(build[k])) > 2048))
+    if (!sha(build.asrSourceSha256) ||
+        !sha(build.embeddingSourceSha256) ||
+        ['swiftVersion', 'clangVersion'].some((k) => typeof build[k] !== 'string' || !build[k] || Buffer.byteLength(String(build[k])) > 2048))
         fail();
     return { ...r, artifacts, build };
 }
-export function nativePlatformSupported(platform = process.platform, architecture = process.arch, kernel = release()) { return platform === 'darwin' && architecture === 'arm64' && /^\d+\./u.test(kernel) && Number(kernel.split('.')[0]) >= 25; }
-export function nativeCatalogPath() { return fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? '../../native/runtime-manifest.json' : '../../../native/runtime-manifest.json', import.meta.url)); }
+export function nativePlatformSupported(platform = process.platform, architecture = process.arch, kernel = release()) {
+    return (platform === 'darwin' && architecture === 'arm64' && /^\d+\./u.test(kernel) && Number(kernel.split('.')[0]) >= 25);
+}
+export function nativeCatalogPath() {
+    return fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? '../../native/runtime-manifest.json' : '../../../native/runtime-manifest.json', import.meta.url));
+}
 export async function loadNativeCatalog(expectedVersion, path = nativeCatalogPath()) {
     let file;
     try {
@@ -40,8 +84,8 @@ export async function loadNativeCatalog(expectedVersion, path = nativeCatalogPat
     }
     catch (error) {
         if (error.code === 'ENOENT')
-            throw new NativeCatalogError('runtime-missing');
-        throw new NativeCatalogError('integrity');
+            throw new SpongeError('runtime-missing');
+        throw new SpongeError('integrity');
     }
     try {
         const stat = await file.stat();
@@ -65,7 +109,32 @@ export function nativeModelPackage(catalog, kind) {
     if (kind !== 'asr' && kind !== 'embedding')
         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, 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 });
-    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', artifacts };
+    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,
+            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,
+        });
+    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',
+        artifacts,
+    };
 }

package/dist/src/models/download.js

@@ -1,14 +1,22 @@
-import { ModelSetupError } from './artifacts.js';
+import { SpongeError } from '../errors.js';
 const api = 'https://api.github.com/repos/hraness/sponge';
 const nativeUrl = /^https:\/\/github\.com\/hraness\/sponge\/releases\/download\/(v(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*))\/([A-Za-z0-9_.-]+)$/;
-const cdnHosts = new Set(['release-assets.githubusercontent.com', 'objects.githubusercontent.com', 'github-releases.githubusercontent.com']);
+const cdnHosts = new Set([
+    'release-assets.githubusercontent.com',
+    'objects.githubusercontent.com',
+    'github-releases.githubusercontent.com',
+]);
 const redirectCodes = new Set([301, 302, 303, 307, 308]);
 export const nativeDownloadAuthGuidance = 'Set GH_TOKEN or GITHUB_TOKEN with Contents: read access to hraness/sponge, then retry setup. Credentials are never saved.';
-function fail(code) { throw new ModelSetupError(code); }
-async function discard(response) { try {
-    await response.body?.cancel();
+function fail(code) {
+    throw new SpongeError(code);
+}
+async function discard(response) {
+    try {
+        await response.body?.cancel();
+    }
+    catch { }
 }
-catch { } }
 async function boundedJson(response) {
     if (!response.body)
         fail('integrity');
@@ -27,7 +35,7 @@ async function boundedJson(response) {
         return value;
     }
     catch (error) {
-        if (error instanceof ModelSetupError)
+        if (error instanceof SpongeError)
             throw error;
         fail('integrity');
     }
@@ -43,7 +51,7 @@ function credential(env) {
  * Manual CDN redirects always discard auth; returned bytes still pass package hashes.
  * Public model downloads never read credentials or receive authorization headers. */
 export function nativeArtifactFetch(manifest, options = {}) {
-    const transport = options.fetch ?? globalThis.fetch, env = options.env ?? process.env, artifacts = new Map(manifest.artifacts.map(a => [a.url, a]));
+    const transport = options.fetch ?? globalThis.fetch, env = options.env ?? process.env, artifacts = new Map(manifest.artifacts.map((a) => [a.url, a]));
     const request = async (url, signal, headers) => {
         if (signal?.aborted)
             fail('cancelled');
@@ -57,7 +65,11 @@ export function nativeArtifactFetch(manifest, options = {}) {
         }
     };
     const download = async (artifact, tag, name, signal) => {
-        const token = credential(env), auth = { Authorization: `Bearer ${token}`, 'X-GitHub-Api-Version': '2022-11-28', Accept: 'application/vnd.github+json' };
+        const token = credential(env), auth = {
+            Authorization: `Bearer ${token}`,
+            'X-GitHub-Api-Version': '2022-11-28',
+            Accept: 'application/vnd.github+json',
+        };
         const metadataResponse = await request(`${api}/releases/tags/${tag}`, signal, auth);
         if (!metadataResponse.ok) {
             await discard(metadataResponse);
@@ -66,13 +78,28 @@ export function nativeArtifactFetch(manifest, options = {}) {
             fail('unavailable');
         }
         const release = await boundedJson(metadataResponse);
-        if (release.tag_name !== tag || release.immutable !== true || release.draft !== false || release.prerelease !== false || !Number.isSafeInteger(release.id) || Number(release.id) <= 0 || release.url !== `${api}/releases/${release.id}` || release.html_url !== `https://github.com/hraness/sponge/releases/tag/${tag}` || !Array.isArray(release.assets) || release.assets.length > 1000)
+        if (release.tag_name !== tag ||
+            release.immutable !== true ||
+            release.draft !== false ||
+            release.prerelease !== false ||
+            !Number.isSafeInteger(release.id) ||
+            Number(release.id) <= 0 ||
+            release.url !== `${api}/releases/${release.id}` ||
+            release.html_url !== `https://github.com/hraness/sponge/releases/tag/${tag}` ||
+            !Array.isArray(release.assets) ||
+            release.assets.length > 1000)
             fail('integrity');
-        const matches = release.assets.filter(a => a && typeof a === 'object' && a.name === name);
+        const matches = release.assets.filter((a) => a && typeof a === 'object' && a.name === name);
         if (matches.length !== 1)
             fail('integrity');
         const asset = matches[0];
-        if (!Number.isSafeInteger(asset.id) || asset.id <= 0 || asset.state !== 'uploaded' || asset.size !== artifact.bytes || asset.digest !== `sha256:${artifact.sha256}` || asset.url !== `${api}/releases/assets/${asset.id}` || asset.browser_download_url !== artifact.url)
+        if (!Number.isSafeInteger(asset.id) ||
+            asset.id <= 0 ||
+            asset.state !== 'uploaded' ||
+            asset.size !== artifact.bytes ||
+            asset.digest !== `sha256:${artifact.sha256}` ||
+            asset.url !== `${api}/releases/assets/${asset.id}` ||
+            asset.browser_download_url !== artifact.url)
             fail('integrity');
         let response = await request(asset.url, signal, { ...auth, Accept: 'application/octet-stream' });
         for (let redirects = 0; redirectCodes.has(response.status); redirects++) {
@@ -87,7 +114,12 @@ export function nativeArtifactFetch(manifest, options = {}) {
             catch {
                 fail('integrity');
             }
-            if (next.protocol !== 'https:' || next.username || next.password || next.port || next.hash || !cdnHosts.has(next.hostname))
+            if (next.protocol !== 'https:' ||
+                next.username ||
+                next.password ||
+                next.port ||
+                next.hash ||
+                !cdnHosts.has(next.hostname))
                 fail('integrity');
             response = await request(next.href, signal); // No credential or GitHub API headers cross this boundary.
         }
@@ -101,7 +133,7 @@ export function nativeArtifactFetch(manifest, options = {}) {
     };
     return (async (input, init) => {
         const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url, artifact = artifacts.get(url), signal = init?.signal ?? undefined;
-        if (!artifact || init?.headers || init?.body || init?.method && init.method !== 'GET')
+        if (!artifact || init?.headers || init?.body || (init?.method && init.method !== 'GET'))
             fail('integrity');
         if (signal?.aborted)
             fail('cancelled');
@@ -133,7 +165,15 @@ export function nativeArtifactFetch(manifest, options = {}) {
             catch {
                 fail('integrity');
             }
-            if (next.protocol !== 'https:' || next.username || next.password || next.port || next.hash || !(next.hostname === 'huggingface.co' || next.hostname.endsWith('.huggingface.co') || next.hostname === 'hf.co' || next.hostname.endsWith('.hf.co')))
+            if (next.protocol !== 'https:' ||
+                next.username ||
+                next.password ||
+                next.port ||
+                next.hash ||
+                !(next.hostname === 'huggingface.co' ||
+                    next.hostname.endsWith('.huggingface.co') ||
+                    next.hostname === 'hf.co' ||
+                    next.hostname.endsWith('.hf.co')))
                 fail('integrity');
             currentUrl = next.href;
             response = await request(currentUrl, signal);

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

@@ -14,8 +14,6 @@ export declare function nativeSetupPlan(kind: NativeKind, version: string): Prom
 export declare function setupNativeRuntime(cacheRoot: string, catalog: NativeCatalog, kind: NativeKind, options?: {
     signal?: AbortSignal;
 }): Promise<AsrRuntime | EmbeddingRuntime>;
-export declare function inspectAsrRuntime(cacheRoot: string, catalog: NativeCatalog): Promise<AsrRuntime>;
-export declare function inspectEmbeddingRuntime(cacheRoot: string, catalog: NativeCatalog): Promise<EmbeddingRuntime>;
 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>;

package/dist/src/models/runtime.js

@@ -2,36 +2,72 @@ import { mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { privateRoot } from '../acquisition/files.js';
 import { nativeArtifactFetch } from './download.js';
-import { inspectModelPackage, provisionModelPackage, recoverModelPackage, modelSetupPlan, ModelSetupError } from './artifacts.js';
-import { nativePlatformSupported, nativeModelPackage, NativeCatalogError, loadNativeCatalog } from './catalog.js';
-export async function nativeSetupPlan(kind, version) { const catalog = await loadNativeCatalog(version); return { ...modelSetupPlan(nativeModelPackage(catalog, kind)), supported: nativePlatformSupported(), minimumMacOS: '26.0' }; }
-function supported() { if (!nativePlatformSupported())
-    throw new NativeCatalogError('unsupported'); }
-function asr(c, p) { return { helper: p['sponge-speech'], helperSha256: c.artifacts.find(a => a.role === 'asr-helper').sha256, model: p['whistle.cact'] }; }
-function embedding(c, p) { return { helper: p['sponge-embedding'], helperSha256: c.artifacts.find(a => a.role === 'embedding-helper').sha256, library: p['libCLiteRTLM_mac.dylib'], model: p['embeddinggemma-2-text-vision-440m.litertlm'] }; }
-export async function setupNativeRuntime(cacheRoot, catalog, kind, options = {}) { supported(); if (options.signal?.aborted)
-    throw new ModelSetupError('cancelled'); const manifest = nativeModelPackage(catalog, kind); await privateRoot(dirname(cacheRoot)); try {
-    await mkdir(cacheRoot, { mode: 0o700 });
-}
-catch (error) {
-    if (error.code !== 'EEXIST')
-        throw error;
-} 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); }
-export async function inspectAsrRuntime(cacheRoot, catalog) { supported(); try {
-    return asr(catalog, await inspectModelPackage(cacheRoot, nativeModelPackage(catalog, 'asr')));
-}
-catch (error) {
-    if (error.code === 'ENOENT')
-        throw new NativeCatalogError('runtime-missing');
-    throw error;
-} }
-export async function inspectEmbeddingRuntime(cacheRoot, catalog) { supported(); try {
-    return embedding(catalog, await inspectModelPackage(cacheRoot, nativeModelPackage(catalog, 'embedding')));
-}
-catch (error) {
-    if (error.code === 'ENOENT')
-        throw new NativeCatalogError('runtime-missing');
-    throw error;
-} }
-export async function provisionNative(kind, cacheRoot, version, signal) { return setupNativeRuntime(cacheRoot, await loadNativeCatalog(version), kind, { signal }); }
-export async function inspectNative(kind, cacheRoot, version) { const catalog = await loadNativeCatalog(version); return kind === 'asr' ? inspectAsrRuntime(cacheRoot, catalog) : inspectEmbeddingRuntime(cacheRoot, catalog); }
+import { inspectInstalledModelPackage, provisionModelPackage, recoverModelPackage, modelSetupPlan, } from './artifacts.js';
+import { nativePlatformSupported, nativeModelPackage, loadNativeCatalog, } from './catalog.js';
+import { SpongeError } from '../errors.js';
+export async function nativeSetupPlan(kind, version) {
+    const catalog = await loadNativeCatalog(version);
+    return {
+        ...modelSetupPlan(nativeModelPackage(catalog, kind)),
+        supported: nativePlatformSupported(),
+        minimumMacOS: '26.0',
+    };
+}
+function supported() {
+    if (!nativePlatformSupported())
+        throw new SpongeError('unsupported');
+}
+function asr(c, p) {
+    return {
+        helper: p['sponge-speech'],
+        helperSha256: c.artifacts.find((a) => a.role === 'asr-helper').sha256,
+        model: p['whistle.cact'],
+    };
+}
+function embedding(c, p) {
+    return {
+        helper: p['sponge-embedding'],
+        helperSha256: c.artifacts.find((a) => a.role === 'embedding-helper').sha256,
+        library: p['libCLiteRTLM_mac.dylib'],
+        model: p['embeddinggemma-2-text-vision-440m.litertlm'],
+    };
+}
+export async function setupNativeRuntime(cacheRoot, catalog, kind, options = {}) {
+    supported();
+    if (options.signal?.aborted)
+        throw new SpongeError('cancelled');
+    const manifest = nativeModelPackage(catalog, kind);
+    await privateRoot(dirname(cacheRoot));
+    try {
+        await mkdir(cacheRoot, { mode: 0o700 });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+    }
+    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);
+}
+async function installed(cacheRoot, catalog, kind) {
+    const paths = await inspectInstalledModelPackage(cacheRoot, nativeModelPackage(catalog, kind));
+    if (!paths)
+        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) {
+    const catalog = await loadNativeCatalog(version);
+    return kind === 'asr' ? inspectAsrRuntime(cacheRoot, catalog) : inspectEmbeddingRuntime(cacheRoot, catalog);
+}

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

@@ -3,7 +3,9 @@ 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' }) });
+    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' }),
+    });
 }
 catch {
     process.stdout.write(JSON.stringify({ ok: false, code: 'unknown' }));

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

@@ -1,7 +1,7 @@
 import type { CaptureResult, ErrorEnvelope } from '../../contracts/index.js';
 import { runOwned } from '../acquisition/process.js';
 import { type CaptureRuntime } from '../acquisition/runtime.js';
-export type CaptureConnection = {
+type CaptureConnection = {
     kind: 'account';
     stateHome: string;
     accountId: string;
@@ -27,3 +27,4 @@ export type CaptureOutcome = {
     dispose: () => Promise<void>;
 } | ErrorEnvelope;
 export declare function capturePdf(request: PdfCaptureRequest): Promise<CaptureOutcome>;
+export {};

package/dist/src/pdf/capture.js

@@ -4,13 +4,14 @@ import { fileURLToPath } from 'node:url';
 import { limits } from '../../contracts/index.js';
 import { privateRoot, physicalBytes } from '../acquisition/files.js';
 import { runOwned, isolatedEnvironment } from '../acquisition/process.js';
-import { inspectCaptureRuntime, CaptureSetupError } from '../acquisition/runtime.js';
-import { settleCaptureRoot, CaptureCleanupError } from '../acquisition/cleanup.js';
+import { inspectCaptureRuntime } from '../acquisition/runtime.js';
+import { settleCaptureRoot } from '../acquisition/cleanup.js';
 import { failure } from '../acquisition/errors.js';
 import { object } from '../acquisition/normalize.js';
 import { normalizePdfBundle } from './normalize.js';
 import { copyPdfInput } from './input.js';
 import { pdfFailure } from './errors.js';
+import { SpongeError, publicCode, codeOf } from '../errors.js';
 export async function capturePdf(request) {
     const { requestId, signal } = request;
     if (!/^[a-zA-Z0-9_-]{1,128}$/.test(requestId))
@@ -18,7 +19,10 @@ export async function capturePdf(request) {
     let url;
     try {
         url = new URL(request.sourceUrl);
-        if (!['http:', 'https:', 'file:'].includes(url.protocol) || url.username || url.password || request.sourceUrl.length > 16384)
+        if (!['http:', 'https:', 'file:'].includes(url.protocol) ||
+            url.username ||
+            url.password ||
+            request.sourceUrl.length > 16384)
             throw Error();
     }
     catch {
@@ -31,7 +35,7 @@ export async function capturePdf(request) {
         runtime = await inspectCaptureRuntime(request.runtime.root, request.runtime.pins);
     }
     catch (error) {
-        return failure(requestId, error instanceof CaptureSetupError ? error.code : 'runtime-missing', 'setup');
+        return failure(requestId, publicCode(error, 'runtime-missing'), 'setup');
     }
     let base;
     try {
@@ -51,7 +55,27 @@ export async function capturePdf(request) {
     if (request.connection?.kind === 'cdp' || 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 = [captureHelper, runtime.root, request.sourceUrl, '--slug', 'document', '--timeout-ms', String(deadline), '--max-pdf-bytes', String(limits.pdfBytes), '--max-pages', '500', '--max-images', String(limits.imagesPerItem), '--max-asset-bytes', String(limits.imageBytes), '--max-total-asset-bytes', String(500 * 1024 ** 2), '--quiet', '--json'];
+    const args = [
+        captureHelper,
+        runtime.root,
+        request.sourceUrl,
+        '--slug',
+        'document',
+        '--timeout-ms',
+        String(deadline),
+        '--max-pdf-bytes',
+        String(limits.pdfBytes),
+        '--max-pages',
+        '500',
+        '--max-images',
+        String(limits.imagesPerItem),
+        '--max-asset-bytes',
+        String(limits.imageBytes),
+        '--max-total-asset-bytes',
+        String(500 * 1024 ** 2),
+        '--quiet',
+        '--json',
+    ];
     let selectedState;
     if (request.connection?.kind === 'account') {
         if (!/^[a-zA-Z0-9_.-]{1,128}$/.test(request.connection.accountId))
@@ -73,32 +97,45 @@ export async function capturePdf(request) {
     if (signal?.aborted)
         abort();
     let cleanup = 'settled', keep = false, quota = false, checking = false;
-    const monitor = setInterval(async () => { if (checking)
-        return; checking = true; try {
-        if (await physicalBytes(root) > limits.stagingBytes) {
+    const monitor = setInterval(async () => {
+        if (checking)
+            return;
+        checking = true;
+        try {
+            if ((await physicalBytes(root)) > limits.stagingBytes) {
+                quota = true;
+                controller.abort();
+            }
+        }
+        catch {
             quota = true;
             controller.abort();
         }
-    }
-    catch {
-        quota = true;
-        controller.abort();
-    }
-    finally {
-        checking = false;
-    } }, 100);
+        finally {
+            checking = false;
+        }
+    }, 100);
     const started = Date.now();
     try {
         await mkdir(home, { mode: 0o700 });
         await mkdir(output, { mode: 0o700 });
-        await writeFile(join(root, 'ownership.json'), JSON.stringify({ schemaVersion: 1, requestId, state: 'acquiring' }), { mode: 0o600 });
+        await writeFile(join(root, 'ownership.json'), JSON.stringify({ schemaVersion: 1, requestId, state: 'acquiring' }), {
+            mode: 0o600,
+        });
         let sourceHash;
         if (url.protocol === 'file:') {
             sourceHash = await copyPdfInput(fileURLToPath(url), join(root, 'input.pdf'), controller.signal);
             args[2] = join(root, 'input.pdf');
         }
         cleanup = 'pending';
-        const result = await (request.runProcess ?? runOwned)(runtime.bun, args, { cwd: root, env, signal: controller.signal, deadlineMs: Math.max(1, deadline - (Date.now() - started)), maxOutputBytes: limits.metadataBytes, graceMs: 5000 });
+        const result = await (request.runProcess ?? runOwned)(runtime.bun, args, {
+            cwd: root,
+            env,
+            signal: controller.signal,
+            deadlineMs: Math.max(1, deadline - (Date.now() - started)),
+            maxOutputBytes: limits.metadataBytes,
+            graceMs: 5000,
+        });
         cleanup = result.cleanup;
         let summary;
         try {
@@ -119,11 +156,19 @@ export async function capturePdf(request) {
         if (result.code !== 0 || object(summary).ok !== true)
             return upstream;
         const outputDirectory = object(summary).outputDirectory;
-        if (typeof outputDirectory !== 'string' || !outputDirectory.startsWith(output + '/') || await realpath(outputDirectory) !== outputDirectory)
+        if (typeof outputDirectory !== 'string' ||
+            !outputDirectory.startsWith(output + '/') ||
+            (await realpath(outputDirectory)) !== outputDirectory)
             return failure(requestId, 'integrity', 'verification');
         const helper = fileURLToPath(new URL(import.meta.url.endsWith('.ts') ? './verify-helper.ts' : './verify-helper.js', import.meta.url));
         cleanup = 'pending';
-        const checked = await (request.runProcess ?? runOwned)(runtime.bun, [helper, runtime.root, outputDirectory, request.sourceUrl], { cwd: root, env, signal: controller.signal, deadlineMs: Math.max(1, deadline - (Date.now() - started)), maxOutputBytes: limits.helperFrameBytes });
+        const checked = await (request.runProcess ?? runOwned)(runtime.bun, [helper, runtime.root, outputDirectory, request.sourceUrl], {
+            cwd: root,
+            env,
+            signal: controller.signal,
+            deadlineMs: Math.max(1, deadline - (Date.now() - started)),
+            maxOutputBytes: limits.helperFrameBytes,
+        });
         cleanup = checked.cleanup;
         if (cleanup !== 'settled')
             return failure(requestId, 'cleanup-required', 'cleanup');
@@ -131,26 +176,49 @@ export async function capturePdf(request) {
             return failure(requestId, checked.stopped);
         if (checked.code !== 0)
             return failure(requestId, 'integrity', 'verification');
-        const capture = await normalizePdfBundle({ bundleRoot: outputDirectory, inspection: JSON.parse(checked.stdout), summary, requestId, sourceUrl: request.sourceUrl, wordcellVersion: runtime.pins.wordcell.version, ...(sourceHash ? { sourceHash } : {}) });
+        const capture = await normalizePdfBundle({
+            bundleRoot: outputDirectory,
+            inspection: JSON.parse(checked.stdout),
+            summary,
+            requestId,
+            sourceUrl: request.sourceUrl,
+            wordcellVersion: runtime.pins.wordcell.version,
+            ...(sourceHash ? { sourceHash } : {}),
+        });
         if (controller.signal.aborted)
             return failure(requestId, quota ? 'limit-exceeded' : 'cancelled');
-        await writeFile(join(root, 'ownership.json'), JSON.stringify({ schemaVersion: 1, requestId, state: 'verified' }), { mode: 0o600 });
+        await writeFile(join(root, 'ownership.json'), JSON.stringify({ schemaVersion: 1, requestId, state: 'verified' }), {
+            mode: 0o600,
+        });
         keep = true;
-        return { ok: true, capture, bundleRoot: outputDirectory, dispose: async () => { if (await settleCaptureRoot(root, requestId) === 'pending')
-                throw new CaptureCleanupError(); } };
+        return {
+            ok: true,
+            capture,
+            bundleRoot: outputDirectory,
+            dispose: async () => {
+                if ((await settleCaptureRoot(root, requestId)) === 'pending')
+                    throw new SpongeError('cleanup-required');
+            },
+        };
     }
     catch (error) {
         if (cleanup !== 'settled')
             return failure(requestId, 'cleanup-required', 'cleanup');
-        const code = (error instanceof Error && ['integrity', 'limit-exceeded', 'schema-newer', 'invalid-input', 'cancelled'].includes(error.message) ? error.message : 'unclassified');
+        const raw = codeOf(error), code = raw === 'integrity' ||
+            raw === 'limit-exceeded' ||
+            raw === 'schema-newer' ||
+            raw === 'invalid-input' ||
+            raw === 'cancelled'
+            ? raw
+            : 'unclassified';
         return failure(requestId, code, 'verification');
     }
     finally {
         clearInterval(monitor);
         while (checking)
-            await new Promise(r => setTimeout(r, 5));
+            await new Promise((r) => setTimeout(r, 5));
         signal?.removeEventListener('abort', abort);
-        if (!keep && cleanup === 'settled' && await settleCaptureRoot(root, requestId) === 'pending')
+        if (!keep && cleanup === 'settled' && (await settleCaptureRoot(root, requestId)) === 'pending')
             return failure(requestId, 'cleanup-required', 'cleanup');
     }
 }