@hraness/sponge 0.2.6 → 0.3.0

package/dist/src/indexing/runner.js

@@ -1,54 +1,68 @@
 import { join } from 'node:path';
-import { StoreError } from '../store/index.js';
 import { acquireWorkerCustody, proveAttemptCleanup } from '../worker/custody.js';
 import { supervisedRunner } from '../worker/supervisor.js';
 import { directory, writeJournal } from '../worker/journal.js';
-import { embedBatch, embeddingFingerprint, encodeEmbeddingRequest, resolveIndexSpace, projectVector } from '../inference/embedding/index.js';
+import { embedBatch, embeddingFingerprint, encodeEmbeddingRequest, resolveIndexSpace, projectVector, } from '../inference/embedding/index.js';
 import { deriveEmbeddingImage } from './image.js';
 import { failure } from '../acquisition/errors.js';
-/** Same durable worker lock/owner/supervisor as acquisition, with sequential bounded batches. */
+import { SpongeError, codeOf, publicCode } from '../errors.js';
+/** Same durable worker lock/owner/supervisor as acquisition, with sequential bounded batches. Only inputs whose content the space
+ * has not embedded run: a delta after captures, or everything new for a new fingerprint. Captures during a run join it. */
 export async function drainIndexQueue(store, options) {
     const custody = await acquireWorkerCustody(store.root);
     let owner, settled = true;
     const results = [];
     try {
-        owner = store.acquireOwner(custody.incarnation);
+        owner = store.queue.acquireOwner(custody.incarnation);
         while (!options.signal?.aborted) {
-            const attempt = store.claimIndexJob(owner, options.jobId);
+            const attempt = store.index.claim(owner, options.jobId);
             if (!attempt)
                 break;
             settled = false;
             const attemptDirectory = await directory(join(custody.directory, 'attempts', attempt.attemptId)), scratchRoot = await directory(join(store.root, 'staging', attempt.attemptId));
-            await writeJournal(join(scratchRoot, 'ownership.json'), { schemaVersion: 1, requestId: attempt.attemptId, ownerIncarnation: attempt.ownerIncarnation });
-            const checkpoint = async (stage) => { store.checkpointIndexAttempt(attempt, stage); await writeJournal(join(attemptDirectory, 'checkpoint.json'), { schemaVersion: 1, ...attempt, stage }); await options.onCheckpoint?.(attempt, stage); };
-            const controller = new AbortController(), cancel = () => { store.requestCancellation(attempt.jobId); controller.abort(); };
+            await writeJournal(join(scratchRoot, 'ownership.json'), {
+                schemaVersion: 1,
+                requestId: attempt.attemptId,
+                ownerIncarnation: attempt.ownerIncarnation,
+            });
+            const checkpoint = async (stage) => {
+                store.index.checkpoint(attempt, stage);
+                await writeJournal(join(attemptDirectory, 'checkpoint.json'), { schemaVersion: 1, ...attempt, stage });
+                await options.onCheckpoint?.(attempt, stage);
+            };
+            const controller = new AbortController(), cancel = () => {
+                store.queue.cancel(attempt.jobId);
+                controller.abort();
+            };
             options.signal?.addEventListener('abort', cancel, { once: true });
-            const poll = setInterval(() => { try {
-                if (store.jobCancellationRequested(attempt.jobId))
+            const poll = setInterval(() => {
+                try {
+                    if (store.queue.cancelRequested(attempt.jobId))
+                        controller.abort();
+                }
+                catch {
                     controller.abort();
-            }
-            catch {
-                controller.abort();
-            } }, 100);
+                }
+            }, 100);
             const runProcess = supervisedRunner(custody.directory, custody.incarnation, attempt.attemptId);
             let result;
             try {
                 if (options.signal?.aborted)
                     cancel();
                 await checkpoint('acquiring');
-                const job = store.indexJob(attempt.jobId);
+                const job = store.index.job(attempt.jobId);
                 if (!job)
-                    throw new StoreError('unavailable');
-                const generationId = String(job.generation_id), status = store.indexStatus(generationId), space = resolveIndexSpace(options.runtime.helperSha256, status.fingerprint);
+                    throw new SpongeError('unavailable');
+                const generationId = String(job.generation_id);
+                store.index.refresh(attempt);
+                const status = store.index.status(generationId), space = resolveIndexSpace(options.runtime.helperSha256, status.fingerprint);
                 if (!space)
-                    throw new StoreError('integrity');
+                    throw new SpongeError('integrity');
                 await checkpoint('indexing');
                 for (;;) {
-                    if (controller.signal.aborted || store.jobCancellationRequested(attempt.jobId))
-                        throw new StoreError('cancelled');
-                    if (store.revisionEpoch !== status.revisionEpoch)
-                        throw Object.assign(Error('stale-index'), { code: 'stale-index' });
-                    const inputs = store.indexInputs(generationId, 16);
+                    if (controller.signal.aborted || store.queue.cancelRequested(attempt.jobId))
+                        throw new SpongeError('cancelled');
+                    const inputs = store.index.inputs(generationId, 16);
                     if (!inputs.length)
                         break;
                     const batch = [];
@@ -57,35 +71,64 @@ export async function drainIndexQueue(store, options) {
                             batch.push({ kind: 'document', text: input.text });
                             continue;
                         }
-                        const item = store.read(input.itemId), asset = item?.assets.find(a => a.sha256 === input.assetSha256);
+                        const item = store.read(input.itemId), asset = item?.assets.find((a) => a.sha256 === input.assetSha256);
                         if (!item || item.revisionId !== input.revisionId || !asset)
-                            throw new StoreError('unavailable');
-                        const derived = await (options.deriveImage ?? deriveEmbeddingImage)(store.readBlob(asset), { scratchRoot, runProcess, signal: controller.signal });
+                            throw new SpongeError('unavailable');
+                        const derived = await (options.deriveImage ?? deriveEmbeddingImage)(store.blobs.read(asset), {
+                            scratchRoot,
+                            runProcess,
+                            signal: controller.signal,
+                        });
                         batch.push({ kind: 'image', png: derived.png });
                     }
-                    const expected = encodeEmbeddingRequest(batch).inputHashes, embedded = await (options.embed ?? embedBatch)(batch, { runtime: options.runtime, scratchRoot, runProcess, signal: controller.signal });
-                    if (embedded.fingerprint !== embeddingFingerprint(options.runtime.helperSha256) || embedded.inputHashes.length !== expected.length || embedded.inputHashes.some((hash, i) => hash !== expected[i]))
-                        throw new StoreError('integrity');
-                    store.writeIndexAttemptBatch(attempt, status.fingerprint, inputs.map((input, i) => ({ ...input, inputHash: expected[i], vector: projectVector(embedded.vectors[i], space.dimensions) })));
-                    await options.onBatch?.(attempt, store.indexStatus(generationId).completed);
+                    const expected = encodeEmbeddingRequest(batch).inputHashes, embedded = await (options.embed ?? embedBatch)(batch, {
+                        runtime: options.runtime,
+                        scratchRoot,
+                        runProcess,
+                        signal: controller.signal,
+                    });
+                    if (embedded.fingerprint !== embeddingFingerprint(options.runtime.helperSha256) ||
+                        embedded.inputHashes.length !== expected.length ||
+                        embedded.inputHashes.some((hash, i) => hash !== expected[i]))
+                        throw new SpongeError('integrity');
+                    store.index.writeAttemptBatch(attempt, status.fingerprint, inputs.map((input, i) => ({
+                        ...input,
+                        inputHash: expected[i],
+                        vector: projectVector(embedded.vectors[i], space.dimensions),
+                    })));
+                    await options.onBatch?.(attempt, store.index.status(generationId).completed);
                 }
                 await checkpoint('promoting');
-                store.completeIndexAttempt(attempt);
+                store.index.complete(attempt);
                 result = { ok: true, jobId: attempt.jobId, generationId, cleanup: 'settled' };
             }
             catch (error) {
-                const raw = error.code, reason = raw && /^[a-z][a-z-]{0,63}$/.test(raw) ? raw : 'unclassified';
-                store.failIndexAttempt(attempt, reason);
-                const known = ['integrity', 'unavailable', 'unsupported', 'cancelled', 'limit-exceeded', 'cleanup-required', 'runtime-missing', 'owner-busy'];
-                result = { ...failure(attempt.attemptId, known.includes(reason) ? reason : 'unavailable', 'inference'), cleanup: 'pending' };
+                const reason = codeOf(error), code = publicCode(reason);
+                store.index.fail(attempt, reason);
+                const known = [
+                    'integrity',
+                    'unavailable',
+                    'unsupported',
+                    'cancelled',
+                    'limit-exceeded',
+                    'cleanup-required',
+                    'runtime-missing',
+                    'owner-busy',
+                ];
+                result = {
+                    ...failure(attempt.attemptId, known.includes(code) ? code : 'unavailable', 'inference'),
+                    cleanup: 'pending',
+                };
             }
             finally {
                 clearInterval(poll);
                 options.signal?.removeEventListener('abort', cancel);
             }
-            settled = !(result.ok === false && result.code === 'cleanup-required') && await proveAttemptCleanup(custody.directory, custody.incarnation, attempt.attemptId);
+            settled =
+                !(result.ok === false && result.code === 'cleanup-required') &&
+                    (await proveAttemptCleanup(custody.directory, custody.incarnation, attempt.attemptId));
             if (settled) {
-                store.settleIndexAttempt(attempt);
+                store.index.settle(attempt);
                 result.cleanup = 'settled';
             }
             else
@@ -96,13 +139,13 @@ export async function drainIndexQueue(store, options) {
                 break;
         }
         if (!settled)
-            throw Object.assign(Error('cleanup-required'), { code: 'cleanup-required' });
+            throw new SpongeError('cleanup-required');
         return results;
     }
     finally {
         if (owner && settled) {
             try {
-                store.releaseOwner(owner);
+                store.queue.releaseOwner(owner);
             }
             catch {
                 settled = false;

package/dist/src/indexing/upgrade.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseSync } from 'node:sqlite';
+/**
+ * Migration 10's code step. Each generation's JSON coverage becomes `index_items` and `index_inputs` rows keyed by content hash,
+ * and its embedded vectors move to `embeddings` under (fingerprint, content hash), so a vector shared by two generations or two
+ * items is stored once. All or nothing per generation: one unverifiable input leaves that generation's JSON coverage in place,
+ * where it never reads (as before). Then the copy of `vectors` is dropped and active generations catch up with captures made since they
+ * were built: their delta is queued, not a rebuild.
+ */
+export declare function incrementalIndex(db: DatabaseSync): void;

package/dist/src/indexing/upgrade.js

@@ -0,0 +1,79 @@
+import { chunkDocument, chunkHash, coverageMarker, documentHash, imageHash, trackLibrary } from './index.js';
+const parse = (text) => {
+    try {
+        return JSON.parse(String(text));
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Content key of one schema-9 coverage input, or undefined when its chunk hash no longer verifies (such a generation already could not build). */
+function contentOf(db, input, chunks) {
+    if (input.kind === 'image')
+        return typeof input.assetSha256 === 'string' &&
+            input.derivationHash === imageHash(input.assetSha256) &&
+            input.sourceId === JSON.stringify([input.revisionId, 'image', input.assetSha256])
+            ? input.derivationHash
+            : undefined;
+    if (input.kind !== 'document' ||
+        typeof input.representationId !== 'string' ||
+        !Number.isSafeInteger(input.ordinal) ||
+        input.sourceId !== JSON.stringify([input.revisionId, 'document', input.representationId, input.ordinal]))
+        return undefined;
+    if (!chunks.has(input.representationId)) {
+        const markdown = db
+            .prepare('SELECT markdown FROM representations WHERE id=? AND revision_id=?')
+            .get(input.representationId, input.revisionId)?.markdown;
+        chunks.set(input.representationId, typeof markdown === 'string' ? chunkDocument(markdown) : undefined);
+    }
+    const text = chunks.get(input.representationId)?.[input.ordinal];
+    return text !== undefined && input.derivationHash === chunkHash(input.representationId, input.ordinal, text)
+        ? documentHash(text)
+        : undefined;
+}
+/**
+ * Migration 10's code step. Each generation's JSON coverage becomes `index_items` and `index_inputs` rows keyed by content hash,
+ * and its embedded vectors move to `embeddings` under (fingerprint, content hash), so a vector shared by two generations or two
+ * items is stored once. All or nothing per generation: one unverifiable input leaves that generation's JSON coverage in place,
+ * where it never reads (as before). Then the copy of `vectors` is dropped and active generations catch up with captures made since they
+ * were built: their delta is queued, not a rebuild.
+ */
+export function incrementalIndex(db) {
+    const chunks = new Map();
+    for (const g of db.prepare('SELECT id,fingerprint,coverage_json FROM index_generations ORDER BY rowid').all()) {
+        const coverage = parse(g.coverage_json);
+        if (!coverage || coverage.version !== 1 || !Array.isArray(coverage.revisions) || !Array.isArray(coverage.inputs))
+            continue;
+        const revisions = coverage.revisions, inputs = coverage.inputs, content = new Map(), images = new Set(inputs.filter((i) => i?.kind === 'image').map((i) => i.sourceId));
+        if (!revisions.every((r) => typeof r?.itemId === 'string' &&
+            typeof r.revisionId === 'string' &&
+            db.prepare('SELECT 1 FROM revisions WHERE id=? AND item_id=?').get(r.revisionId, r.itemId)))
+            continue;
+        for (const input of inputs) {
+            const key = input && typeof input.sourceId === 'string' && typeof input.revisionId === 'string'
+                ? contentOf(db, input, chunks)
+                : undefined;
+            if (!key || content.has(input.sourceId))
+                break;
+            content.set(input.sourceId, key);
+        }
+        if (content.size !== inputs.length)
+            continue;
+        for (const r of revisions)
+            db.prepare('INSERT OR IGNORE INTO index_items VALUES(?,?,?)').run(g.id, r.itemId, r.revisionId);
+        for (const input of inputs)
+            db.prepare('INSERT INTO index_inputs VALUES(?,?,?,?)').run(g.id, input.sourceId, input.revisionId, content.get(input.sourceId));
+        // A document vector is the embedding of its content exactly when its input hash is that content hash; first writer wins.
+        for (const v of db
+            .prepare('SELECT source_id,input_hash,vector FROM temp.vectors_v9 WHERE generation_id=? AND input_hash IS NOT NULL ORDER BY rowid')
+            .all(g.id)) {
+            const source = String(v.source_id), key = content.get(source);
+            if (!key || (!images.has(source) && v.input_hash !== key))
+                continue;
+            db.prepare('INSERT OR IGNORE INTO embeddings VALUES(?,?,?,?)').run(g.fingerprint, key, v.input_hash, v.vector);
+        }
+        db.prepare('UPDATE index_generations SET coverage_json=? WHERE id=?').run(coverageMarker, g.id);
+    }
+    db.exec('DROP TABLE temp.vectors_v9');
+    trackLibrary(db);
+}

package/dist/src/inference/asr/bridge.js

@@ -8,8 +8,12 @@ try {
     child.stderr.pipe(process.stderr);
     child.stdin.on('error', () => { });
     child.stdin.end(JSON.stringify(config.request) + '\n');
-    child.once('error', () => { process.exitCode = 1; });
-    child.once('close', code => { process.exitCode = code ?? 1; });
+    child.once('error', () => {
+        process.exitCode = 1;
+    });
+    child.once('close', (code) => {
+        process.exitCode = code ?? 1;
+    });
 }
 catch {
     process.exitCode = 1;

package/dist/src/inference/asr/protocol.js

@@ -1,14 +1,36 @@
-import { createHash } from 'node:crypto';
-export const asrIdentity = { engine: 'Cactus-Compute/needle3@93e88ede867e4311c39151285e74df513e4b835b', model: 'Cactus-Compute/whistle@ca5287601bef25af26dcf2e1b2bdc0843a7c19e5', modelSha256: 'b6e02f048568ac5d01a2042556c658061e699acbc0aa2a1439f52f3d461dffeb', modelBytes: 16919407 };
-export const asrLimits = { outputBytes: 4 * 1024 ** 2, frameBytes: 4 * 1024 ** 2, words: 30000, maximumDurationMs: 3600000, windowDurationMs: 60000, overlapMs: 4000, deadlineMs: 180000 };
-const fail = () => { throw Error('integrity'); };
+import { sha256 } from '../../util/hash.js';
+import { SpongeError } from '../../errors.js';
+export const asrIdentity = {
+    engine: 'Cactus-Compute/needle3@93e88ede867e4311c39151285e74df513e4b835b',
+    model: 'Cactus-Compute/whistle@ca5287601bef25af26dcf2e1b2bdc0843a7c19e5',
+    modelSha256: 'b6e02f048568ac5d01a2042556c658061e699acbc0aa2a1439f52f3d461dffeb',
+    modelBytes: 16919407,
+};
+export const asrLimits = {
+    outputBytes: 4 * 1024 ** 2,
+    frameBytes: 4 * 1024 ** 2,
+    words: 30000,
+    maximumDurationMs: 3600000,
+    windowDurationMs: 60000,
+    overlapMs: 4000,
+    deadlineMs: 180000,
+};
+const fail = () => {
+    throw new SpongeError('integrity');
+};
 const obj = (v) => v && typeof v === 'object' && !Array.isArray(v) ? v : fail();
 const finite = (v, min = 0, max = Number.MAX_SAFE_INTEGER) => typeof v === 'number' && Number.isFinite(v) && v >= min && v <= max ? v : fail();
-function time(v) { const t = obj(v); if (!Number.isSafeInteger(t.value) || !Number.isSafeInteger(t.timescale) || t.timescale <= 0)
-    fail(); return finite(t.value / t.timescale, 0, asrLimits.maximumDurationMs / 1000); }
+function time(v) {
+    const t = obj(v);
+    if (!Number.isSafeInteger(t.value) || !Number.isSafeInteger(t.timescale) || t.timescale <= 0)
+        fail();
+    return finite(t.value / t.timescale, 0, asrLimits.maximumDurationMs / 1000);
+}
 /** Decode only correlated native events; diagnostics never become error classifications. */
 export function parseAsrOutput(stdout, requestId, sourceSha256, helperSha256) {
-    if (Buffer.byteLength(stdout) > asrLimits.outputBytes || !/^[a-f0-9]{64}$/.test(sourceSha256) || !/^[a-f0-9]{64}$/.test(helperSha256))
+    if (Buffer.byteLength(stdout) > asrLimits.outputBytes ||
+        !/^[a-f0-9]{64}$/.test(sourceSha256) ||
+        !/^[a-f0-9]{64}$/.test(helperSha256))
         fail();
     let ready = false, result;
     for (const line of stdout.split('\n')) {
@@ -18,43 +40,111 @@ export function parseAsrOutput(stdout, requestId, sourceSha256, helperSha256) {
             fail();
         const event = obj(JSON.parse(line));
         if (event.type === 'ready') {
-            if (ready || event.protocolVersion !== 2 || event.engine !== asrIdentity.engine || event.model !== asrIdentity.model)
+            if (ready ||
+                event.protocolVersion !== 2 ||
+                event.engine !== asrIdentity.engine ||
+                event.model !== asrIdentity.model)
                 fail();
             ready = true;
         }
         else if (event.type === 'progress') {
-            if (!ready || result || event.id !== requestId || !['verifying', 'extracting', 'recognizing'].includes(event.stage))
+            if (!ready ||
+                result ||
+                event.id !== requestId ||
+                !['verifying', 'extracting', 'recognizing'].includes(event.stage))
                 fail();
         }
         else if (event.type === 'result') {
-            if (!ready || result || event.id !== requestId || event.sourceSha256 !== sourceSha256 || event.engine !== asrIdentity.engine || event.model !== asrIdentity.model)
+            if (!ready ||
+                result ||
+                event.id !== requestId ||
+                event.sourceSha256 !== sourceSha256 ||
+                event.engine !== asrIdentity.engine ||
+                event.model !== asrIdentity.model)
                 fail();
             result = event;
         }
         else if (event.type === 'error' || event.type === 'fatal')
-            throw Error('unclassified');
+            throw new SpongeError('unclassified');
         else
             fail();
     }
     if (!ready || !result || result.hasAudio !== true)
         return fail();
     const recognition = obj(result.recognition), map = obj(result.audioMap);
-    if (recognition.language !== 'en' || typeof recognition.text !== 'string' || !Array.isArray(recognition.words) || recognition.words.length > asrLimits.words || map.sampleRate !== 16000 || !Number.isSafeInteger(map.sampleCount) || map.sampleCount < 0 || map.sampleCount > asrLimits.windowDurationMs * 16 || !Array.isArray(map.spans) || map.spans.length > 30000)
+    if (recognition.language !== 'en' ||
+        typeof recognition.text !== 'string' ||
+        !Array.isArray(recognition.words) ||
+        recognition.words.length > asrLimits.words ||
+        map.sampleRate !== 16000 ||
+        !Number.isSafeInteger(map.sampleCount) ||
+        map.sampleCount < 0 ||
+        map.sampleCount > asrLimits.windowDurationMs * 16 ||
+        !Array.isArray(map.spans) ||
+        map.spans.length > 30000)
         fail();
     const durationMs = time(map.sourceDuration) * 1000;
     if (durationMs <= 0)
         fail();
     let sampleEnd = 0, sourceEnd = 0;
-    const spans = map.spans.map((raw) => { const s = obj(raw), range = obj(s.source), start = time(range.start), end = time(range.end); if (!Number.isSafeInteger(s.sampleStart) || !Number.isSafeInteger(s.sampleEnd) || s.sampleStart !== sampleEnd || s.sampleEnd <= s.sampleStart || s.sampleEnd > map.sampleCount || start < sourceEnd || end <= start || end * 1000 > durationMs + .1 || !['audio', 'silence'].includes(s.kind))
-        fail(); sampleEnd = s.sampleEnd; sourceEnd = end; return { sampleStart: s.sampleStart, sampleEnd: s.sampleEnd, start, end }; });
+    const spans = map.spans.map((raw) => {
+        const s = obj(raw), range = obj(s.source), start = time(range.start), end = time(range.end);
+        if (!Number.isSafeInteger(s.sampleStart) ||
+            !Number.isSafeInteger(s.sampleEnd) ||
+            s.sampleStart !== sampleEnd ||
+            s.sampleEnd <= s.sampleStart ||
+            s.sampleEnd > map.sampleCount ||
+            start < sourceEnd ||
+            end <= start ||
+            end * 1000 > durationMs + 0.1 ||
+            !['audio', 'silence'].includes(s.kind))
+            fail();
+        sampleEnd = s.sampleEnd;
+        sourceEnd = end;
+        return { sampleStart: s.sampleStart, sampleEnd: s.sampleEnd, start, end };
+    });
     if (sampleEnd !== map.sampleCount)
         fail();
-    const sourceTime = (seconds, end) => { const sample = seconds * 16000; const span = spans.find(s => sample >= s.sampleStart && (end ? sample <= s.sampleEnd : sample < s.sampleEnd)) ?? (sample === map.sampleCount ? spans.at(-1) : undefined); if (!span)
-        return fail(); return (span.start + (sample - span.sampleStart) / (span.sampleEnd - span.sampleStart) * (span.end - span.start)) * 1000; };
+    const sourceTime = (seconds, end) => {
+        const sample = seconds * 16000;
+        const span = spans.find((s) => sample >= s.sampleStart && (end ? sample <= s.sampleEnd : sample < s.sampleEnd)) ??
+            (sample === map.sampleCount ? spans.at(-1) : undefined);
+        if (!span)
+            return fail();
+        return ((span.start + ((sample - span.sampleStart) / (span.sampleEnd - span.sampleStart)) * (span.end - span.start)) *
+            1000);
+    };
     let prior = 0;
-    const segments = recognition.words.map((raw) => { const w = obj(raw); if (typeof w.word !== 'string' || !w.word.trim() || Buffer.byteLength(w.word) > 16384)
-        fail(); const start = finite(w.start, prior, map.sampleCount / 16000), end = finite(w.end, start, map.sampleCount / 16000); prior = start; return { startMs: sourceTime(start, false), endMs: sourceTime(end, true), text: w.word.trim() }; });
+    const segments = recognition.words.map((raw) => {
+        const w = obj(raw);
+        if (typeof w.word !== 'string' || !w.word.trim() || Buffer.byteLength(w.word) > 16384)
+            fail();
+        const start = finite(w.start, prior, map.sampleCount / 16000), end = finite(w.end, start, map.sampleCount / 16000);
+        prior = start;
+        return { startMs: sourceTime(start, false), endMs: sourceTime(end, true), text: w.word.trim() };
+    });
     if (!segments.length && recognition.text.trim())
         fail();
-    return { schemaVersion: 1, requestId, source: 'local-asr', language: 'en', modelFingerprint: createHash('sha256').update(JSON.stringify(['sponge-asr-v1', asrIdentity, helperSha256, 'decoded-audio-map-window-v2', { windowDurationMs: asrLimits.windowDurationMs, overlapMs: asrLimits.overlapMs, join: 'source-midpoint-overlap-dedupe-v1' }])).digest('hex'), segments, cleanup: 'settled', sourceSha256, timing: 'decoded-audio-map', durationMs };
+    return {
+        schemaVersion: 1,
+        requestId,
+        source: 'local-asr',
+        language: 'en',
+        modelFingerprint: sha256(JSON.stringify([
+            'sponge-asr-v1',
+            asrIdentity,
+            helperSha256,
+            'decoded-audio-map-window-v2',
+            {
+                windowDurationMs: asrLimits.windowDurationMs,
+                overlapMs: asrLimits.overlapMs,
+                join: 'source-midpoint-overlap-dedupe-v1',
+            },
+        ])),
+        segments,
+        cleanup: 'settled',
+        sourceSha256,
+        timing: 'decoded-audio-map',
+        durationMs,
+    };
 }

package/dist/src/inference/asr/runtime.js

@@ -8,14 +8,15 @@ import { failure } from '../../acquisition/errors.js';
 import { privateRoot } from '../../acquisition/files.js';
 import { asrIdentity, asrLimits, parseAsrOutput } from './protocol.js';
 import { audioWindows, joinWindows } from './windows.js';
+import { SpongeError, codeOf } from '../../errors.js';
 async function verify(path, sha256, maximum, expected) {
-    if (!isAbsolute(path) || !/^[a-f0-9]{64}$/.test(sha256) || await realpath(path) !== path)
-        throw Error('integrity');
+    if (!isAbsolute(path) || !/^[a-f0-9]{64}$/.test(sha256) || (await realpath(path)) !== path)
+        throw new SpongeError('integrity');
     const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     try {
         const stat = await file.stat();
-        if (!stat.isFile() || stat.size > maximum || expected !== undefined && stat.size !== expected)
-            throw Error('integrity');
+        if (!stat.isFile() || stat.size > maximum || (expected !== undefined && stat.size !== expected))
+            throw new SpongeError('integrity');
         const hash = createHash('sha256'), buffer = Buffer.alloc(65536);
         let bytes = 0;
         for (;;) {
@@ -24,27 +25,38 @@ async function verify(path, sha256, maximum, expected) {
                 break;
             bytes += bytesRead;
             if (bytes > maximum)
-                throw Error('limit-exceeded');
+                throw new SpongeError('limit-exceeded');
             hash.update(buffer.subarray(0, bytesRead));
         }
         if (bytes !== stat.size || hash.digest('hex') !== sha256)
-            throw Error('integrity');
+            throw new SpongeError('integrity');
     }
     finally {
         await file.close();
     }
 }
 /** Portable callers can use captions; this pinned native artifact requires macOS26 arm64. */
-export function supportsNativeAsr(platform = process.platform, arch = process.arch, kernel = release()) { return platform === 'darwin' && arch === 'arm64' && /^\d+\./.test(kernel) && Number(kernel.split('.')[0]) >= 25; }
+export function supportsNativeAsr(platform = process.platform, arch = process.arch, kernel = release()) {
+    return platform === 'darwin' && arch === 'arm64' && /^\d+\./.test(kernel) && Number(kernel.split('.')[0]) >= 25;
+}
 export async function transcribeAudio(requestId, audio, language, options) {
-    const error = (code, cleanup = 'settled') => ({ ...failure(requestId, code, cleanup === 'pending' ? 'cleanup' : 'inference'), cleanup });
+    const error = (code, cleanup = 'settled') => ({
+        ...failure(requestId, code, cleanup === 'pending' ? 'cleanup' : 'inference'),
+        cleanup,
+    });
     if (options.signal?.aborted)
         return error('cancelled');
     if (!supportsNativeAsr() || language !== 'en')
         return error('unsupported');
     if (!options.runtime)
         return error('runtime-missing');
-    if (!/^[A-Za-z0-9_-]{1,128}$/.test(requestId) || !Number.isSafeInteger(audio.bytes) || audio.bytes < 1 || audio.bytes > 512 * 1024 ** 2 || !Number.isFinite(audio.durationMs) || audio.durationMs <= 0 || audio.durationMs > asrLimits.maximumDurationMs)
+    if (!/^[A-Za-z0-9_-]{1,128}$/.test(requestId) ||
+        !Number.isSafeInteger(audio.bytes) ||
+        audio.bytes < 1 ||
+        audio.bytes > 512 * 1024 ** 2 ||
+        !Number.isFinite(audio.durationMs) ||
+        audio.durationMs <= 0 ||
+        audio.durationMs > asrLimits.maximumDurationMs)
         return error('limit-exceeded');
     let scratch, cleanup = 'settled', outcome;
     try {
@@ -60,34 +72,59 @@ export async function transcribeAudio(requestId, audio, language, options) {
         const windows = audioWindows(audio.durationMs), transcripts = [];
         let totalWords = 0;
         for (const window of windows) {
-            await writeFile(requestFile, JSON.stringify({ helper: runtime.helper, model: runtime.model, request: { id: requestId, sourcePath: audio.path, expectedSourceSha256: audio.sha256, windowStartMs: window.startMs, windowEndMs: window.endMs } }), { mode: 0o600, flag: transcripts.length ? 'w' : 'wx' });
+            await writeFile(requestFile, JSON.stringify({
+                helper: runtime.helper,
+                model: runtime.model,
+                request: {
+                    id: requestId,
+                    sourcePath: audio.path,
+                    expectedSourceSha256: audio.sha256,
+                    windowStartMs: window.startMs,
+                    windowEndMs: window.endMs,
+                },
+            }), { mode: 0o600, flag: transcripts.length ? 'w' : 'wx' });
             cleanup = 'pending';
-            const result = await options.runProcess(process.execPath, source ? ['--import', import.meta.resolve('tsx'), entry, requestFile] : [entry, requestFile], { env: { PATH: '/usr/bin:/bin', HOME: scratch, TMPDIR: scratch, LANG: 'en_US.UTF-8' }, deadlineMs: asrLimits.deadlineMs, maxOutputBytes: asrLimits.outputBytes, signal: options.signal });
+            const result = await options.runProcess(process.execPath, source ? ['--import', import.meta.resolve('tsx'), entry, requestFile] : [entry, requestFile], {
+                env: { PATH: '/usr/bin:/bin', HOME: scratch, TMPDIR: scratch, LANG: 'en_US.UTF-8' },
+                deadlineMs: asrLimits.deadlineMs,
+                maxOutputBytes: asrLimits.outputBytes,
+                signal: options.signal,
+            });
             cleanup = result.cleanup;
             if (cleanup === 'pending')
-                throw Error('cleanup-required');
+                throw new SpongeError('cleanup-required');
             if (options.signal?.aborted || result.stopped === 'cancelled')
-                throw Error('cancelled');
+                throw new SpongeError('cancelled');
             if (result.stopped)
-                throw Error(result.stopped);
+                throw new SpongeError(result.stopped);
             if (result.code !== 0)
-                throw Error('unclassified');
+                throw new SpongeError('unclassified');
             const transcript = parseAsrOutput(result.stdout, requestId, audio.sha256, runtime.helperSha256);
             if (Math.abs(transcript.durationMs - audio.durationMs) > 1000)
-                throw Error('integrity');
-            if (transcript.segments.some(s => s.startMs < window.startMs - .1 || s.endMs > window.endMs + .1))
-                throw Error('integrity');
+                throw new SpongeError('integrity');
+            if (transcript.segments.some((s) => s.startMs < window.startMs - 0.1 || s.endMs > window.endMs + 0.1))
+                throw new SpongeError('integrity');
             totalWords += transcript.segments.length;
             if (totalWords > asrLimits.words)
-                throw Error('limit-exceeded');
+                throw new SpongeError('limit-exceeded');
             transcripts.push(transcript);
         }
         await verify(audio.path, audio.sha256, 512 * 1024 ** 2, audio.bytes);
         outcome = { ok: true, transcript: joinWindows(windows, transcripts), cleanup };
     }
     catch (e) {
-        const code = e instanceof Error ? e.message : '';
-        outcome = error(cleanup === 'pending' ? 'cleanup-required' : code === 'integrity' ? 'integrity' : code === 'limit-exceeded' ? 'limit-exceeded' : code === 'cancelled' ? 'cancelled' : code === 'unavailable' ? 'unavailable' : 'unclassified', cleanup);
+        const code = codeOf(e);
+        outcome = error(cleanup === 'pending'
+            ? 'cleanup-required'
+            : code === 'integrity'
+                ? 'integrity'
+                : code === 'limit-exceeded'
+                    ? 'limit-exceeded'
+                    : code === 'cancelled'
+                        ? 'cancelled'
+                        : code === 'unavailable'
+                            ? 'unavailable'
+                            : 'unclassified', cleanup);
     }
     finally {
         if (scratch && cleanup === 'settled') {

package/dist/src/inference/asr/windows.js

@@ -1,7 +1,8 @@
 import { asrLimits } from './protocol.js';
+import { SpongeError } from '../../errors.js';
 export function audioWindows(durationMs) {
     if (!Number.isFinite(durationMs) || durationMs <= 0 || durationMs > asrLimits.maximumDurationMs)
-        throw Error('limit-exceeded');
+        throw new SpongeError('limit-exceeded');
     durationMs = Math.ceil(durationMs);
     const result = [];
     for (let startMs = 0; startMs < durationMs; startMs += asrLimits.windowDurationMs - asrLimits.overlapMs) {
@@ -16,12 +17,15 @@ export function audioWindows(durationMs) {
  * words are removed only when their time ranges overlap, never globally. */
 export function joinWindows(windows, transcripts) {
     if (!transcripts.length || windows.length !== transcripts.length)
-        throw Error('integrity');
+        throw new SpongeError('integrity');
     const first = transcripts[0], segments = [];
     for (let i = 0; i < windows.length; i++) {
         const window = windows[i], transcript = transcripts[i];
-        if (transcript.sourceSha256 !== first.sourceSha256 || transcript.durationMs !== first.durationMs || transcript.modelFingerprint !== first.modelFingerprint || transcript.requestId !== first.requestId)
-            throw Error('integrity');
+        if (transcript.sourceSha256 !== first.sourceSha256 ||
+            transcript.durationMs !== first.durationMs ||
+            transcript.modelFingerprint !== first.modelFingerprint ||
+            transcript.requestId !== first.requestId)
+            throw new SpongeError('integrity');
         const lower = i ? (windows[i - 1].endMs + window.startMs) / 2 : 0, upper = i + 1 < windows.length ? (window.endMs + windows[i + 1].startMs) / 2 : Infinity;
         for (const segment of transcript.segments) {
             const center = (segment.startMs + segment.endMs) / 2;
@@ -33,7 +37,7 @@ export function joinWindows(windows, transcripts) {
                 continue;
             }
             if (prior && segment.startMs < prior.startMs)
-                throw Error('integrity');
+                throw new SpongeError('integrity');
             segments.push({ ...segment });
         }
     }