@hraness/sponge 0.2.5 → 0.2.6

package/dist/src/digest/store.js

@@ -1,19 +1,19 @@
-import { checkDigest, parseDigest } from './schema.js';
+import { checkDigest, digestSchemaVersion, parseDigest } from './schema.js';
 import { markdownFor } from '../annotations/store.js';
 import { mutate } from '../store/changes.js';
 import { StoreError } from '../store/types.js';
 import { digest, hash } from '../store/files.js';
 const now = () => new Date().toISOString();
 const fail = (code = 'invalid-input') => { throw new StoreError(code); };
-/** A parsed digest serialized in fixed key order, so key order never makes a different object. */
+/** A parsed digest serialized in fixed key order, so key order never makes a different object. Optional fields appear only when present. */
 export function canonicalDigest(d) {
-    return JSON.stringify({ schemaVersion: d.schemaVersion, form: d.form, gist: { lead: d.gist.lead, ...(d.gist.context !== undefined ? { context: d.gist.context } : {}) }, ideas: d.ideas.map(i => ({ claim: i.claim, detail: i.detail, kind: i.kind, voice: i.voice.type === 'author' ? { type: 'author' } : { type: i.voice.type, name: i.voice.name }, quotes: i.quotes.map(q => ({ text: q.text, ...(q.speaker !== undefined ? { speaker: q.speaker } : {}), ...(q.locator ? { locator: q.locator.type === 'timestamp' ? { type: 'timestamp', ms: q.locator.ms } : { type: 'page', page: q.locator.page } } : {}) })) })), tags: [...d.tags] });
+    return JSON.stringify({ schemaVersion: d.schemaVersion, form: d.form, gist: { lead: d.gist.lead, ...(d.gist.context !== undefined ? { context: d.gist.context } : {}) }, ideas: d.ideas.map(i => ({ claim: i.claim, detail: i.detail, ...(i.kind !== undefined ? { kind: i.kind } : {}), ...(i.voice ? { voice: i.voice.type === 'author' ? { type: 'author' } : { type: i.voice.type, name: i.voice.name } } : {}), quotes: i.quotes.map(q => ({ text: q.text, ...(q.speaker !== undefined ? { speaker: q.speaker } : {}), ...(q.attribution !== undefined ? { attribution: q.attribution } : {}), ...(q.locator ? { locator: q.locator.type === 'timestamp' ? { type: 'timestamp', ms: q.locator.ms } : { type: 'page', page: q.locator.page } } : {}) })) })), tags: [...d.tags] });
 }
 /** Content address of a derivation: the same output from the same input is the same immutable object on every device. */
 export const derivationId = (revisionId, kind, inputHash, output) => digest(JSON.stringify(['derivation-v1', revisionId, kind, inputHash, output]));
 /**
- * Store a draft digest only when every v1 rule passes against the revision it was made from.
- * Drafts are immutable data, not change-log entries; a different output is a new object.
+ * Store a draft digest only when it is Digest v2 and every v2 rule passes against the revision it was made from.
+ * Stored v1 digests stay readable; new ones are v2. Drafts are immutable data, not change-log entries; a different output is a new object.
  */
 export function putDigest(db, input) {
     hash(input.inputHash);
@@ -26,6 +26,8 @@ export function putDigest(db, input) {
     const parsed = parseDigest(input.output);
     if (!parsed.digest)
         throw Object.assign(new StoreError('invalid-input'), { issues: parsed.issues });
+    if (parsed.digest.schemaVersion !== digestSchemaVersion)
+        throw Object.assign(new StoreError('invalid-input'), { issues: [{ path: 'schemaVersion', code: 'superseded' }] });
     const check = checkDigest(parsed.digest, markdownFor(db, input.revisionId), input.options);
     if (!check.ok)
         throw Object.assign(new StoreError('invalid-input'), { issues: check.issues });
@@ -35,7 +37,7 @@ export function putDigest(db, input) {
     const id = derivationId(input.revisionId, 'digest', input.inputHash, output);
     if (db.prepare('SELECT 1 FROM derivations WHERE id=?').get(id))
         return { id, duplicate: true };
-    db.prepare("INSERT INTO derivations(id,item_id,revision_id,kind,schema_version,producer_json,input_hash,output_json,created_at) VALUES(?,?,?,'digest',1,?,?,?,?)").run(id, input.itemId, input.revisionId, producer, input.inputHash, output, now());
+    db.prepare("INSERT INTO derivations(id,item_id,revision_id,kind,schema_version,producer_json,input_hash,output_json,created_at) VALUES(?,?,?,'digest',?,?,?,?,?)").run(id, input.itemId, input.revisionId, parsed.digest.schemaVersion, producer, input.inputHash, output, now());
     return { id, duplicate: false };
 }
 function derivationRow(r) { return { id: String(r.id), itemId: String(r.item_id), revisionId: String(r.revision_id), kind: 'digest', producer: JSON.parse(String(r.producer_json)), inputHash: String(r.input_hash), output: JSON.parse(String(r.output_json)), review: JSON.parse(String(r.review_json)), createdAt: String(r.created_at) }; }
@@ -69,9 +71,9 @@ export function reviewDigest(db, id, review) {
             mutate(db, 'derivation', id, path, next);
     return derivationRow(db.prepare('SELECT * FROM derivations WHERE id=?').get(id));
 }
-/** The accepted subset of a digest. Rejected or unreviewed fields never leave the device. */
+/** The accepted subset of a digest (v1 or v2). Rejected or unreviewed fields never leave the device; v1 ideas keep their kind. */
 export function acceptedDigest(d) {
-    const ideas = d.output.ideas.flatMap((idea, i) => d.review.ideas?.[i] === 'accepted' ? [{ claim: idea.claim, detail: idea.detail, kind: idea.kind, quotes: idea.quotes.filter((_, j) => d.review.quotes?.[i]?.[j] === 'accepted').map(q => q.text) }] : []);
+    const ideas = d.output.ideas.flatMap((idea, i) => d.review.ideas?.[i] === 'accepted' ? [{ claim: idea.claim, detail: idea.detail, ...(idea.kind !== undefined ? { kind: idea.kind } : {}), quotes: idea.quotes.filter((_, j) => d.review.quotes?.[i]?.[j] === 'accepted').map(q => q.text) }] : []);
     const lead = d.review.gist === 'accepted' ? d.output.gist.lead : undefined;
     return lead || ideas.length ? { ...(lead ? { lead } : {}), ideas } : undefined;
 }

package/dist/src/importers/jungle-digest.d.ts

@@ -1,12 +1,13 @@
-import { type DigestIssue, type DigestV1 } from '../digest/schema.js';
+import { type DigestIssue, type DigestV2 } from '../digest/schema.js';
 import { type Form, type QuoteMatch } from '../digest/pipeline.js';
 /**
- * Pure conversion of one reviewed Jungle Reading digest note (`kb/notes/reading/<slug>.md`) into Digest v1. Jungle keeps
- * quotes in their own section, so each quote is assigned to the idea it shares the most content words with.
+ * Pure conversion of one reviewed Jungle Reading digest note (`kb/notes/reading/<slug>.md`) into Digest v2. Jungle keeps
+ * quotes in their own section, so each verbatim quote is assigned to the idea it shares the most content words with.
+ * Owner text is never cut or rewritten: a note that does not fit v2 as written is reported, not converted.
  * Nothing here reads files; callers pass the note and, when available, its capture Markdown.
  */
 export declare const jungleTags: readonly ["agent-eng", "ai", "work", "business", "creative-coding", "finance", "music", "internet", "security", "history", "art", "hardware", "climate", "article", "interactive", "code", "x", "video"];
-/** Tags that name how a source is consumed; Digest v1 carries that as `form`. */
+/** Tags that name how a source is consumed; a digest carries that as `form`. */
 export declare const jungleFormatTags: readonly ["article", "interactive", "x", "video"];
 export declare class JungleDigestError extends Error {
     readonly code: 'not-digest' | 'malformed' | 'no-capture';
@@ -32,23 +33,25 @@ export interface JungleNote {
     }[];
     quotes: JungleQuote[];
 }
-export type Lossy = 'context-trimmed' | 'quote-unassigned' | 'quote-missing' | 'idea-unquoted' | 'no-content-tag';
+/**
+ * Why a Jungle quote is left out of the digest: not found as written in the capture (`snapped` matches differ in markup),
+ * under four words, over the quote budget (count, words or source share), or every idea already holds two.
+ */
+export type QuoteDrop = 'not-verbatim' | 'too-short' | 'budget' | 'overflow';
 export interface JungleConversion {
     note: JungleNote;
-    /** Every idea, including unquoted ones: the evaluation gold. */
-    gold: DigestV1;
-    /** Per Jungle quote: the gold idea it was assigned to, and how it located in the capture. */
+    /** The note as Digest v2: the Gist's first sentence as lead and the rest as context, every idea, and the quotes that survive. */
+    gold: DigestV2;
+    /** Per Jungle quote, in note order: the idea it went to (null when dropped), how it located in the capture, and why it was dropped. */
     quotes: {
         idea: number | null;
         match?: QuoteMatch;
+        dropped?: QuoteDrop;
     }[];
-    lossy: Lossy[];
-    /** checkDigest issues of the gold against the capture; empty without a capture. */
+    /** Why the gold is not a valid Digest v2: shape issues (an empty detail), then checkDigest issues against the capture when one is given. */
     issues: DigestIssue[];
-    /** The gold with unlocated quotes and then unquoted ideas dropped, when that still passes every v1 rule. */
-    importable?: DigestV1;
-    /** Gold passes every v1 rule against the capture with nothing dropped or trimmed. `kind` is never gold: Jungle has no kinds. */
-    clean: boolean;
+    /** The gold, when a capture was given and the gold passes every v2 rule against it. */
+    digest?: DigestV2;
 }
 export type Yaml = string | boolean | Yaml[] | {
     [k: string]: Yaml;
@@ -58,7 +61,7 @@ export declare function captureBody(capture: string): string;
 export declare function parseJungleNote(markdown: string): JungleNote;
 /**
  * One Jungle Reading note of any form (digest, social, note, conversation), kept whole: the exact Markdown and its hash,
- * the parsed frontmatter, and the gist, ideas and quotes where the form has them. Nothing is trimmed to Digest v1 limits.
+ * the parsed frontmatter, and the gist, ideas and quotes where the form has them. Nothing is trimmed to digest limits.
  * `capture` is the evidence the note is about: the first `synthesizes` relation, else the first `evidenced-by`.
  */
 export interface JungleEditorial {
@@ -84,14 +87,21 @@ export declare function parseJungleEditorial(markdown: string): JungleEditorial;
 /** Content-word stems: lowercase, stopwords out, a crude plural/tense strip. Shared by idea assignment and lexical coverage. */
 export declare function contentTerms(text: string): Set<string>;
 export declare function termSimilarity(a: Set<string>, b: Set<string>): number;
-/** Best-first assignment: every idea gets at most one quote before any gets a second; zero-overlap pairs are never made. */
+/**
+ * Each quote in order goes to the idea sharing the most content words with its claim and detail (ties: the earliest idea),
+ * else to the next best idea with room; null when every idea already holds `cap` quotes.
+ */
 export declare function assignQuotes(ideas: {
     claim: string;
     detail: string;
 }[], quotes: {
     text: string;
-}[]): (number | null)[];
+}[], cap?: number): (number | null)[];
 export declare const firstSentence: (text: string) => readonly [string, string];
 export declare function formOf(note: JungleNote): Form;
-/** Convert one Jungle digest note. With `capture` (the capture Markdown, frontmatter allowed), quotes are located and the gold is checked. */
+/**
+ * Convert one Jungle digest note. With `capture` (the capture Markdown, frontmatter allowed), each quote is kept only when it
+ * occurs as written (folded typography only) and has at least four words; whole quotes then leave, longest and then latest in
+ * the note first, until the rest fit the quote budget (never the last one); survivors are assigned to ideas, and the gold is checked.
+ */
 export declare function convertJungleDigest(noteMarkdown: string, capture?: string): JungleConversion;

package/dist/src/importers/jungle-digest.js

@@ -1,14 +1,15 @@
 import { createHash } from 'node:crypto';
-import { foldText, locateAll, words } from '../annotations/quote.js';
-import { checkDigest, digestLimits as L } from '../digest/schema.js';
-import { minQuoteWords, snapQuote } from '../digest/pipeline.js';
+import { foldText, words } from '../annotations/quote.js';
+import { checkDigest, digestLimits as L, parseDigest } from '../digest/schema.js';
+import { snapQuote } from '../digest/pipeline.js';
 /**
- * Pure conversion of one reviewed Jungle Reading digest note (`kb/notes/reading/<slug>.md`) into Digest v1. Jungle keeps
- * quotes in their own section, so each quote is assigned to the idea it shares the most content words with.
+ * Pure conversion of one reviewed Jungle Reading digest note (`kb/notes/reading/<slug>.md`) into Digest v2. Jungle keeps
+ * quotes in their own section, so each verbatim quote is assigned to the idea it shares the most content words with.
+ * Owner text is never cut or rewritten: a note that does not fit v2 as written is reported, not converted.
  * Nothing here reads files; callers pass the note and, when available, its capture Markdown.
  */
 export const jungleTags = ['agent-eng', 'ai', 'work', 'business', 'creative-coding', 'finance', 'music', 'internet', 'security', 'history', 'art', 'hardware', 'climate', 'article', 'interactive', 'code', 'x', 'video'];
-/** Tags that name how a source is consumed; Digest v1 carries that as `form`. */
+/** Tags that name how a source is consumed; a digest carries that as `form`. */
 export const jungleFormatTags = ['article', 'interactive', 'x', 'video'];
 export class JungleDigestError extends Error {
     code;
@@ -148,21 +149,14 @@ export function termSimilarity(a, b) { if (!a.size || !b.size)
     return 0; let n = 0; for (const t of a)
     if (b.has(t))
         n++; return n / Math.sqrt(a.size * b.size); }
-/** Best-first assignment: every idea gets at most one quote before any gets a second; zero-overlap pairs are never made. */
-export function assignQuotes(ideas, quotes) { return assign(ideas, quotes); }
-function assign(ideas, quotes) {
-    const ideaTerms = ideas.map(i => contentTerms(`${i.claim} ${i.detail}`)), pairs = [];
-    quotes.forEach((q, qi) => { const t = contentTerms(q.text); ideaTerms.forEach((it, ii) => { const s = termSimilarity(t, it); if (s > 0)
-        pairs.push({ q: qi, i: ii, s }); }); });
-    pairs.sort((a, b) => b.s - a.s || Math.abs(a.q - a.i) - Math.abs(b.q - b.i) || a.q - b.q);
-    const out = quotes.map(() => null), load = ideas.map(() => 0);
-    for (const cap of [1, L.maxQuotesPerIdea])
-        for (const p of pairs)
-            if (out[p.q] === null && load[p.i] < cap) {
-                out[p.q] = p.i;
-                load[p.i]++;
-            }
-    return out;
+/**
+ * Each quote in order goes to the idea sharing the most content words with its claim and detail (ties: the earliest idea),
+ * else to the next best idea with room; null when every idea already holds `cap` quotes.
+ */
+export function assignQuotes(ideas, quotes, cap = L.maxQuotesPerIdea) {
+    const terms = ideas.map(i => contentTerms(`${i.claim} ${i.detail}`)), load = ideas.map(() => 0);
+    return quotes.map(q => { const t = contentTerms(q.text), pick = terms.map((it, i) => ({ i, s: termSimilarity(t, it) })).sort((a, b) => b.s - a.s || a.i - b.i).find(r => load[r.i] < cap); if (!pick)
+        return null; load[pick.i]++; return pick.i; });
 }
 export const firstSentence = (text) => { const m = /^(.+?[.!?]["”’)]*)\s+(?=["“(]?[A-Z0-9])/.exec(text); return m ? [m[1], text.slice(m[0].length)] : [text, '']; };
 export function formOf(note) {
@@ -172,50 +166,31 @@ export function formOf(note) {
         return 'thread';
     return /\.pdf(?:$|[?#])|arxiv\.org\/pdf\//i.test(note.sourceUrl) ? 'pdf' : 'article';
 }
-/** Convert one Jungle digest note. With `capture` (the capture Markdown, frontmatter allowed), quotes are located and the gold is checked. */
+/**
+ * Convert one Jungle digest note. With `capture` (the capture Markdown, frontmatter allowed), each quote is kept only when it
+ * occurs as written (folded typography only) and has at least four words; whole quotes then leave, longest and then latest in
+ * the note first, until the rest fit the quote budget (never the last one); survivors are assigned to ideas, and the gold is checked.
+ */
 export function convertJungleDigest(noteMarkdown, capture) {
-    const note = parseJungleNote(noteMarkdown), lossy = new Set(), source = capture === undefined ? undefined : captureBody(capture);
-    const [lead, rest] = firstSentence(note.gist);
-    let context = '';
-    for (let r = rest; r;) {
-        const [s, next] = firstSentence(r);
-        if (words(context ? `${context} ${s}` : s) > L.contextWords) {
-            lossy.add('context-trimmed');
-            break;
-        }
-        context = context ? `${context} ${s}` : s;
-        r = next;
-    }
-    const assigned = assign(note.ideas, note.quotes), authors = new Set(note.authors.map(a => foldText(a).toLowerCase())), form = formOf(note);
-    const located = note.quotes.map(q => source === undefined ? undefined : snapQuote(source, q.text));
-    const ideas = note.ideas.map((idea, i) => {
-        const mine = note.quotes.map((q, k) => ({ q, k })).filter(x => assigned[x.k] === i);
-        const other = mine.find(x => !authors.has(foldText(x.q.speaker).toLowerCase()));
-        // A non-author in a talk is a speaker; in writing, the author reports them.
-        const voice = other ? { type: form === 'video' ? 'speaker' : 'reported', name: other.q.speaker } : { type: 'author' };
-        const quotes = mine.map(x => ({ text: located[x.k]?.text ?? x.q.text, speaker: x.q.speaker }));
-        return { claim: idea.claim, detail: idea.detail, kind: 'argument', voice, quotes };
-    });
-    const content = note.tags.filter(t => t !== 'reading' && !jungleFormatTags.includes(t)), tags = (content.length ? content : note.tags.filter(t => t !== 'reading')).slice(0, L.maxTags);
-    if (!content.length)
-        lossy.add('no-content-tag');
-    if (assigned.some(a => a === null))
-        lossy.add('quote-unassigned');
-    if (located.some(l => l?.match === 'missing'))
-        lossy.add('quote-missing');
-    if (ideas.some(i => !i.quotes.length))
-        lossy.add('idea-unquoted');
-    const gold = { schemaVersion: 1, form, gist: { lead, ...(context ? { context } : {}) }, ideas, tags };
-    const options = { tags: jungleTags };
-    const issues = source === undefined ? [] : checkDigest(gold, source, options).issues;
-    let importable;
-    if (source !== undefined) {
-        const kept = note.quotes.map((_, k) => assigned[k] !== null && located[k]?.match !== 'missing');
-        // Import keeps Sponge's ordering rule: ideas by their earliest quote in the capture, quotes of at least minQuoteWords.
-        const at = (t) => locateAll(source, t)[0]?.start ?? Number.MAX_SAFE_INTEGER;
-        const trimmed = { ...gold, ideas: note.ideas.map((_, i) => ({ ...ideas[i], quotes: note.quotes.flatMap((__, k) => assigned[k] === i && kept[k] && words(located[k].text) >= minQuoteWords ? [{ text: located[k].text, speaker: note.quotes[k].speaker }] : []).sort((a, b) => at(a.text) - at(b.text)) })).filter(i => i.quotes.length).sort((a, b) => at(a.quotes[0].text) - at(b.quotes[0].text)) };
-        if (checkDigest(trimmed, source, options).ok)
-            importable = trimmed;
+    const note = parseJungleNote(noteMarkdown), source = capture === undefined ? undefined : captureBody(capture), [lead, context] = firstSentence(note.gist);
+    const located = note.quotes.map(q => source === undefined ? undefined : snapQuote(source, q.text).match);
+    const dropped = note.quotes.map((q, k) => located[k] === 'missing' || located[k] === 'snapped' ? 'not-verbatim' : words(q.text) < L.minQuoteWords ? 'too-short' : undefined);
+    let kept = note.quotes.flatMap((q, k) => dropped[k] ? [] : [{ q, k, n: words(q.text) }]);
+    // The pipeline's budget rule, applied to owner quotes: drop whole quotes, never edit one. A single quote over budget still fails the check.
+    const budget = source === undefined ? Infinity : Math.min(L.totalQuoteWords, Math.max(L.quoteWords, Math.floor(words(source) * L.sourceQuoteShare)));
+    while (kept.length > 1 && (kept.length > L.maxQuotes || kept.reduce((n, x) => n + x.n, 0) > budget)) {
+        const x = [...kept].sort((a, b) => b.n - a.n || b.k - a.k)[0];
+        dropped[x.k] = 'budget';
+        kept = kept.filter(y => y !== x);
     }
-    return { note, gold, quotes: note.quotes.map((_, k) => ({ idea: assigned[k] ?? null, ...(located[k] ? { match: located[k].match } : {}) })), lossy: [...lossy], issues, ...(importable ? { importable } : {}), clean: source !== undefined && issues.length === 0 && lossy.size === 0 };
+    const assigned = note.quotes.map(() => null);
+    assignQuotes(note.ideas, kept.map(x => x.q)).forEach((idea, n) => { if (idea === null)
+        dropped[kept[n].k] = 'overflow';
+    else
+        assigned[kept[n].k] = idea; });
+    const ideas = note.ideas.map((idea, i) => ({ claim: idea.claim, detail: idea.detail, quotes: note.quotes.flatMap((q, k) => assigned[k] === i ? [{ text: q.text, ...(q.attribution ? { attribution: q.attribution } : {}) }] : []) }));
+    const tags = note.tags.filter(t => t !== 'reading' && !jungleFormatTags.includes(t));
+    const gold = { schemaVersion: 2, form: formOf(note), gist: { lead, ...(context ? { context } : {}) }, ideas, tags };
+    const issues = [...parseDigest(gold).issues, ...source === undefined ? [] : checkDigest(gold, source, { tags: jungleTags }).issues];
+    return { note, gold, quotes: note.quotes.map((_, k) => ({ idea: assigned[k] ?? null, ...(located[k] ? { match: located[k] } : {}), ...(dropped[k] ? { dropped: dropped[k] } : {}) })), issues, ...(source !== undefined && !issues.length ? { digest: gold } : {}) };
 }

package/dist/src/importers/jungle-store.d.ts

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from 'node:sqlite';
-import { type DigestV1 } from '../digest/schema.js';
+import { type DigestV2 } from '../digest/schema.js';
 import { type VisibilityState } from '../identity/visibility.js';
 import { type JungleEditorial } from './jungle-digest.js';
 /**
@@ -8,7 +8,7 @@ import { type JungleEditorial } from './jungle-digest.js';
  */
 export declare const jungleNamespace = "jungle", jungleRealm = "import:jungle", jungleProducer: {
     readonly importer: "sponge-jungle-reading";
-    readonly version: "1";
+    readonly version: "2";
 };
 export type EditorialAction = 'new' | 'unchanged' | 'user-review-wins';
 export type DigestAction = 'new' | 'unchanged' | 'not-convertible' | 'not-digest' | 'user-review-wins' | 'user-digest-wins';
@@ -17,13 +17,13 @@ export interface JungleNoteInput {
     itemId: string;
     revisionId: string;
     editorial: JungleEditorial;
-    v1?: DigestV1;
+    digest?: DigestV2;
 }
 export interface JunglePlan {
     editorialId: string;
     editorial: EditorialAction;
-    v1Id?: string;
-    v1: DigestAction;
+    digestId?: string;
+    digest: DigestAction;
     visibility: VisibilityAction;
 }
 /** What Jungle's `reading.status` asks for: `published` is Jungle's explicit public approval, `draft` stays private. */
@@ -39,7 +39,7 @@ export declare function visibilityAction(state: Pick<VisibilityState, 'access' |
 export declare function planJungleNote(db: DatabaseSync, input: JungleNoteInput): JunglePlan;
 /**
  * Apply one note; the caller holds the write transaction. A new editorial object is accepted through `review.note` unless
- * the user already rejected or cleared an earlier one; a clean Digest v1 is stored and accepted per field, linked to the
+ * the user already rejected or cleared an earlier one; a converted Digest v2 is stored and accepted per field, linked to the
  * editorial object by its input hash, unless the user owns a digest of this item or changed an imported digest's review.
  */
 export declare function applyJungleNote(db: DatabaseSync, input: JungleNoteInput): JunglePlan;

package/dist/src/importers/jungle-store.js

@@ -8,7 +8,7 @@ import { jungleTags } from './jungle-digest.js';
  * The library side of `sponge import jungle`: one Jungle Reading note onto the item holding its capture.
  * `planJungleNote` only reads; `applyJungleNote` runs the same plan inside the caller's transaction, through the logged paths.
  */
-export const jungleNamespace = 'jungle', jungleRealm = 'import:jungle', jungleProducer = { importer: 'sponge-jungle-reading', version: '1' };
+export const jungleNamespace = 'jungle', jungleRealm = 'import:jungle', jungleProducer = { importer: 'sponge-jungle-reading', version: '2' };
 /** Receipts of the importer's own visibility writes (local, like every import receipt), so a later user override is recognisable. */
 const visibilityReceipts = 'jungle-visibility';
 /** What Jungle's `reading.status` asks for: `published` is Jungle's explicit public approval, `draft` stays private. */
@@ -49,29 +49,30 @@ export function planJungleNote(db, input) {
     const { itemId, revisionId, editorial } = input, editorialId = derivationId(revisionId, 'editorial', editorial.markdownSha256, canonicalEditorial(editorial));
     const editorials = db.prepare("SELECT id,review_json FROM derivations WHERE item_id=? AND kind='editorial'").all(itemId);
     const editorialAction = editorials.some(r => r.id === editorialId) ? 'unchanged' : editorials.some(r => JSON.parse(String(r.review_json)).note !== 'accepted') ? 'user-review-wins' : 'new';
-    let v1 = 'not-digest', v1Id;
-    if (editorial.form === 'digest' && !input.v1)
-        v1 = 'not-convertible';
-    else if (input.v1) {
-        const digests = db.prepare("SELECT id,producer_json,output_json,review_json FROM derivations WHERE item_id=? AND kind='digest'").all(itemId), parsed = parseDigest(input.v1).digest;
-        v1Id = parsed && derivationId(revisionId, 'digest', editorialId, canonicalDigest(parsed));
-        if (!parsed)
-            v1 = 'not-convertible';
-        else if (digests.some(r => r.id === v1Id))
-            v1 = 'unchanged';
+    // Any earlier digest of the item, v1 included, takes part: an unchanged imported one is superseded by the v2 import, a user's is never.
+    let action = 'not-digest', digestId;
+    if (editorial.form === 'digest' && !input.digest)
+        action = 'not-convertible';
+    else if (input.digest) {
+        const digests = db.prepare("SELECT id,producer_json,output_json,review_json FROM derivations WHERE item_id=? AND kind='digest'").all(itemId), parsed = parseDigest(input.digest).digest;
+        digestId = parsed && derivationId(revisionId, 'digest', editorialId, canonicalDigest(parsed));
+        if (!parsed || parsed.schemaVersion !== 2)
+            action = 'not-convertible';
+        else if (digests.some(r => r.id === digestId))
+            action = 'unchanged';
         else if (digests.some(r => !imported(r)))
-            v1 = 'user-digest-wins';
+            action = 'user-digest-wins';
         else if (digests.some(r => JSON.stringify(JSON.parse(String(r.review_json))) !== JSON.stringify(allAccepted(JSON.parse(String(r.output_json))))))
-            v1 = 'user-review-wins';
+            action = 'user-review-wins';
         else
-            v1 = editorialAction === 'user-review-wins' ? 'user-review-wins' : 'new';
+            action = editorialAction === 'user-review-wins' ? 'user-review-wins' : 'new';
     }
     const visibility = visibilityAction(visibilityState(db, itemId), editorial.status, userOverride(db, itemId)).action;
-    return { editorialId, editorial: editorialAction, ...(v1Id ? { v1Id } : {}), v1, visibility };
+    return { editorialId, editorial: editorialAction, ...(digestId ? { digestId } : {}), digest: action, visibility };
 }
 /**
  * Apply one note; the caller holds the write transaction. A new editorial object is accepted through `review.note` unless
- * the user already rejected or cleared an earlier one; a clean Digest v1 is stored and accepted per field, linked to the
+ * the user already rejected or cleared an earlier one; a converted Digest v2 is stored and accepted per field, linked to the
  * editorial object by its input hash, unless the user owns a digest of this item or changed an imported digest's review.
  */
 export function applyJungleNote(db, input) {
@@ -81,9 +82,9 @@ export function applyJungleNote(db, input) {
         if (plan.editorial === 'new')
             reviewEditorial(db, plan.editorialId, 'accepted');
     }
-    if (plan.v1 === 'new') {
-        const stored = putDigest(db, { itemId: input.itemId, revisionId: input.revisionId, producer: { ...producer, editorial: plan.editorialId }, inputHash: plan.editorialId, output: input.v1, options: { tags: jungleTags } });
-        reviewDigest(db, stored.id, allAccepted(input.v1));
+    if (plan.digest === 'new') {
+        const stored = putDigest(db, { itemId: input.itemId, revisionId: input.revisionId, producer: { ...producer, editorial: plan.editorialId }, inputHash: plan.editorialId, output: input.digest, options: { tags: jungleTags } });
+        reviewDigest(db, stored.id, allAccepted(input.digest));
     }
     const action = visibilityAction(visibilityState(db, input.itemId), input.editorial.status, userOverride(db, input.itemId));
     if (action.target !== undefined) {

package/dist/src/importers/jungle.d.ts

@@ -1,13 +1,13 @@
 import type { LibraryStore } from '../store/index.js';
-import { type DigestV1 } from '../digest/schema.js';
-import { type JungleEditorial } from './jungle-digest.js';
+import { type DigestV2 } from '../digest/schema.js';
+import { type JungleEditorial, type QuoteDrop } from './jungle-digest.js';
 import { type DigestAction, type EditorialAction, type VisibilityAction } from './jungle-store.js';
 import type { BundleVerifier } from './inspect.js';
 /**
  * `sponge import jungle DIR`: every Jungle Reading note (`kb/notes/reading/<slug>.md`) onto the item holding its capture.
  * The capture goes through the verified bundle import (always as a private association); the note becomes an accepted
- * editorial derivation, plus an accepted Digest v1 when it converts with nothing dropped; `reading.status` becomes the
- * item's visibility. Jungle is only read. A dry run reads the notes, captures and library and writes nothing.
+ * editorial derivation, plus an accepted Digest v2 when it converts without altering owner text (non-verbatim, short and
+ * overflowing quotes are dropped and reported); `reading.status` becomes the item's visibility. Jungle is only read. A dry run reads the notes, captures and library and writes nothing.
  */
 export interface JungleImportOptions {
     verify?: BundleVerifier;
@@ -17,6 +17,14 @@ export interface JungleImportOptions {
     signal?: AbortSignal;
 }
 export type JungleSkip = 'not-reading-note' | 'malformed-note' | 'no-capture' | 'capture-missing' | 'item-deleted' | 'capture-unsupported' | 'capture-failed';
+/** Per note: quotes assigned to ideas, and each dropped quote by its 0-based position in the note's Quotes section. */
+export interface JungleQuoteReport {
+    assigned: number;
+    dropped: {
+        quote: number;
+        reason: QuoteDrop;
+    }[];
+}
 export interface JungleEntry {
     slug: string;
     form?: string;
@@ -24,14 +32,16 @@ export interface JungleEntry {
     item?: 'new' | 'existing';
     itemId?: string;
     editorial?: EditorialAction;
-    v1?: DigestAction;
-    v1Issues?: string[];
+    digest?: DigestAction;
+    digestIssues?: string[];
+    quotes?: JungleQuoteReport;
     visibility?: VisibilityAction;
     skipped?: JungleSkip;
     code?: string;
 }
+/** Schema 2: digest actions are Digest v2 (`digest`, `digestIssues`; counts add notes per reason and quotes assigned or dropped); schema 1 reported Digest v1 as `v1`. */
 export interface JungleImportReport {
-    schemaVersion: 1;
+    schemaVersion: 2;
     dryRun: boolean;
     captureVerification: 'deferred' | 'verified';
     notes: number;
@@ -39,16 +49,22 @@ export interface JungleImportReport {
         newItems: number;
         existingItems: number;
         editorial: Record<string, number>;
-        v1: Record<string, number>;
+        digest: Record<string, number>;
+        digestIssues: Record<string, number>;
+        quotes: {
+            assigned: number;
+            dropped: Record<string, number>;
+        };
         visibility: Record<string, number>;
         skipped: Record<string, number>;
     };
     entries: JungleEntry[];
     nextOffset: number | null;
 }
-/** Digest v1 only when the note converts with nothing dropped or trimmed and passes every rule against this revision's Markdown. */
-export declare function jungleV1(editorial: JungleEditorial, markdown: string): {
-    v1?: DigestV1;
+/** Digest v2 when the note converts and passes every rule against this revision's Markdown; otherwise the reasons. */
+export declare function jungleDigest(editorial: JungleEditorial, markdown: string): {
+    digest?: DigestV2;
     issues: string[];
+    quotes?: JungleQuoteReport;
 };
 export declare function importJungle(store: LibraryStore, jungle: string, options?: JungleImportOptions): Promise<JungleImportReport>;

package/dist/src/importers/jungle.js

@@ -13,12 +13,13 @@ const errorCode = (error) => String(error?.code ?? (error instanceof Error ? err
 /** A capture link is `<dir>/<name>` under `kb/`, never escaping it; the bundle is its directory. */
 function captureLink(link) { if (isAbsolute(link) || link.includes('\\') || link.split('/').length < 2 || link.split('/').some(p => !p || p === '.' || p === '..'))
     throw new JungleDigestError('no-capture'); return link; }
-/** Digest v1 only when the note converts with nothing dropped or trimmed and passes every rule against this revision's Markdown. */
-export function jungleV1(editorial, markdown) {
+/** Digest v2 when the note converts and passes every rule against this revision's Markdown; otherwise the reasons. */
+export function jungleDigest(editorial, markdown) {
     if (editorial.form !== 'digest')
         return { issues: [] };
-    const c = convertJungleDigest(editorial.markdown, markdown), check = checkDigest(c.gold, markdown, { tags: jungleTags }), issues = [...c.lossy, ...c.issues.map(i => `${i.path}:${i.code}`), ...check.issues.map(i => `${i.path}:${i.code}`)];
-    return c.clean && check.ok ? { v1: c.gold, issues: [] } : { issues: [...new Set(issues)] };
+    const c = convertJungleDigest(editorial.markdown, markdown), check = checkDigest(c.gold, markdown, { tags: jungleTags }), issues = [...new Set([...c.issues, ...check.issues].map(i => `${i.path}:${i.code}`))];
+    const quotes = { assigned: c.quotes.filter(q => q.idea !== null).length, dropped: c.quotes.flatMap((q, k) => q.dropped ? [{ quote: k, reason: q.dropped }] : []) };
+    return c.digest && check.ok ? { digest: c.digest, issues: [], quotes } : { issues, quotes };
 }
 /** What a verified import would store, read from the bundle without the verifier: the same localization, from the manifest's asset list. */
 async function previewCapture(kb, bundle, link) {
@@ -37,7 +38,7 @@ export async function importJungle(store, jungle, options = {}) {
         throw Object.assign(Error('invalid-input'), { code: 'invalid-input' });
     if (!dryRun && !options.verify)
         throw Object.assign(Error('runtime-missing'), { code: 'runtime-missing' });
-    const report = { schemaVersion: 1, dryRun, captureVerification: dryRun ? 'deferred' : 'verified', notes: files.length, counts: { newItems: 0, existingItems: 0, editorial: {}, v1: {}, visibility: {}, skipped: {} }, entries: [], nextOffset: offset + limit < files.length ? offset + limit : null };
+    const report = { schemaVersion: 2, dryRun, captureVerification: dryRun ? 'deferred' : 'verified', notes: files.length, counts: { newItems: 0, existingItems: 0, editorial: {}, digest: {}, digestIssues: {}, quotes: { assigned: 0, dropped: {} }, visibility: {}, skipped: {} }, entries: [], nextOffset: offset + limit < files.length ? offset + limit : null };
     const bump = (m, k) => { m[k] = (m[k] ?? 0) + 1; }, seen = new Set();
     for (const file of files.slice(offset, offset + limit)) {
         if (options.signal?.aborted)
@@ -82,12 +83,12 @@ export async function importJungle(store, jungle, options = {}) {
             seen.add(link);
             if (dryRun) {
                 if (prior?.revisionId) {
-                    const markdown = store.revisionMarkdown(prior.revisionId), { v1, issues } = jungleV1(editorial, markdown), plan = store.planJungleNote({ itemId: prior.itemId, revisionId: prior.revisionId, editorial, ...(v1 ? { v1 } : {}) });
-                    Object.assign(entry, { itemId: prior.itemId, editorial: plan.editorial, v1: plan.v1, ...(issues.length ? { v1Issues: issues } : {}), visibility: plan.visibility });
+                    const markdown = store.revisionMarkdown(prior.revisionId), { digest, issues, quotes } = jungleDigest(editorial, markdown), plan = store.planJungleNote({ itemId: prior.itemId, revisionId: prior.revisionId, editorial, ...(digest ? { digest } : {}) });
+                    Object.assign(entry, { itemId: prior.itemId, editorial: plan.editorial, digest: plan.digest, ...(issues.length ? { digestIssues: issues } : {}), ...(quotes ? { quotes } : {}), visibility: plan.visibility });
                 }
                 else {
-                    const preview = await previewCapture(kb, bundle, link), { v1, issues } = jungleV1(editorial, preview.markdown), access = accessClass(jungleRealm, preview.locator);
-                    Object.assign(entry, { editorial: 'new', v1: editorial.form !== 'digest' ? 'not-digest' : v1 ? 'new' : 'not-convertible', ...(issues.length ? { v1Issues: issues } : {}), visibility: visibilityAction({ access, default: defaultVisibility(access, 'private'), override: null }, editorial.status, false).action });
+                    const preview = await previewCapture(kb, bundle, link), { digest, issues, quotes } = jungleDigest(editorial, preview.markdown), access = accessClass(jungleRealm, preview.locator);
+                    Object.assign(entry, { editorial: 'new', digest: editorial.form !== 'digest' ? 'not-digest' : digest ? 'new' : 'not-convertible', ...(issues.length ? { digestIssues: issues } : {}), ...(quotes ? { quotes } : {}), visibility: visibilityAction({ access, default: defaultVisibility(access, 'private'), override: null }, editorial.status, false).action });
                 }
             }
             else {
@@ -103,12 +104,19 @@ export async function importJungle(store, jungle, options = {}) {
                     entry.code = code;
                     throw entry;
                 }
-                const itemId = imported.itemId, revisionId = store.importedRevision(itemId, importBundleHash(imported.sourceHash)), markdown = store.revisionMarkdown(revisionId), { v1, issues } = jungleV1(editorial, markdown);
-                const plan = store.applyJungleNote({ itemId, revisionId, editorial, ...(v1 ? { v1 } : {}) });
-                Object.assign(entry, { itemId, editorial: plan.editorial, v1: plan.v1, ...(issues.length ? { v1Issues: issues } : {}), visibility: plan.visibility });
+                const itemId = imported.itemId, revisionId = store.importedRevision(itemId, importBundleHash(imported.sourceHash)), markdown = store.revisionMarkdown(revisionId), { digest, issues, quotes } = jungleDigest(editorial, markdown);
+                const plan = store.applyJungleNote({ itemId, revisionId, editorial, ...(digest ? { digest } : {}) });
+                Object.assign(entry, { itemId, editorial: plan.editorial, digest: plan.digest, ...(issues.length ? { digestIssues: issues } : {}), ...(quotes ? { quotes } : {}), visibility: plan.visibility });
             }
             bump(report.counts.editorial, entry.editorial);
-            bump(report.counts.v1, entry.v1);
+            bump(report.counts.digest, entry.digest);
+            for (const i of new Set((entry.digestIssues ?? []).map(i => i.replace(/\.\d+/g, '.N'))))
+                bump(report.counts.digestIssues, i);
+            if (entry.quotes) {
+                report.counts.quotes.assigned += entry.quotes.assigned;
+                for (const d of entry.quotes.dropped)
+                    bump(report.counts.quotes.dropped, d.reason);
+            }
             bump(report.counts.visibility, entry.visibility);
             if (entry.item === 'new')
                 report.counts.newItems++;

package/dist/src/portability/backup.js

@@ -1,4 +1,4 @@
-import { constants, openSync, closeSync, fstatSync, fsyncSync, unlinkSync } from 'node:fs';
+import { constants, openSync, closeSync, fstatSync, fsyncSync, unlinkSync, rmSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { openLibrary } from '../store/index.js';
 import { safeDirectory } from '../store/files.js';
@@ -74,6 +74,8 @@ export async function backupLibrary(store, output) {
             closeSync(fd);
         try {
             unlinkSync(snapshot.path);
+            for (const side of ['-wal', '-shm'])
+                rmSync(snapshot.path + side, { force: true });
         }
         finally {
             store.finishBackup(snapshot.id);

package/dist/src/publish/projection.js

@@ -12,8 +12,8 @@ function selectedClaim(db, revisionId, fields) {
     return undefined;
 }
 /**
- * The public digest: the accepted fields of the current Digest v1, else the public subset of an accepted editorial
- * note (lead, claims, verbatim quotes within the v1 budget). Never both, and never the note's other content.
+ * The public digest: the accepted fields of the current digest (v2, or a stored v1), else the public subset of an accepted
+ * editorial note (lead, claims, verbatim quotes within the v2 limits). Never both, never attributions, and never the note's other content.
  */
 function publicDigest(db, id) { const d = currentDigest(db, id); if (d)
     return acceptedDigest(d); const e = currentEditorial(db, id); return e && publicEditorial(db, e); }

package/native/runtime-manifest.json

@@ -27,14 +27,14 @@
     }
   ],
   "build": {
-    "asrSourceSha256": "1cb743b39e76666adc814306e06c02ae1c59ca3b784a6bb8f186270387f59ee9",
+    "asrSourceSha256": "e944e4e0b1c2cf571e78a83fcfbf56a91a14fd08dcc701562d32555cf090ec40",
     "clangVersion": "Apple clang version 21.0.0 (clang-2100.1.1.101)",
-    "embeddingSourceSha256": "7e499ea896cd9805daca51bb6489c0856acad4edbaf7e76b07ff1e63d5766457",
+    "embeddingSourceSha256": "7d58718911725b3c3dce35a09a253704b4e5e732cf1e23c12389485127534b10",
     "swiftVersion": "Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)"
   },
   "minimumMacOS": "26.0",
-  "packageVersion": "0.2.5",
+  "packageVersion": "0.2.6",
   "platform": "darwin",
   "schemaVersion": 1,
-  "sourceCommit": "e69bea289723e18288322257ffff269b7fe16bac"
+  "sourceCommit": "1190f23ad793985b6934583c5d8b0957d79a4ce0"
 }

package/package.json

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