@hraness/sponge 0.2.6 → 0.3.1

package/dist/src/digest/pipeline.js

@@ -1,37 +1,43 @@
-import { createHash } from 'node:crypto';
 import { foldText, locateAll, locateLoose, words } from '../annotations/quote.js';
-import { checkDigest, digestLimits as L, forms, parseDigest } from './schema.js';
-import { StoreError } from '../store/types.js';
+import { checkDigest, digestLimits as L, forms, parseDigest, } from './schema.js';
+import { SpongeError } from '../errors.js';
+import { sha256 } from '../util/hash.js';
 /**
  * Model-agnostic Digest v2 drafting. The model sees numbered passages and cites a passage id plus a short exact
  * span; code snaps, prunes and checks. Nothing leaves this module except through the injected model.
  */
-export const PROMPT_VERSION = 'sponge-digest-prompt-v2';
+export const PROMPT_VERSION = 'sponge-digest-prompt-v5';
 /** 24k characters is roughly 6k tokens of passages, leaving room for instructions and output in an 8k context on an 8 GB Mac. */
-export const defaultDigestParams = { temperature: 0, seed: 1, maxTokens: 2048, contextChars: 24000, maxSections: 24, timeoutMs: 300000, deadlineMs: 1800000, maxOutputBytes: 65536 };
-export class DigestError extends Error {
-    code;
-    issues;
-    constructor(code, issues) {
-        super(code);
-        this.code = code;
-        this.issues = issues;
-        this.name = 'DigestError';
-    }
-}
+const defaultDigestParams = {
+    temperature: 0,
+    seed: 1,
+    maxTokens: 2048,
+    contextChars: 24000,
+    maxSections: 24,
+    timeoutMs: 300000,
+    deadlineMs: 1800000,
+    maxOutputBytes: 65536,
+};
 /** Quotes under this many words carry no evidence; the checker is gaining the same floor. */
-export const minQuoteWords = 4;
-const sha256 = (v) => createHash('sha256').update(v).digest('hex');
+const minQuoteWords = 4;
 const collapse = (v) => v.replace(/\s+/g, ' ').trim();
 const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-/** Sorted-key JSON; the only serialization that enters input hashes. */
+/**
+ * Sorted-key JSON; the only serialization that enters input hashes. Deliberately not `util/canonical.ts`: this one
+ * accepts finite non-integer numbers (temperature) and writes `undefined` array entries as null, so merging would
+ * change digest input hashes.
+ */
 export function canonicalJson(value) {
     if (Array.isArray(value))
         return `[${value.map(canonicalJson).join(',')}]`;
     if (object(value))
-        return `{${Object.keys(value).filter(k => value[k] !== undefined).sort().map(k => `${JSON.stringify(k)}:${canonicalJson(value[k])}`).join(',')}}`;
+        return `{${Object.keys(value)
+            .filter((k) => value[k] !== undefined)
+            .sort()
+            .map((k) => `${JSON.stringify(k)}:${canonicalJson(value[k])}`)
+            .join(',')}}`;
     if (typeof value === 'number' && !Number.isFinite(value))
-        throw new DigestError('invalid-input');
+        throw new SpongeError('invalid-input');
     return JSON.stringify(value ?? null);
 }
 /** Paragraph-level passages with raw offsets. Headings label passages; code fences and image-only blocks are not quotable. */
@@ -85,8 +91,12 @@ export function passages(markdown, maxChars = 1200) {
     }
     return out;
 }
-function lastSentenceEnd(window) { let best = -1; for (const m of window.matchAll(/[.!?]["')\]]*(?=\s)/g))
-    best = m.index + m[0].length; return best; }
+function lastSentenceEnd(window) {
+    let best = -1;
+    for (const m of window.matchAll(/[.!?]["')\]]*(?=\s)/g))
+        best = m.index + m[0].length;
+    return best;
+}
 const display = (p) => `[${p.id}] ${collapse(p.text)}`;
 /** Pack passages into sections of at most `budget` display characters, preferring heading boundaries past half a budget. */
 export function sectionsOf(list, budget) {
@@ -94,7 +104,8 @@ export function sectionsOf(list, budget) {
     let current = [], size = 0;
     for (const p of list) {
         const n = display(p).length + 1;
-        if (current.length && (size + n > budget || p.heading !== current[current.length - 1].heading && size > budget / 2)) {
+        if (current.length &&
+            (size + n > budget || (p.heading !== current[current.length - 1].heading && size > budget / 2))) {
             out.push(current);
             current = [];
             size = 0;
@@ -107,28 +118,95 @@ export function sectionsOf(list, budget) {
     return out;
 }
 const sourceWords = (markdown) => words(markdown);
-export const quoteBudget = (markdown) => Math.min(L.totalQuoteWords, Math.max(L.quoteWords, Math.floor(sourceWords(markdown) * L.sourceQuoteShare)));
+const quoteBudget = (markdown) => Math.min(L.totalQuoteWords, Math.max(L.quoteWords, Math.floor(sourceWords(markdown) * L.sourceQuoteShare)));
 const str = (maxLength) => ({ type: 'string', minLength: 1, maxLength });
 /** JSON Schema for the model's draft. Tags become an enum when a vocabulary is given. */
 export function draftSchema(passageCount, vocabulary) {
-    const quote = { type: 'object', additionalProperties: false, required: ['passage', 'text'], properties: { passage: { type: 'integer', minimum: 1, maximum: Math.max(1, passageCount) }, text: str(300), attribution: str(200) } };
-    const idea = { type: 'object', additionalProperties: false, required: ['claim', 'detail', 'quotes'], properties: { claim: str(200), detail: str(600), quotes: { type: 'array', minItems: 0, maxItems: L.maxQuotesPerIdea, items: quote } } };
-    const tag = vocabulary?.length ? { type: 'string', enum: [...vocabulary] } : { type: 'string', pattern: '^[a-z0-9][a-z0-9-]{0,63}$' };
-    return { type: 'object', additionalProperties: false, required: ['lead', 'ideas', 'tags'], properties: { lead: str(L.leadChars), context: str(600), ideas: { type: 'array', minItems: L.minIdeas, maxItems: L.maxIdeas, items: idea }, tags: { type: 'array', minItems: 0, maxItems: L.maxTags, items: tag } } };
+    const quote = {
+        type: 'object',
+        additionalProperties: false,
+        required: ['passage', 'text'],
+        properties: {
+            passage: { type: 'integer', minimum: 1, maximum: Math.max(1, passageCount) },
+            text: str(300),
+            attribution: str(200),
+        },
+    };
+    const idea = {
+        type: 'object',
+        additionalProperties: false,
+        required: ['claim', 'detail', 'quotes'],
+        properties: {
+            claim: str(200),
+            detail: str(600),
+            quotes: { type: 'array', minItems: 0, maxItems: L.maxQuotesPerIdea, items: quote },
+        },
+    };
+    const tag = vocabulary?.length
+        ? { type: 'string', enum: [...vocabulary] }
+        : { type: 'string', pattern: '^[a-z0-9][a-z0-9-]{0,63}$' };
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['lead', 'context', 'ideas', 'tags'],
+        properties: {
+            lead: str(L.leadChars),
+            context: str(600),
+            ideas: { type: 'array', minItems: L.minIdeas, maxItems: L.maxIdeas, items: idea },
+            tags: { type: 'array', minItems: 0, maxItems: L.maxTags, items: tag },
+        },
+    };
 }
-export function notesSchema(first, last) {
-    return { type: 'object', additionalProperties: false, required: ['notes'], properties: { notes: { type: 'array', minItems: 1, maxItems: 4, items: { type: 'object', additionalProperties: false, required: ['point', 'passage', 'quote'], properties: { point: str(300), passage: { type: 'integer', minimum: first, maximum: last }, quote: str(300) } } } } };
+function notesSchema(first, last) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        required: ['notes'],
+        properties: {
+            notes: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 4,
+                items: {
+                    type: 'object',
+                    additionalProperties: false,
+                    required: ['point', 'passage', 'quote'],
+                    properties: { point: str(300), passage: { type: 'integer', minimum: first, maximum: last }, quote: str(300) },
+                },
+            },
+        },
+    };
 }
-const system = (budget, vocabulary) => `You write a Digest v2 of one source for a private reading library. Reply with JSON only, matching the schema.
-- lead: one sentence of at most ${L.leadChars} characters that names the author or organization when known and states the main finding.
-- context: optional, at most ${L.contextWords} words of essential background. Lead and context together stay within ${L.gistWords} words and ${L.gistSentences} sentences.
-- ideas: ${L.minIdeas} to ${L.maxIdeas}, in the order the author makes them. Each idea is a bold one-sentence claim with detail:
-  - claim: one sentence of at most ${L.claimWords} words that asserts something; never a topic label.
-  - detail: at most ${L.detailWords} words in at most ${L.detailSentences} sentences: evidence, mechanism or limits.
-  - quotes: 0 to ${L.maxQuotesPerIdea} that support this idea, each copied character for character from one numbered passage, ${minQuoteWords} to ${L.quoteWords} words, with that passage number. No added quotation marks or ellipses. Give attribution (who said it) when it is not the author. Prefer reader highlights.
-- Attach at least ${L.minQuotes} and at most ${L.maxQuotes} quotes in all. All quotes together stay within ${budget} words and never overlap.
-- tags: 0 to ${L.maxTags} ${vocabulary?.length ? `from: ${vocabulary.join(', ')}` : 'lowercase kebab-case topics'}.
-Use only what the source says.`;
+/**
+ * Style examples are invented sources shaped like reviewed digests (short verdict claims, dense details); no library
+ * text. They show voice only: the model must still draw every claim and number from the source it is given.
+ */
+const styleExamples = `Style examples (invented sources; copy the voice, never the content):
+Source: a database company's post on moving its write path to object storage.
+  lead: Acme moves Ledger's write path onto an append-only log in S3 and cuts p99 commit latency from 40 ms to 9 ms.
+  context: Postgres becomes a read replica rebuilt from the log. Batching makes object storage affordable; single-row workloads still get slower.
+  claim: The log is the database. | detail: Every write appends one immutable segment; Postgres is rebuilt from the log and serves reads only.
+  claim: Batching pays for the bucket. | detail: Commits wait up to 5 ms, so one PUT carries about 300 writes and request cost falls 40-fold.
+  claim: Small writers lose. | detail: Under ten writes per second, latency is higher than before the move.
+Source: an essay arguing that taste is a skill.
+  lead: Mara Lind argues taste is trained by making and comparing many small things, not inherited, and that teams can schedule it.
+  claim: Taste is trained. | detail: Lind's students improved most after drawing fifty quick versions, not after studying masters.
+  claim: Volume beats polish early. | detail: Side-by-side comparison of many rough drafts sharpens judgment faster than finishing one.
+Bad claim: The essay explores how practice over time shapes a person's sense of taste.
+Good claim: Taste is trained.`;
+const system = (budget, vocabulary) => `You write a Digest v2 of one source for a private reading library, in the owner's voice: terse, declarative, specific. Reply with JSON only, matching the schema.
+- lead: one sentence of at most ${L.leadChars} characters stating this source's specific thesis or result: who (author, organization or product by name) shows or argues what, with the number, name or mechanism that makes it this source. Do not restate the title, describe the source ("This article discusses"), or tease.
+- context: 1 or 2 sentences, at most 45 words: the evidence, method, numbers or limits the lead could not hold. Lead and context together stay within ${L.gistWords} words and ${L.gistSentences} sentences.
+- ideas: ${L.minIdeas} to ${L.maxIdeas} (prefer ${L.maxIdeas} when the source has them), in the order the author makes them, covering the whole source including its caveats and limits. Each idea is a claim with detail:
+  - claim: a verdict of 4 to 8 words (never more than 12): subject, verb, point, naming this source's own subject ("Batching pays for the bucket", not "Costs drop"). Something a reader could disagree with; never a topic label or a description of the source.
+  - detail: one or two sentences, 15 to 30 words, dense with the source's own names, numbers, mechanism or limits behind the claim. Do not repeat the claim.
+  - quotes: 0 to ${L.maxQuotesPerIdea} that support this idea, each a contiguous span copied character for character from one numbered passage, ${minQuoteWords + 2} to 20 words, with that passage number. A quote is a fragment, not a whole long sentence: when a sentence runs past 20 words, copy only its strongest part. No added quotation marks or ellipses. Give attribution (who said it) when it is not the author. Prefer reader highlights.
+- Attach at least ${L.minQuotes} and at most ${L.maxQuotes} quotes in all; ${L.minQuotes + 1} to 3 is typical. All quotes together stay within ${budget} words and never overlap.
+- tags: 0 to ${L.maxTags} ${vocabulary?.length ? `from: ${vocabulary.join(', ')}` : 'lowercase kebab-case topics'}; usually one subject tag.
+Plain words. Name things and use numbers. No hedges or filler: may, might, potentially, various, significantly, key, crucial, notably, highlights, explores, discusses, "the author argues", "the article".
+Use only what the source says.
+
+${styleExamples}`;
 function sourceBlock(title, form, list, highlights) {
     let heading;
     const lines = [];
@@ -143,10 +221,26 @@ function sourceBlock(title, form, list, highlights) {
     const marks = highlights.map((h, i) => `[h${i + 1}${h.passage ? `, passage ${h.passage}` : ''}] ${collapse(h.text).slice(0, 400)}`);
     return `Form: ${form}${title ? `\nTitle: ${collapse(title).slice(0, 300)}` : ''}${marks.length ? `\n\nReader highlights (preferred quotes):\n${marks.join('\n')}` : ''}\n\nPassages:\n${lines.join('\n')}`;
 }
-const rule = { gist: `lead and context within ${L.gistWords} words and ${L.gistSentences} sentences`, lead: `one sentence, at most ${L.leadChars} characters`, context: `at most ${L.contextWords} words`, claim: `one distinct sentence, at most ${L.claimWords} words`, detail: `at most ${L.detailWords} words and ${L.detailSentences} sentences`, quotes: `0-${L.maxQuotesPerIdea} quotes per idea, each copied exactly from its passage, ${minQuoteWords} to ${L.quoteWords} words, not overlapping another quote`, attribution: `at most ${L.attributionWords} words`, ideas: `${L.minIdeas}-${L.maxIdeas} ideas; ${L.minQuotes}-${L.maxQuotes} quotes in all, within the total budget`, tags: `0-${L.maxTags} distinct allowed tags` };
+const rule = {
+    gist: `lead and context within ${L.gistWords} words and ${L.gistSentences} sentences`,
+    lead: `one sentence, at most ${L.leadChars} characters`,
+    context: `at most ${L.contextWords} words`,
+    claim: `one distinct sentence, at most ${L.claimWords} words`,
+    detail: `at most ${L.detailWords} words and ${L.detailSentences} sentences`,
+    quotes: `0-${L.maxQuotesPerIdea} quotes per idea, each copied exactly from its passage, ${minQuoteWords} to ${L.quoteWords} words, not overlapping another quote`,
+    attribution: `at most ${L.attributionWords} words`,
+    ideas: `${L.minIdeas}-${L.maxIdeas} ideas; ${L.minQuotes}-${L.maxQuotes} quotes in all, within the total budget`,
+    tags: `0-${L.maxTags} distinct allowed tags`,
+};
 function repairPrompt(issues) {
-    const lines = issues.slice(0, 40).map(i => { const last = i.path.split('.').filter(s => !/^\d+$/.test(s)).pop() ?? ''; return `- ${i.path || 'output'}: ${i.code}${rule[last] ? ` (rule: ${rule[last]})` : ''}`; });
-    return `That draft broke these rules:\n${lines.join('\n')}\nReturn the complete corrected JSON. Copy quotes exactly from the numbered passages.`;
+    const lines = issues.slice(0, 40).map((i) => {
+        const last = i.path
+            .split('.')
+            .filter((s) => !/^\d+$/.test(s))
+            .pop() ?? '';
+        return `- ${i.path || 'output'}: ${i.code}${rule[last] ? ` (rule: ${rule[last]})` : ''}`;
+    });
+    return `That draft broke these rules:\n${lines.join('\n')}\nReturn the complete corrected JSON. Copy quotes exactly from the numbered passages; shorten a too-long quote to its strongest contiguous 6 to 20 words.`;
 }
 /** Map the model's draft shape into Digest v2; parseDigest then decides whether the shape is valid. Ideas keep the model's order. */
 function fromModel(text, form) {
@@ -159,18 +253,31 @@ function fromModel(text, form) {
     }
     if (!object(v) || !Array.isArray(v.ideas) || !Array.isArray(v.tags))
         return { issues: [{ path: '', code: 'shape' }] };
-    const trim = (s) => typeof s === 'string' ? s.trim() : s, cites = [];
+    const trim = (s) => (typeof s === 'string' ? s.trim() : s), cites = [];
     const ideas = v.ideas.map((idea) => {
         if (!object(idea)) {
             cites.push([]);
             return idea;
         }
         const quotes = Array.isArray(idea.quotes) ? idea.quotes : [];
-        cites.push(quotes.map((q) => Number.isSafeInteger(q?.passage) ? q.passage : undefined));
-        return { claim: trim(idea.claim), detail: trim(idea.detail), quotes: quotes.map((q) => { const attribution = trim(q?.attribution); return { text: trim(q?.text), ...(attribution ? { attribution } : {}) }; }) };
+        cites.push(quotes.map((q) => (Number.isSafeInteger(q?.passage) ? q.passage : undefined)));
+        return {
+            claim: trim(idea.claim),
+            detail: trim(idea.detail),
+            quotes: quotes.map((q) => {
+                const attribution = trim(q?.attribution);
+                return { text: trim(q?.text), ...(attribution ? { attribution } : {}) };
+            }),
+        };
     });
     const context = trim(v.context);
-    const parsed = parseDigest({ schemaVersion: 2, form, gist: { lead: trim(v.lead), ...(context ? { context } : {}) }, ideas, tags: v.tags.map(trim) });
+    const parsed = parseDigest({
+        schemaVersion: 2,
+        form,
+        gist: { lead: trim(v.lead), ...(context ? { context } : {}) },
+        ideas,
+        tags: v.tags.map(trim),
+    });
     return parsed.digest?.schemaVersion === 2 ? { digest: parsed.digest, cites } : { issues: parsed.issues };
 }
 /**
@@ -181,7 +288,10 @@ export function snapQuote(source, text, within) {
     if (source.includes(text))
         return { text, match: 'exact' };
     const inside = (m) => !!within && m.start >= within.start && m.end <= within.end;
-    const pick = (all) => { const local = all.filter(inside); return local.length === 1 ? local[0] : all.length === 1 ? all[0] : undefined; };
+    const pick = (all) => {
+        const local = all.filter(inside);
+        return local.length === 1 ? local[0] : all.length === 1 ? all[0] : undefined;
+    };
     const folded = locateAll(source, text);
     if (folded.length) {
         const m = pick(folded);
@@ -198,13 +308,39 @@ export function snapQuote(source, text, within) {
         end++;
     return { text: source.slice(start, end), match: 'snapped' };
 }
-/** Snap every quote in place and drop quotes under `minQuoteWords`. */
-export function snapQuotes(draft, source, list) {
-    const stats = { exact: 0, folded: 0, snapped: 0, missing: 0, short: 0 }, byId = new Map(list.map(p => [p.id, p]));
+/**
+ * A located quote over the word limit keeps its leading words: a prefix of a source span is still verbatim. Trailing
+ * clause punctuation goes; unlocated quotes are left for the checker.
+ */
+export function trimQuote(text, max = L.quoteWords) {
+    if (words(text) <= max)
+        return text;
+    const ends = [...text.matchAll(/\S+/g)].map((m) => m.index + m[0].length);
+    let n = Math.min(max, ends.length), out = text;
+    do {
+        out = text.slice(0, ends[n - 1]).replace(/[\s,;:(\[\u2014\u2013-]+$/, '');
+        n--;
+    } while (n > 0 && words(out) > max);
+    return out;
+}
+/** Snap every quote in place, trim located quotes over the word limit, and drop quotes under `minQuoteWords`. */
+function snapQuotes(draft, source, list) {
+    const stats = { exact: 0, folded: 0, snapped: 0, missing: 0, short: 0, trimmed: 0 }, byId = new Map(list.map((p) => [p.id, p]));
     draft.digest.ideas.forEach((idea, i) => {
-        idea.quotes.forEach((q, j) => { const r = snapQuote(source, q.text, byId.get(draft.cites[i]?.[j] ?? 0)); q.text = r.text; stats[r.match]++; });
-        const keep = idea.quotes.map(q => words(q.text) >= minQuoteWords);
-        stats.short += keep.filter(k => !k).length;
+        idea.quotes.forEach((q, j) => {
+            const r = snapQuote(source, q.text, byId.get(draft.cites[i]?.[j] ?? 0));
+            q.text = r.text;
+            stats[r.match]++;
+            if (r.match !== 'missing') {
+                const t = trimQuote(q.text);
+                if (t !== q.text) {
+                    q.text = t;
+                    stats.trimmed++;
+                }
+            }
+        });
+        const keep = idea.quotes.map((q) => words(q.text) >= minQuoteWords);
+        stats.short += keep.filter((k) => !k).length;
         idea.quotes = idea.quotes.filter((_, j) => keep[j]);
         draft.cites[i] = (draft.cites[i] ?? []).filter((_, j) => keep[j]);
     });
@@ -216,11 +352,28 @@ const pruneable = new Set(['not-verbatim', 'overlap', 'unsupported', 'too-long',
  * budget (second quotes first, longest first), never the last quote. Quoteless ideas stay: v2 allows them.
  */
 function prune(draft, issues, source, options) {
-    const dropped = { quotes: 0, ideas: 0, tags: 0 }, d = draft.digest, bad = new Set(issues.filter(i => /^ideas\.\d+\.quotes\.\d+(?:\.attribution)?$/.test(i.path) && pruneable.has(i.code)).map(i => i.path.replace(/\.attribution$/, '')));
-    d.ideas.forEach((idea, i) => { const keep = idea.quotes.map((_, j) => !bad.has(`ideas.${i}.quotes.${j}`)).map((k, j) => k && j < L.maxQuotesPerIdea); dropped.quotes += keep.filter(k => !k).length; idea.quotes = idea.quotes.filter((_, j) => keep[j]); draft.cites[i] = (draft.cites[i] ?? []).filter((_, j) => keep[j]); });
+    const dropped = { quotes: 0, ideas: 0, tags: 0 }, d = draft.digest;
+    // Context is optional in Digest v2: an over-long gist loses its context rather than the draft.
+    if (d.gist.context !== undefined && issues.some((i) => i.path === 'gist' || i.path === 'gist.context'))
+        delete d.gist.context;
+    const bad = new Set(issues
+        .filter((i) => /^ideas\.\d+\.quotes\.\d+(?:\.attribution)?$/.test(i.path) && pruneable.has(i.code))
+        .map((i) => i.path.replace(/\.attribution$/, '')));
+    d.ideas.forEach((idea, i) => {
+        const keep = idea.quotes
+            .map((_, j) => !bad.has(`ideas.${i}.quotes.${j}`))
+            .map((k, j) => k && j < L.maxQuotesPerIdea);
+        dropped.quotes += keep.filter((k) => !k).length;
+        idea.quotes = idea.quotes.filter((_, j) => keep[j]);
+        draft.cites[i] = (draft.cites[i] ?? []).filter((_, j) => keep[j]);
+    });
     const seen = new Set();
-    const keepIdea = d.ideas.map(idea => { const key = foldText(idea.claim).toLowerCase(), ok = !seen.has(key); seen.add(key); return ok; });
-    dropped.ideas = keepIdea.filter(k => !k).length;
+    const keepIdea = d.ideas.map((idea) => {
+        const key = foldText(idea.claim).toLowerCase(), ok = !seen.has(key);
+        seen.add(key);
+        return ok;
+    });
+    dropped.ideas = keepIdea.filter((k) => !k).length;
     d.ideas = d.ideas.filter((_, i) => keepIdea[i]);
     draft.cites = draft.cites.filter((_, i) => keepIdea[i]);
     if (d.ideas.length > L.maxIdeas) {
@@ -228,7 +381,9 @@ function prune(draft, issues, source, options) {
         d.ideas = d.ideas.slice(0, L.maxIdeas);
         draft.cites = draft.cites.slice(0, L.maxIdeas);
     }
-    const tags = [...new Set(d.tags)].filter(t => options.tags ? options.tags.includes(t) : /^[a-z0-9][a-z0-9-]{0,63}$/.test(t)).slice(0, L.maxTags);
+    const tags = [...new Set(d.tags)]
+        .filter((t) => (options.tags ? options.tags.includes(t) : /^[a-z0-9][a-z0-9-]{0,63}$/.test(t)))
+        .slice(0, L.maxTags);
     dropped.tags = d.tags.length - tags.length;
     d.tags = tags;
     const budget = quoteBudget(source), all = () => d.ideas.flatMap((idea, i) => idea.quotes.map((q, j) => ({ i, j, n: words(q.text) })));
@@ -240,76 +395,132 @@ function prune(draft, issues, source, options) {
     }
     return dropped;
 }
-const hashedParams = (p) => ({ temperature: p.temperature, seed: p.seed, maxTokens: p.maxTokens, contextChars: p.contextChars, maxSections: p.maxSections });
+const hashedParams = (p) => ({
+    temperature: p.temperature,
+    seed: p.seed,
+    maxTokens: p.maxTokens,
+    contextChars: p.contextChars,
+    maxSections: p.maxSections,
+});
 function resolveParams(params = {}) {
     const p = { ...defaultDigestParams, ...params }, int = (v, min, max) => Number.isSafeInteger(v) && v >= min && v <= max;
-    if (!(p.temperature >= 0 && p.temperature <= 2) || !int(p.seed, 0, 2 ** 31) || !int(p.maxTokens, 256, 32768) || !int(p.contextChars, 2000, 1_000_000) || !int(p.maxSections, 1, 256) || !int(p.timeoutMs, 1, 3_600_000) || !int(p.deadlineMs, 1, 14_400_000) || !int(p.maxOutputBytes, 1024, 4 * 1024 * 1024))
-        throw new DigestError('invalid-input');
+    if (!(p.temperature >= 0 && p.temperature <= 2) ||
+        !int(p.seed, 0, 2 ** 31) ||
+        !int(p.maxTokens, 256, 32768) ||
+        !int(p.contextChars, 2000, 1_000_000) ||
+        !int(p.maxSections, 1, 256) ||
+        !int(p.timeoutMs, 1, 3_600_000) ||
+        !int(p.deadlineMs, 1, 14_400_000) ||
+        !int(p.maxOutputBytes, 1024, 4 * 1024 * 1024))
+        throw new SpongeError('invalid-input');
     return p;
 }
 function validIdentity(id) {
     const ok = (v) => typeof v === 'string' && v.length > 0 && v.length <= 256 && !/[\u0000-\u001f\u007f]/.test(v);
     if (!object(id) || !ok(id.model) || !ok(id.quantization) || !ok(id.runtime))
-        throw new DigestError('invalid-input');
+        throw new SpongeError('invalid-input');
     return { model: id.model, quantization: id.quantization, runtime: id.runtime };
 }
 /** sha256 over canonical JSON of the revision, its Markdown, the prompt version, the model identity and every output-shaping input. */
 export function digestInputHash(input) {
-    return sha256(canonicalJson({ revisionId: input.revisionId, markdownSha256: sha256(input.markdown), promptVersion: PROMPT_VERSION, model: validIdentity(input.model), params: { ...hashedParams(resolveParams(input.params)), form: input.form, vocabulary: input.vocabulary ? [...input.vocabulary] : null, highlights: (input.highlights ?? []).map(h => h.text), support: input.embed ? input.supportThreshold ?? defaultSupportThreshold : null } }));
+    return sha256(canonicalJson({
+        revisionId: input.revisionId,
+        markdownSha256: sha256(input.markdown),
+        promptVersion: PROMPT_VERSION,
+        model: validIdentity(input.model),
+        params: {
+            ...hashedParams(resolveParams(input.params)),
+            form: input.form,
+            vocabulary: input.vocabulary ? [...input.vocabulary] : null,
+            highlights: (input.highlights ?? []).map((h) => h.text),
+            support: input.embed ? (input.supportThreshold ?? defaultSupportThreshold) : null,
+        },
+    }));
 }
 /** Unqualified on real claims: a deliberately low bar that only catches quotes unrelated to their claim. */
-export const defaultSupportThreshold = 0.35;
+const defaultSupportThreshold = 0.35;
 export async function draftDigest(input) {
     const p = resolveParams(input.params), identity = validIdentity(input.model.identity);
     if (typeof input.markdown !== 'string' || !input.markdown.trim() || !forms.includes(input.form))
-        throw new DigestError('invalid-input');
-    if (input.vocabulary && (!input.vocabulary.length || input.vocabulary.length > 256 || input.vocabulary.some(t => !/^[a-z0-9][a-z0-9-]{0,63}$/.test(t))))
-        throw new DigestError('invalid-input');
+        throw new SpongeError('invalid-input');
+    if (input.vocabulary &&
+        (!input.vocabulary.length ||
+            input.vocabulary.length > 256 ||
+            input.vocabulary.some((t) => !/^[a-z0-9][a-z0-9-]{0,63}$/.test(t))))
+        throw new SpongeError('invalid-input');
     const inputHash = digestInputHash({ ...input, model: identity }), source = input.markdown, list = passages(source);
     if (list.length === 0)
-        throw new DigestError('invalid-input');
+        throw new SpongeError('invalid-input');
     const userSignal = input.signal ?? new AbortController().signal, overall = AbortSignal.any([userSignal, AbortSignal.timeout(p.deadlineMs)]);
-    const trace = { strategy: 'single', sections: 1, calls: 0, repaired: false, attempts: [], dropped: { quotes: 0, ideas: 0, tags: 0 } };
+    const trace = {
+        strategy: 'single',
+        sections: 1,
+        calls: 0,
+        repaired: false,
+        attempts: [],
+        dropped: { quotes: 0, ideas: 0, tags: 0 },
+    };
     const call = async (messages, schema) => {
         if (userSignal.aborted)
-            throw new DigestError('cancelled');
+            throw new SpongeError('cancelled');
         if (overall.aborted)
-            throw new DigestError('limit-exceeded');
+            throw new SpongeError('limit-exceeded');
         const signal = AbortSignal.any([overall, AbortSignal.timeout(p.timeoutMs)]);
         trace.calls++;
         let text;
         try {
-            text = await input.model.generate(messages, schema, { signal, maxOutputBytes: p.maxOutputBytes, maxTokens: p.maxTokens, temperature: p.temperature, seed: p.seed });
+            text = await input.model.generate(messages, schema, {
+                signal,
+                maxOutputBytes: p.maxOutputBytes,
+                maxTokens: p.maxTokens,
+                temperature: p.temperature,
+                seed: p.seed,
+            });
         }
         catch (error) {
             if (userSignal.aborted)
-                throw new DigestError('cancelled');
+                throw new SpongeError('cancelled');
             if (signal.aborted)
-                throw new DigestError('limit-exceeded');
-            if (error instanceof DigestError)
+                throw new SpongeError('limit-exceeded');
+            if (error instanceof SpongeError)
                 throw error;
-            throw new DigestError('unavailable');
+            throw new SpongeError('unavailable');
         }
         if (userSignal.aborted)
-            throw new DigestError('cancelled');
+            throw new SpongeError('cancelled');
         if (typeof text !== 'string' || Buffer.byteLength(text) > p.maxOutputBytes)
-            throw new DigestError('limit-exceeded');
+            throw new SpongeError('limit-exceeded');
         return text;
     };
-    const highlights = (input.highlights ?? []).filter(h => typeof h?.text === 'string' && h.text.trim()).slice(0, 32).map(h => { const at = h.start ?? locateAll(source, h.text)[0]?.start; return { text: h.text, passage: at === undefined ? undefined : list.find(x => at >= x.start && at < x.end)?.id }; });
+    const highlights = (input.highlights ?? [])
+        .filter((h) => typeof h?.text === 'string' && h.text.trim())
+        .slice(0, 32)
+        .map((h) => {
+        const at = h.start ?? locateAll(source, h.text)[0]?.start;
+        return {
+            text: h.text,
+            passage: at === undefined ? undefined : list.find((x) => at >= x.start && at < x.end)?.id,
+        };
+    });
     let shown = list, notesText;
     const total = list.reduce((n, x) => n + display(x).length + 1, 0);
     if (total > p.contextChars) {
         // Long source: notes per section, then one combined pass over the cited and highlighted passages only.
         const sections = sectionsOf(list, p.contextChars);
         if (sections.length > p.maxSections)
-            throw new DigestError('limit-exceeded');
+            throw new SpongeError('limit-exceeded');
         trace.strategy = 'sections';
         trace.sections = sections.length;
         const notes = [];
         for (const [k, section] of sections.entries()) {
             const first = section[0].id, last = section[section.length - 1].id;
-            const text = await call([{ role: 'system', content: `You take notes on part ${k + 1} of ${sections.length} of a longer source. Reply with JSON only. Give 1 to 4 notes, each a point of at most 25 words that the section asserts, with one passage number from this part and a short quote copied exactly from that passage.` }, { role: 'user', content: sourceBlock(input.title, input.form, section, []) }], notesSchema(first, last));
+            const text = await call([
+                {
+                    role: 'system',
+                    content: `You take notes on part ${k + 1} of ${sections.length} of a longer source. Reply with JSON only. Give 1 to 4 notes, each a point of at most 25 words that the section asserts, with one passage number from this part and a short quote copied exactly from that passage.`,
+                },
+                { role: 'user', content: sourceBlock(input.title, input.form, section, []) },
+            ], notesSchema(first, last));
             let v;
             try {
                 v = JSON.parse(text);
@@ -319,11 +530,23 @@ export async function draftDigest(input) {
             }
             if (object(v) && Array.isArray(v.notes))
                 for (const n of v.notes.slice(0, 4))
-                    if (object(n) && typeof n.point === 'string' && Number.isSafeInteger(n.passage) && n.passage >= first && n.passage <= last && typeof n.quote === 'string')
-                        notes.push({ point: collapse(n.point).slice(0, 300), passage: n.passage, quote: collapse(n.quote).slice(0, 300) });
+                    if (object(n) &&
+                        typeof n.point === 'string' &&
+                        Number.isSafeInteger(n.passage) &&
+                        n.passage >= first &&
+                        n.passage <= last &&
+                        typeof n.quote === 'string')
+                        notes.push({
+                            point: collapse(n.point).slice(0, 300),
+                            passage: n.passage,
+                            quote: collapse(n.quote).slice(0, 300),
+                        });
         }
-        const wanted = new Set([...notes.map(n => n.passage), ...highlights.flatMap(h => h.passage ? [h.passage] : [])]);
-        notesText = notes.map(n => `- [${n.passage}] ${n.point}`).join('\n');
+        const wanted = new Set([
+            ...notes.map((n) => n.passage),
+            ...highlights.flatMap((h) => (h.passage ? [h.passage] : [])),
+        ]);
+        notesText = notes.map((n) => `- [${n.passage}] ${n.point}`).join('\n');
         shown = [];
         let size = notesText.length;
         for (const x of list)
@@ -332,21 +555,36 @@ export async function draftDigest(input) {
                 size += display(x).length + 1;
             }
         if (!shown.length)
-            throw new DigestError('unavailable', [{ path: '', code: 'no-notes' }]);
+            throw new SpongeError('unavailable', { issues: [{ path: '', code: 'no-notes' }] });
     }
     const budget = quoteBudget(source), schema = draftSchema(list.length, input.vocabulary);
-    const messages = [{ role: 'system', content: system(budget, input.vocabulary) }, { role: 'user', content: (notesText ? `Notes from each part of the source, in order:\n${notesText}\n\n` : '') + sourceBlock(input.title, input.form, shown, highlights) }];
+    const messages = [
+        { role: 'system', content: system(budget, input.vocabulary) },
+        {
+            role: 'user',
+            content: (notesText ? `Notes from each part of the source, in order:\n${notesText}\n\n` : '') +
+                sourceBlock(input.title, input.form, shown, highlights),
+        },
+    ];
     const cache = new Map(), options = { ...(input.vocabulary ? { tags: input.vocabulary } : {}) };
     const embedKey = (t) => Buffer.from(foldText(t)).subarray(0, 900).toString();
     if (input.embed)
-        Object.assign(options, { supportThreshold: input.supportThreshold ?? defaultSupportThreshold, supports: (claim, quote) => { const a = cache.get(embedKey(claim)), b = cache.get(embedKey(quote)); return a && b ? a.reduce((n, x, i) => n + x * b[i], 0) : 0; } });
+        Object.assign(options, {
+            supportThreshold: input.supportThreshold ?? defaultSupportThreshold,
+            supports: (claim, quote) => {
+                const a = cache.get(embedKey(claim)), b = cache.get(embedKey(quote));
+                return a && b ? a.reduce((n, x, i) => n + x * b[i], 0) : 0;
+            },
+        });
     const check = async (draft) => {
         if (input.embed) {
-            const missing = [...new Set(draft.digest.ideas.flatMap(i => [i.claim, ...i.quotes.map(q => q.text)]).map(embedKey))].filter(t => !cache.has(t));
+            const missing = [
+                ...new Set(draft.digest.ideas.flatMap((i) => [i.claim, ...i.quotes.map((q) => q.text)]).map(embedKey)),
+            ].filter((t) => !cache.has(t));
             if (missing.length) {
                 const vectors = await input.embed(missing, overall);
                 if (!Array.isArray(vectors) || vectors.length !== missing.length)
-                    throw new DigestError('unavailable');
+                    throw new SpongeError('unavailable');
                 missing.forEach((t, i) => cache.set(t, vectors[i]));
             }
         }
@@ -370,30 +608,59 @@ export async function draftDigest(input) {
         result = await attempt(await call([...messages, { role: 'assistant', content: first }, { role: 'user', content: repairPrompt(result.issues) }], schema));
     }
     if (!result.draft)
-        throw new DigestError('unavailable', result.issues);
+        throw new SpongeError('unavailable', { issues: result.issues });
     let issues = result.issues;
     if (issues.length) {
         trace.dropped = prune(result.draft, issues, source, options);
         issues = await check(result.draft);
         if (result.draft.digest.ideas.length < L.minIdeas)
-            issues = [...issues.filter(i => !(i.path === 'ideas' && i.code === 'count')), { path: 'ideas', code: 'count' }];
+            issues = [...issues.filter((i) => !(i.path === 'ideas' && i.code === 'count')), { path: 'ideas', code: 'count' }];
         if (issues.length)
-            throw new DigestError('unavailable', issues);
+            throw new SpongeError('unavailable', { issues });
     }
-    const producer = { pipeline: 'sponge-digest', promptVersion: PROMPT_VERSION, model: identity, params: hashedParams(p), strategy: trace.strategy, sections: trace.sections, calls: trace.calls, repaired: trace.repaired, dropped: trace.dropped, ...(input.embed ? { supportThreshold: options.supportThreshold } : {}) };
+    const producer = {
+        pipeline: 'sponge-digest',
+        promptVersion: PROMPT_VERSION,
+        model: identity,
+        params: hashedParams(p),
+        strategy: trace.strategy,
+        sections: trace.sections,
+        calls: trace.calls,
+        repaired: trace.repaired,
+        dropped: trace.dropped,
+        ...(input.embed ? { supportThreshold: options.supportThreshold } : {}),
+    };
     return { output: result.draft.digest, inputHash, producer, options, trace };
 }
-const formFor = (kind) => kind === 'pdf' ? 'pdf' : kind === 'media' ? 'video' : 'article';
+const formFor = (kind) => (kind === 'pdf' ? 'pdf' : kind === 'media' ? 'video' : 'article');
 /** Draft and store a digest for the item's current revision. A matching input hash returns the stored draft without calling the model. */
 export async function createDigest(store, itemId, model, options = {}) {
     const item = store.read(itemId);
     if (!item)
-        throw new StoreError('unavailable');
-    const highlights = store.listAnnotations(itemId).filter(a => a.kind === 'highlight' && a.revisionId === item.revisionId && a.anchored !== false).map(a => ({ text: a.anchor.exact, start: a.anchor.start }));
-    const input = { ...options, revisionId: item.revisionId, markdown: item.markdown, title: item.title, form: formFor(item.kind), model, highlights };
-    const prior = store.findDigest(item.revisionId, digestInputHash({ ...input, model: model.identity }));
+        throw new SpongeError('unavailable');
+    const highlights = store.annotations
+        .list(itemId)
+        .filter((a) => a.kind === 'highlight' && a.revisionId === item.revisionId && a.anchored !== false)
+        .map((a) => ({ text: a.anchor.exact, start: a.anchor.start }));
+    const input = {
+        ...options,
+        revisionId: item.revisionId,
+        markdown: item.markdown,
+        title: item.title,
+        form: formFor(item.kind),
+        model,
+        highlights,
+    };
+    const prior = store.derivations.find('digest', item.revisionId, digestInputHash({ ...input, model: model.identity }));
     if (prior)
         return { derivation: prior, duplicate: true };
-    const draft = await draftDigest(input), stored = store.putDigest({ itemId, revisionId: item.revisionId, producer: draft.producer, inputHash: draft.inputHash, output: draft.output, options: draft.options });
-    return { derivation: store.readDigest(stored.id), duplicate: stored.duplicate, trace: draft.trace };
+    const draft = await draftDigest(input), stored = store.derivations.put('digest', {
+        itemId,
+        revisionId: item.revisionId,
+        producer: draft.producer,
+        inputHash: draft.inputHash,
+        output: draft.output,
+        options: draft.options,
+    });
+    return { derivation: store.derivations.read('digest', stored.id), duplicate: stored.duplicate, trace: draft.trace };
 }