@hraness/sponge 0.2.5 → 0.3.0

package/dist/src/acquisition/verify-helper.js

@@ -1,19 +1,26 @@
+import { SpongeError } from '../errors.js';
 // Executed only by the pinned Bun runtime. The import is Wordcell's public API.
 const runtime = process.argv[2], bundle = process.argv[3];
 try {
     const { verifyCaptureBundle } = await import(import.meta.resolve('@hraness/wordcell/clip/bundle-reader', `${runtime}/package.json`));
-    const result = await verifyCaptureBundle(bundle, { verifyAssets: true, maxDocumentBytes: 16 * 1024 ** 2, maxVerifiedAssets: 200, maxAssetBytes: 20 * 1024 ** 2, maxTotalAssetBytes: 500 * 1024 ** 2, maxAssetVerificationMs: 30000 });
+    const result = await verifyCaptureBundle(bundle, {
+        verifyAssets: true,
+        maxDocumentBytes: 16 * 1024 ** 2,
+        maxVerifiedAssets: 200,
+        maxAssetBytes: 20 * 1024 ** 2,
+        maxTotalAssetBytes: 500 * 1024 ** 2,
+        maxAssetVerificationMs: 30000,
+    });
     // The document travels via the verified file, never a giant protocol frame.
     const { markdown: _, ...document } = result.inspection.document;
     // Metadata is validated upstream and read from the confined manifest by the parent.
     const { metadata: _metadata, ...inspection } = result.inspection;
     const output = JSON.stringify({ ...result, inspection: { ...inspection, document } });
     if (Buffer.byteLength(output) > 65536)
-        throw Error('frame-limit');
+        throw new SpongeError('limit-exceeded');
     process.stdout.write(output);
 }
 catch {
     process.stdout.write(JSON.stringify({ ok: false }));
     process.exitCode = 1;
 }
-export {};

package/dist/src/annotations/quote.js

@@ -10,10 +10,13 @@ const escapable = /^[\\`*_{}[\]()#+\-.!|>~<"']$/;
 function fold(raw) {
     let text = '', space = false;
     const map = [], ends = [], clusters = [...graphemes.segment(raw)];
-    const emit = (out, start, end) => { text += out; for (let k = 0; k < out.length; k++) {
-        map.push(start);
-        ends.push(end);
-    } };
+    const emit = (out, start, end) => {
+        text += out;
+        for (let k = 0; k < out.length; k++) {
+            map.push(start);
+            ends.push(end);
+        }
+    };
     for (let c = 0; c < clusters.length; c++) {
         const { segment, index } = clusters[c];
         // An escaped character maps to its backslash, so a match starting there keeps the escape.
@@ -29,7 +32,11 @@ function fold(raw) {
             continue;
         }
         space = false;
-        emit(ch.replace(/[‘’‚′]/g, "'").replace(/[“”„″]/g, '"').replace(/[\u2010-\u2015\u2212]/g, '-').normalize('NFC'), index, end);
+        emit(ch
+            .replace(/[‘’‚′]/g, "'")
+            .replace(/[“”„″]/g, '"')
+            .replace(/[\u2010-\u2015\u2212]/g, '-')
+            .normalize('NFC'), index, end);
     }
     if (text.endsWith(' ')) {
         text = text.slice(0, -1);
@@ -38,7 +45,9 @@ function fold(raw) {
     }
     return { text, map, ends };
 }
-export function foldText(value) { return fold(value).text; }
+export function foldText(value) {
+    return fold(value).text;
+}
 /** Every occurrence of `quote` in `source`, compared after folding. */
 export function locateAll(source, quote) {
     const s = fold(source), q = fold(quote).text, out = [];
@@ -47,14 +56,21 @@ export function locateAll(source, quote) {
     for (let at = s.text.indexOf(q); at >= 0; at = s.text.indexOf(q, at + 1)) {
         // A match must start and end on cluster boundaries; half a cluster has no raw offsets.
         const last = at + q.length - 1;
-        if (at > 0 && s.map[at - 1] === s.map[at] || last + 1 < s.text.length && s.map[last + 1] === s.map[last])
+        if ((at > 0 && s.map[at - 1] === s.map[at]) || (last + 1 < s.text.length && s.map[last + 1] === s.map[last]))
             continue;
         out.push({ start: s.map[at], end: s.ends[last] });
     }
     return out;
 }
 export function textQuote(source, start, end) {
-    return { type: 'text-quote', exact: source.slice(start, end), prefix: source.slice(Math.max(0, start - context), start), suffix: source.slice(end, end + context), start, end };
+    return {
+        type: 'text-quote',
+        exact: source.slice(start, end),
+        prefix: source.slice(Math.max(0, start - context), start),
+        suffix: source.slice(end, end + context),
+        start,
+        end,
+    };
 }
 /** The single match for `quote`, or undefined when absent or ambiguous. */
 export function locateQuote(source, quote) {
@@ -63,9 +79,16 @@ export function locateQuote(source, quote) {
 }
 /** A stored selector still names its exact text in `source`. */
 export function anchorHolds(source, anchor) {
-    return Number.isSafeInteger(anchor.start) && Number.isSafeInteger(anchor.end) && anchor.start >= 0 && anchor.end > anchor.start && source.slice(anchor.start, anchor.end) === anchor.exact;
+    return (Number.isSafeInteger(anchor.start) &&
+        Number.isSafeInteger(anchor.end) &&
+        anchor.start >= 0 &&
+        anchor.end > anchor.start &&
+        source.slice(anchor.start, anchor.end) === anchor.exact);
+}
+export function words(value) {
+    const t = foldText(value);
+    return t ? t.split(' ').length : 0;
 }
-export function words(value) { const t = foldText(value); return t ? t.split(' ').length : 0; }
 /**
  * Rendered-text projection for snapping a near-verbatim quote: drops inline Markdown syntax (link targets, brackets,
  * emphasis, code ticks, line-start block markers), folds like `fold`, and lowercases. Offsets map back to raw text.
@@ -90,7 +113,7 @@ function rendered(raw) {
                 continue;
             }
         }
-        if (ch === '!' && raw[i + 1] === '[' || /[[\]*_`]/.test(ch))
+        if ((ch === '!' && raw[i + 1] === '[') || /[[\]*_`]/.test(ch))
             continue;
         if (ch === '\\' && i + 1 < raw.length && /[\\`*_{}[\]()#+\-.!|>~<"']/.test(raw[i + 1])) {
             ch = raw[++i];
@@ -105,7 +128,12 @@ function rendered(raw) {
             continue;
         }
         space = false;
-        ch = ch.replace(/[‘’‚′]/g, "'").replace(/[“”„″]/g, '"').replace(/[‐-―−]/g, '-').normalize('NFC').toLowerCase();
+        ch = ch
+            .replace(/[‘’‚′]/g, "'")
+            .replace(/[“”„″]/g, '"')
+            .replace(/[‐-―−]/g, '-')
+            .normalize('NFC')
+            .toLowerCase();
         // One entry per output code unit: normalization and case mapping may change the length.
         text += ch;
         for (let k = 0; k < ch.length; k++) {

package/dist/src/annotations/store.d.ts

@@ -43,7 +43,6 @@ export declare function updateAnnotation(db: DatabaseSync, id: string, body: str
 export declare function deleteAnnotation(db: DatabaseSync, id: string): void;
 /** Reading state is one field per item; `updatedAt` travels with it. */
 export declare function setReadingState(db: DatabaseSync, itemId: string, state: unknown): void;
-export declare function readAnnotation(db: DatabaseSync, id: string): Annotation | undefined;
 /** The one annotation reader: live annotations in creation order, highlights checked against their revision. */
 export declare function listAnnotations(db: DatabaseSync, itemId: string): (Annotation & {
     anchored?: boolean;

package/dist/src/annotations/store.js

@@ -1,16 +1,23 @@
 import { randomUUID } from 'node:crypto';
 import { anchorHolds, locateAll, textQuote } from './quote.js';
 import { mutate } from '../store/changes.js';
-import { StoreError } from '../store/types.js';
-import { digest, text } from '../store/files.js';
+import { text } from '../store/files.js';
+import { sha256 } from '../util/hash.js';
+import { SpongeError } from '../errors.js';
 const now = () => new Date().toISOString();
-const fail = (code = 'invalid-input') => { throw new StoreError(code); };
+const fail = (code = 'invalid-input') => {
+    throw new SpongeError(code);
+};
 export function markdownFor(db, revisionId) {
-    const row = db.prepare("SELECT markdown FROM representations WHERE revision_id=? AND kind='markdown'").get(revisionId);
+    const row = db
+        .prepare("SELECT markdown FROM representations WHERE revision_id=? AND kind='markdown'")
+        .get(revisionId);
     return typeof row?.markdown === 'string' ? row.markdown : fail('unavailable');
 }
 /** Create through the log with the full row image, so a replay rebuilds the same row. */
-function create(db, id, row) { mutate(db, 'annotation', id, 'created', row); }
+function create(db, id, row) {
+    mutate(db, 'annotation', id, 'created', row);
+}
 /**
  * Highlight `quote` in the item's current revision. An ambiguous quote needs `occurrence` (0-based),
  * so a highlight never silently lands on the wrong passage.
@@ -27,7 +34,15 @@ export function addHighlight(db, input) {
     if (!Number.isSafeInteger(index) || index < 0 || index >= matches.length)
         fail();
     const anchor = textQuote(source, matches[index].start, matches[index].end), id = randomUUID();
-    create(db, id, { itemId: input.itemId, kind: 'highlight', revisionId, parentId: null, anchor, body: input.note ?? '', createdAt: now() });
+    create(db, id, {
+        itemId: input.itemId,
+        kind: 'highlight',
+        revisionId,
+        parentId: null,
+        anchor,
+        body: input.note ?? '',
+        createdAt: now(),
+    });
     return readAnnotation(db, id);
 }
 export function addComment(db, input) {
@@ -40,7 +55,15 @@ export function addComment(db, input) {
             fail('unavailable');
     }
     const id = randomUUID();
-    create(db, id, { itemId: input.itemId, kind: 'comment', revisionId: null, parentId: input.parentId ?? null, anchor: null, body: input.body, createdAt: now() });
+    create(db, id, {
+        itemId: input.itemId,
+        kind: 'comment',
+        revisionId: null,
+        parentId: input.parentId ?? null,
+        anchor: null,
+        body: input.body,
+        createdAt: now(),
+    });
     return readAnnotation(db, id);
 }
 /**
@@ -48,14 +71,23 @@ export function addComment(db, input) {
  * once the user edits or deletes it, the user's choice wins and the import skips it.
  */
 export function importNote(db, input) {
-    const id = digest(JSON.stringify(['import-note-v1', input.namespace, input.sourceKey, input.noteId]));
+    const id = sha256(JSON.stringify(['import-note-v1', input.namespace, input.sourceKey, input.noteId]));
     const prior = db.prepare('SELECT item_id,body,updated_at,deleted_at FROM annotations WHERE id=?').get(id);
     if (prior) {
-        if (prior.item_id !== input.itemId || prior.body !== input.body && prior.updated_at === null && prior.deleted_at === null)
+        if (prior.item_id !== input.itemId ||
+            (prior.body !== input.body && prior.updated_at === null && prior.deleted_at === null))
             fail('integrity');
         return;
     }
-    create(db, id, { itemId: input.itemId, kind: 'note', revisionId: input.revisionId, parentId: null, anchor: { kind: 'imported-note', sourceId: input.noteId }, body: input.body, createdAt: now() });
+    create(db, id, {
+        itemId: input.itemId,
+        kind: 'note',
+        revisionId: input.revisionId,
+        parentId: null,
+        anchor: { kind: 'imported-note', sourceId: input.noteId },
+        body: input.body,
+        createdAt: now(),
+    });
 }
 export function updateAnnotation(db, id, body) {
     text(body, 16384);
@@ -75,12 +107,32 @@ export function deleteAnnotation(db, id) {
         mutate(db, 'annotation', id, 'deleted', now());
 }
 /** Reading state is one field per item; `updatedAt` travels with it. */
-export function setReadingState(db, itemId, state) { mutate(db, 'reading', itemId, 'state', { state, updatedAt: now() }); }
-function annotationRow(r) { return { id: String(r.id), itemId: String(r.item_id), kind: r.kind, revisionId: r.revision_id === null ? null : String(r.revision_id), parentId: r.parent_id === null ? null : String(r.parent_id), anchor: JSON.parse(String(r.anchor_json)), body: String(r.body), createdAt: String(r.created_at), updatedAt: r.updated_at === null ? null : String(r.updated_at) }; }
-export function readAnnotation(db, id) { const r = db.prepare('SELECT * FROM annotations WHERE id=? AND deleted_at IS NULL').get(id); return r ? annotationRow(r) : undefined; }
+export function setReadingState(db, itemId, state) {
+    mutate(db, 'reading', itemId, 'state', { state, updatedAt: now() });
+}
+function annotationRow(r) {
+    return {
+        id: String(r.id),
+        itemId: String(r.item_id),
+        kind: r.kind,
+        revisionId: r.revision_id === null ? null : String(r.revision_id),
+        parentId: r.parent_id === null ? null : String(r.parent_id),
+        anchor: JSON.parse(String(r.anchor_json)),
+        body: String(r.body),
+        createdAt: String(r.created_at),
+        updatedAt: r.updated_at === null ? null : String(r.updated_at),
+    };
+}
+function readAnnotation(db, id) {
+    const r = db.prepare('SELECT * FROM annotations WHERE id=? AND deleted_at IS NULL').get(id);
+    return r ? annotationRow(r) : undefined;
+}
 /** The one annotation reader: live annotations in creation order, highlights checked against their revision. */
 export function listAnnotations(db, itemId) {
-    return db.prepare('SELECT * FROM annotations WHERE item_id=? AND deleted_at IS NULL ORDER BY created_at,rowid').all(itemId).map(r => {
+    return db
+        .prepare('SELECT * FROM annotations WHERE item_id=? AND deleted_at IS NULL ORDER BY created_at,rowid')
+        .all(itemId)
+        .map((r) => {
         const a = annotationRow(r);
         if (a.kind !== 'highlight' || !a.revisionId)
             return a;

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

@@ -1,7 +1,7 @@
 import type { ErrorEnvelope, JobCheckpoint } from '../../contracts/index.js';
 import { type CaptureRequest, type CaptureOutcome, type CaptureRuntime, type CaptureConnection } from '../acquisition/index.js';
 import type { LibraryStore, AttemptToken } from '../store/index.js';
-export interface ArticleResult {
+interface ArticleResult {
     ok: true;
     itemId: string;
     revisionId: string;
@@ -21,3 +21,4 @@ export interface ArticleOptions {
 }
 /** One attempt. Durable queue policy and process recovery live above this function. */
 export declare function ingestArticle(store: LibraryStore, token: AttemptToken, options: ArticleOptions): Promise<ArticleOutcome>;
+export {};

package/dist/src/app/article.js

@@ -1,82 +1,78 @@
-import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { validateCapture } from '../../contracts/validate.js';
-import { captureArticle } from '../acquisition/index.js';
-import { failure } from '../acquisition/errors.js';
+import { captureArticle, } from '../acquisition/index.js';
+import { runAttempt, classifyErrors } from '../ingest/attempt.js';
+import { sha256 } from '../util/hash.js';
 import { bundleBytes, bundleText } from './bundle-files.js';
 import { selectedMetadata } from '../metadata/article.js';
 import { localizeMarkdown } from './markdown.js';
-const known = new Set(['integrity', 'limit-exceeded', 'cancelled', 'invalid-input', 'owner-busy', 'unavailable']);
+import { SpongeError } from '../errors.js';
+const classify = classifyErrors([
+    'integrity',
+    'limit-exceeded',
+    'cancelled',
+    'invalid-input',
+    'owner-busy',
+    'unavailable',
+]);
 /** One attempt. Durable queue policy and process recovery live above this function. */
-export async function ingestArticle(store, token, options) {
-    let captured, committed = false;
-    let outcome = failure(token.attemptId, 'unclassified', 'storage');
-    let cleanup = 'settled';
-    try {
-        const source = store.sourceForJob(token.jobId);
+export function ingestArticle(store, token, options) {
+    return runAttempt(store, token, classify, async (attempt) => {
+        const source = store.queue.source(token.jobId);
         if (!source || source.kind !== 'article')
-            throw Object.assign(Error('unsupported'), { code: 'invalid-input' });
-        const result = await (options.capture ?? captureArticle)({ runProcess: options.runProcess, runtime: options.runtime, stagingRoot: join(store.root, 'staging'), sourceUrl: source.locator, requestId: token.attemptId, connection: options.connection, signal: options.signal, allowPrivateNetwork: options.allowPrivateNetwork });
+            throw new SpongeError('invalid-input');
+        const result = await (options.capture ?? captureArticle)({
+            runProcess: options.runProcess,
+            runtime: options.runtime,
+            stagingRoot: join(store.root, 'staging'),
+            sourceUrl: source.locator,
+            requestId: token.attemptId,
+            connection: options.connection,
+            signal: options.signal,
+            allowPrivateNetwork: options.allowPrivateNetwork,
+        });
         if (!result.ok) {
-            outcome = result;
-            cleanup = result.code === 'cleanup-required' ? 'pending' : 'settled';
+            if (result.code === 'cleanup-required')
+                attempt.cleanup = 'pending';
+            return result;
         }
-        else {
-            captured = result;
-            await options.checkpoint?.('extracting');
-            const capture = result.capture;
-            validateCapture(capture);
-            if (capture.kind !== 'article' || capture.requestId !== token.attemptId || capture.sourceUrl !== source.locator)
-                throw Object.assign(Error('integrity'), { code: 'integrity' });
-            const original = await bundleText(result.bundleRoot, capture.markdown), localized = localizeMarkdown(original, capture.assets);
-            const assets = [];
-            for (const asset of capture.assets) {
-                if (options.signal?.aborted)
-                    throw Object.assign(Error('cancelled'), { code: 'cancelled' });
-                const blob = await store.putBlob(token, asset.sha256, asset.bytes, bundleBytes(result.bundleRoot, asset));
-                assets.push({ ...blob, mediaType: asset.mediaType });
-            }
-            if (options.signal?.aborted) {
-                store.requestCancellation(token.jobId);
-                throw Object.assign(Error('cancelled'), { code: 'cancelled' });
-            }
-            const selectedTitle = selectedMetadata(capture.metadata, 'title')?.value;
-            const title = typeof selectedTitle === 'string' ? selectedTitle : undefined;
-            const status = localized.missingImages ? 'partial' : capture.status;
-            // Representation algorithm participates in identity: later extraction changes cannot reuse an old payload.
-            const bundleHash = createHash('sha256').update(JSON.stringify(['article-local-markdown-v1', capture.manifestSha256])).digest('hex');
-            await options.checkpoint?.('promoting');
-            const revision = store.commitRevision({ ...token, itemId: source.itemId, bundleHash, markdown: localized.markdown, title, extractor: capture.extractor, status, metadata: capture.metadata, metadataWarnings: capture.metadataWarnings, assets, warnings: [...new Set([...capture.warnings, ...(localized.missingImages ? ['partial'] : [])])] });
-            committed = true;
-            outcome = { ok: true, itemId: source.itemId, revisionId: revision.revisionId, status };
+        attempt.hold(result);
+        await options.checkpoint?.('extracting');
+        const capture = result.capture;
+        validateCapture(capture);
+        if (capture.kind !== 'article' || capture.requestId !== token.attemptId || capture.sourceUrl !== source.locator)
+            throw new SpongeError('integrity');
+        const original = await bundleText(result.bundleRoot, capture.markdown), localized = localizeMarkdown(original, capture.assets);
+        const assets = [];
+        for (const asset of capture.assets) {
+            if (options.signal?.aborted)
+                throw new SpongeError('cancelled');
+            const blob = await store.blobs.put(token, asset.sha256, asset.bytes, bundleBytes(result.bundleRoot, asset));
+            assets.push({ ...blob, mediaType: asset.mediaType });
         }
-    }
-    catch (error) {
-        const code = error?.code;
-        outcome = failure(token.attemptId, code && known.has(code) ? code : 'unclassified', 'storage');
-    }
-    if (captured)
-        try {
-            await captured.dispose();
+        if (options.signal?.aborted) {
+            store.queue.cancel(token.jobId);
+            throw new SpongeError('cancelled');
         }
-        catch {
-            cleanup = 'pending';
-        }
-    if (!committed)
-        try {
-            store.failAttempt(token, outcome.ok ? 'unclassified' : outcome.code, outcome.ok ? {} : { retryable: outcome.retryable, retryAfterMs: outcome.retryAfterMs });
-        }
-        catch {
-            cleanup = 'pending';
-        }
-    if (cleanup === 'settled')
-        try {
-            store.settleAttempt(token);
-        }
-        catch {
-            cleanup = 'pending';
-        }
-    if (cleanup === 'pending')
-        return { ...failure(token.attemptId, 'cleanup-required', 'cleanup'), cleanup };
-    return { ...outcome, cleanup };
+        const selectedTitle = selectedMetadata(capture.metadata, 'title')?.value;
+        const title = typeof selectedTitle === 'string' ? selectedTitle : undefined;
+        const status = localized.missingImages ? 'partial' : capture.status;
+        // Representation algorithm participates in identity: later extraction changes cannot reuse an old payload.
+        const bundleHash = sha256(JSON.stringify(['article-local-markdown-v1', capture.manifestSha256]));
+        await options.checkpoint?.('promoting');
+        const revision = store.revisions.commit({
+            ...token,
+            itemId: source.itemId,
+            bundleHash,
+            markdown: localized.markdown,
+            title,
+            extractor: capture.extractor,
+            status,
+            metadata: capture.metadata,
+            metadataWarnings: capture.metadataWarnings,
+            assets,
+            warnings: [...new Set([...capture.warnings, ...(localized.missingImages ? ['partial'] : [])])],
+        });
+        return { ok: true, itemId: source.itemId, revisionId: revision.revisionId, status };
+    });
 }

package/dist/src/app/bundle-files.d.ts

@@ -1,8 +1,4 @@
 import { type Asset } from '../../contracts/index.js';
-export declare class BundleIntegrityError extends Error {
-    readonly code = "integrity";
-    constructor();
-}
 /** Stream only the verified regular inode; parent path checks never follow symlinks. */
 export declare function bundleBytes(root: string, asset: Asset): AsyncGenerator<Uint8Array>;
 export declare function bundleText(root: string, asset: Asset): Promise<string>;

package/dist/src/app/bundle-files.js

@@ -4,32 +4,29 @@ import { createHash } from 'node:crypto';
 import { dirname, join, isAbsolute, relative, sep } from 'node:path';
 import { limits } from '../../contracts/index.js';
 import { validateAsset } from '../../contracts/validate.js';
-export class BundleIntegrityError extends Error {
-    code = 'integrity';
-    constructor() { super('integrity'); }
-}
+import { SpongeError } from '../errors.js';
 /** Stream only the verified regular inode; parent path checks never follow symlinks. */
 export async function* bundleBytes(root, asset) {
     validateAsset(asset);
     if (asset.bytes > limits.pdfBytes)
-        throw new BundleIntegrityError();
-    if (!isAbsolute(root) || await realpath(root) !== root)
-        throw new BundleIntegrityError();
+        throw new SpongeError('integrity');
+    if (!isAbsolute(root) || (await realpath(root)) !== root)
+        throw new SpongeError('integrity');
     const path = join(root, asset.relativePath), rel = relative(root, path);
     if (!rel || rel.startsWith('..' + sep) || isAbsolute(rel))
-        throw new BundleIntegrityError();
+        throw new SpongeError('integrity');
     let parent = root;
     for (const part of relative(root, dirname(path)).split(sep).filter(Boolean)) {
         parent = join(parent, part);
         const stat = await lstat(parent);
         if (!stat.isDirectory() || stat.isSymbolicLink())
-            throw new BundleIntegrityError();
+            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.nlink !== 1 || stat.size !== asset.bytes)
-            throw new BundleIntegrityError();
+            throw new SpongeError('integrity');
         const digest = createHash('sha256');
         let count = 0;
         for (;;) {
@@ -39,13 +36,13 @@ export async function* bundleBytes(root, asset) {
                 break;
             count += bytesRead;
             if (count > asset.bytes)
-                throw new BundleIntegrityError();
+                throw new SpongeError('integrity');
             const bytes = buffer.subarray(0, bytesRead);
             digest.update(bytes);
             yield bytes;
         }
         if (count !== asset.bytes || digest.digest('hex') !== asset.sha256)
-            throw new BundleIntegrityError();
+            throw new SpongeError('integrity');
     }
     finally {
         await file.close();
@@ -53,7 +50,7 @@ export async function* bundleBytes(root, asset) {
 }
 export async function bundleText(root, asset) {
     if (asset.mediaType !== 'text/markdown' || asset.bytes > limits.markdownBytes)
-        throw new BundleIntegrityError();
+        throw new SpongeError('integrity');
     const chunks = [];
     for await (const chunk of bundleBytes(root, asset))
         chunks.push(chunk);
@@ -61,6 +58,6 @@ export async function bundleText(root, asset) {
         return new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks));
     }
     catch {
-        throw new BundleIntegrityError();
+        throw new SpongeError('integrity');
     }
 }

package/dist/src/app/markdown.js

@@ -1,16 +1,19 @@
 import { fromMarkdown } from 'mdast-util-from-markdown';
 import { toMarkdown } from 'mdast-util-to-markdown';
+import { SpongeError } from '../errors.js';
 const assetPrefix = 'sponge-asset:';
 function localKey(url) {
     try {
         const key = decodeURIComponent(url).replace(/^\.\//u, '');
-        return key.split('/').some(p => p === '..' || p === '') || key.includes('\\') || key.includes(':') ? null : key;
+        return key.split('/').some((p) => p === '..' || p === '') || key.includes('\\') || key.includes(':') ? null : key;
     }
     catch {
         return null;
     }
 }
-function text(value) { return toMarkdown({ type: 'text', value }).trimEnd(); }
+function text(value) {
+    return toMarkdown({ type: 'text', value }).trimEnd();
+}
 /** Preserve original formatting/frontmatter; edit parsed destination spans, never regex Markdown. */
 export function localizeMarkdown(markdown, assets) {
     const frontmatter = /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/u.exec(markdown)?.[0];
@@ -18,7 +21,7 @@ export function localizeMarkdown(markdown, assets) {
         const body = localizeMarkdown(markdown.slice(frontmatter.length), assets);
         return { ...body, markdown: frontmatter + body.markdown };
     }
-    const tree = fromMarkdown(markdown), byPath = new Map(assets.map(a => [a.relativePath, a.sha256]));
+    const tree = fromMarkdown(markdown), byPath = new Map(assets.map((a) => [a.relativePath, a.sha256]));
     const definitions = new Map();
     const patches = [];
     let missingImages = false;
@@ -33,7 +36,7 @@ export function localizeMarkdown(markdown, assets) {
     function replace(node, value) {
         const start = node.position?.start.offset, end = node.position?.end.offset;
         if (start === undefined || end === undefined)
-            throw Error('integrity');
+            throw new SpongeError('integrity');
         patches.push({ start, end, value });
     }
     function walk(node) {
@@ -41,7 +44,12 @@ export function localizeMarkdown(markdown, assets) {
             const url = node.type === 'image' ? node.url : definitions.get(node.identifier)?.url;
             const key = url ? localKey(url) : null, sha = key ? byPath.get(key) : undefined;
             if (sha) {
-                const image = { type: 'image', url: assetPrefix + sha, alt: node.alt ?? '', title: node.type === 'image' ? node.title : definitions.get(node.identifier)?.title };
+                const image = {
+                    type: 'image',
+                    url: assetPrefix + sha,
+                    alt: node.alt ?? '',
+                    title: node.type === 'image' ? node.title : definitions.get(node.identifier)?.title,
+                };
                 replace(node, toMarkdown(image).trimEnd());
                 Object.assign(node, image);
             }
@@ -73,7 +81,11 @@ export function localizeMarkdown(markdown, assets) {
                 if (node.type === 'definition')
                     replace(node, '');
                 else {
-                    const plain = (n) => 'value' in n ? String(n.value) : 'children' in n ? n.children.map(c => plain(c)).join('') : '';
+                    const plain = (n) => 'value' in n
+                        ? String(n.value)
+                        : 'children' in n
+                            ? n.children.map((c) => plain(c)).join('')
+                            : '';
                     replace(node, text(plain(node)));
                 }
                 return;

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

@@ -1,7 +1,3 @@
-export declare class InputError extends Error {
-    readonly code = "invalid-input";
-    constructor();
-}
 /** The identity form of an http(s) locator; source keys and shareable URIs both use it. Its output pins every existing source key. */
 export declare function normalizeWebLocator(locator: string): string;
 export declare function articleSource(locator: string, realm?: string): {