@hraness/sponge 0.2.5 → 0.3.0

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

@@ -1,37 +1,57 @@
 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';
+import { SpongeError } from '../errors.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`. */
+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; a digest carries that as `form`. */
 export const jungleFormatTags = ['article', 'interactive', 'x', 'video'];
-export class JungleDigestError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-        this.name = 'JungleDigestError';
-    }
-}
-const fail = (code = 'malformed') => { throw new JungleDigestError(code); };
+const fail = (code = 'malformed') => {
+    throw new SpongeError(code);
+};
 /** The frontmatter subset Jungle writes: block maps and lists of scalars, quoted or plain. */
 function parseYaml(lines) {
     let i = 0;
     const indent = (l) => l.length - l.trimStart().length;
-    const scalar = (v) => { v = v.trim(); if (v.startsWith('"')) {
-        try {
-            return JSON.parse(v);
-        }
-        catch {
-            return fail();
+    const scalar = (v) => {
+        v = v.trim();
+        if (v.startsWith('"')) {
+            try {
+                return JSON.parse(v);
+            }
+            catch {
+                return fail();
+            }
         }
-    } if (v.startsWith("'"))
-        return v.endsWith("'") && v.length > 1 ? v.slice(1, -1).replace(/''/g, "'") : fail(); return v === 'true' ? true : v === 'false' ? false : v; };
+        if (v.startsWith("'"))
+            return v.endsWith("'") && v.length > 1 ? v.slice(1, -1).replace(/''/g, "'") : fail();
+        return v === 'true' ? true : v === 'false' ? false : v;
+    };
     const block = (at) => {
         if (lines[i].trimStart().startsWith('- ')) {
             const list = [];
@@ -55,12 +75,18 @@ function parseYaml(lines) {
         while (i < lines.length && indent(lines[i]) === at && !lines[i].trimStart().startsWith('- ')) {
             const m = /^([\w-]+):(?:\s+(.*))?$/.exec(lines[i].trim()) ?? fail();
             i++;
-            if (m[2] !== undefined && m[2] !== '')
-                out[m[1]] = scalar(m[2]);
-            else if (i < lines.length && (indent(lines[i]) > at || indent(lines[i]) === at && lines[i].trimStart().startsWith('- ')))
-                out[m[1]] = block(indent(lines[i]));
-            else
-                out[m[1]] = '';
+            // An own data property even for `__proto__`, which plain assignment would turn into the map's prototype.
+            Object.defineProperty(out, m[1], {
+                value: m[2] !== undefined && m[2] !== ''
+                    ? scalar(m[2])
+                    : i < lines.length &&
+                        (indent(lines[i]) > at || (indent(lines[i]) === at && lines[i].trimStart().startsWith('- ')))
+                        ? block(indent(lines[i]))
+                        : '',
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
         }
         return out;
     };
@@ -68,14 +94,21 @@ function parseYaml(lines) {
     return i === lines.length ? value : fail();
 }
 const object = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
-const strings = (v) => Array.isArray(v) && v.every(x => typeof x === 'string') ? v : fail();
+const strings = (v) => (Array.isArray(v) && v.every((x) => typeof x === 'string') ? v : fail());
 /** Split a Markdown file into its frontmatter lines and body. */
 function frontmatter(markdown) {
     const m = /^---\n([^]*?)\n---(?:\n|$)/.exec(markdown.replace(/\r\n/g, '\n'));
-    return m ? { head: m[1].split('\n').filter(l => l.trim() && !l.trimStart().startsWith('#')), body: markdown.replace(/\r\n/g, '\n').slice(m[0].length) } : { head: [], body: markdown };
+    return m
+        ? {
+            head: m[1].split('\n').filter((l) => l.trim() && !l.trimStart().startsWith('#')),
+            body: markdown.replace(/\r\n/g, '\n').slice(m[0].length),
+        }
+        : { head: [], body: markdown };
 }
 /** Capture Markdown without its YAML frontmatter: what a Sponge revision of the same page would hold. */
-export function captureBody(capture) { return frontmatter(capture).body; }
+export function captureBody(capture) {
+    return frontmatter(capture).body;
+}
 /** `## Heading` sections of a note body, trimmed. */
 function sectionsOf(body) {
     const sections = new Map();
@@ -86,10 +119,19 @@ function sectionsOf(body) {
     return sections;
 }
 /** `- **Claim.** detail` bullets: Jungle's Ideas, and a conversation's Debate. */
-const ideaList = (text) => text.split('\n').filter(l => l.startsWith('- ')).map(l => { const m = /^- \*\*(.+?)\*\*\s*(.*)$/.exec(l.trim()) ?? fail(); return { claim: m[1].trim(), detail: m[2].trim() }; });
+const ideaList = (text) => text
+    .split('\n')
+    .filter((l) => l.startsWith('- '))
+    .map((l) => {
+    const m = /^- \*\*(.+?)\*\*\s*(.*)$/.exec(l.trim()) ?? fail();
+    return { claim: m[1].trim(), detail: m[2].trim() };
+});
 /** Blockquotes ending `> Attribution: Speaker, context`. */
-const quoteList = (text) => text.split(/\n\s*\n/).filter(b => b.trim()).map(b => {
-    const lines = b.split('\n').map(l => /^>\s?(.*)$/.exec(l)?.[1] ?? fail()), at = lines.findIndex(l => l.startsWith('Attribution:'));
+const quoteList = (text) => text
+    .split(/\n\s*\n/)
+    .filter((b) => b.trim())
+    .map((b) => {
+    const lines = b.split('\n').map((l) => /^>\s?(.*)$/.exec(l)?.[1] ?? fail()), at = lines.findIndex((l) => l.startsWith('Attribution:'));
     if (at < 1)
         fail();
     const text = lines.slice(0, at).join(' ').replace(/\s+/g, ' ').trim(), attribution = lines[at].slice('Attribution:'.length).trim();
@@ -100,7 +142,7 @@ export function parseJungleNote(markdown) {
         fail();
     const { head, body } = frontmatter(markdown), meta = parseYaml(head);
     if (!object(meta) || !object(meta.reading))
-        throw new JungleDigestError('not-digest');
+        throw new SpongeError('not-digest');
     const reading = meta.reading;
     if (reading.form !== 'digest')
         fail('not-digest');
@@ -108,63 +150,111 @@ export function parseJungleNote(markdown) {
     const gist = (sections.get('Gist') ?? fail()).replace(/\s+/g, ' ').trim();
     const ideas = ideaList(sections.get('Ideas') ?? fail());
     const quotes = quoteList(sections.get('Quotes') ?? '');
-    if (!gist || !ideas.length || quotes.some(q => !q.text || !q.speaker))
+    if (!gist || !ideas.length || quotes.some((q) => !q.text || !q.speaker))
         fail();
-    const authors = Array.isArray(reading.authors) ? reading.authors.map(a => object(a) && typeof a.name === 'string' ? a.name : fail()) : [];
+    const authors = Array.isArray(reading.authors)
+        ? reading.authors.map((a) => (object(a) && typeof a.name === 'string' ? a.name : fail()))
+        : [];
     const relations = object(meta.relations) ? meta.relations : {}, synth = Array.isArray(relations.synthesizes) ? strings(relations.synthesizes) : [];
-    return { slug: typeof reading.slug === 'string' ? reading.slug : fail(), title: typeof meta.title === 'string' ? meta.title : '', status: typeof reading.status === 'string' ? reading.status : '', sourceUrl: typeof reading.source_url === 'string' ? reading.source_url : '', authors, tags: meta.tags === undefined ? [] : strings(meta.tags), ...(synth[0] ? { capture: synth[0] } : {}), gist, ideas, quotes };
+    return {
+        slug: typeof reading.slug === 'string' ? reading.slug : fail(),
+        title: typeof meta.title === 'string' ? meta.title : '',
+        status: typeof reading.status === 'string' ? reading.status : '',
+        sourceUrl: typeof reading.source_url === 'string' ? reading.source_url : '',
+        authors,
+        tags: meta.tags === undefined ? [] : strings(meta.tags),
+        ...(synth[0] ? { capture: synth[0] } : {}),
+        gist,
+        ideas,
+        quotes,
+    };
 }
 export function parseJungleEditorial(markdown) {
     if (typeof markdown !== 'string' || markdown.length > 4 * 1024 * 1024)
         fail();
     const { head, body } = frontmatter(markdown), meta = parseYaml(head);
     if (!object(meta) || !object(meta.reading))
-        throw new JungleDigestError('not-digest');
+        throw new SpongeError('not-digest');
     const reading = meta.reading, relations = object(meta.relations) ? meta.relations : {};
     const form = reading.form, slug = reading.slug;
     if (typeof form !== 'string' || !form || typeof slug !== 'string' || !/^[a-z0-9][a-z0-9-]{0,199}$/.test(slug))
         return fail();
-    const capture = [relations.synthesizes, relations['evidenced-by']].flatMap(v => Array.isArray(v) ? strings(v) : [])[0] ?? fail('no-capture');
+    const capture = [relations.synthesizes, relations['evidenced-by']].flatMap((v) => (Array.isArray(v) ? strings(v) : []))[0] ??
+        fail('no-capture');
     // A digest must parse strictly; the other forms keep whatever structure they have, and the Markdown keeps the rest.
-    const sections = sectionsOf(body), loose = (f) => { if (form === 'digest')
-        return f(); try {
-        return f();
-    }
-    catch {
-        return undefined;
-    } };
-    const gistText = sections.get('Gist') ?? sections.get('Summary') ?? (typeof reading.summary === 'string' ? reading.summary : undefined), ideaText = sections.get('Ideas') ?? sections.get('Debate'), quoteText = sections.get('Quotes');
+    const sections = sectionsOf(body), loose = (f) => {
+        if (form === 'digest')
+            return f();
+        try {
+            return f();
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const gistText = sections.get('Gist') ??
+        sections.get('Summary') ??
+        (typeof reading.summary === 'string' ? reading.summary : undefined), ideaText = sections.get('Ideas') ?? sections.get('Debate'), quoteText = sections.get('Quotes');
     if (form === 'digest')
         parseJungleNote(markdown);
     const gist = gistText?.replace(/\s+/g, ' ').trim(), ideas = ideaText === undefined ? undefined : loose(() => ideaList(ideaText)), quotes = quoteText === undefined ? undefined : loose(() => quoteList(quoteText));
-    return { schemaVersion: 1, source: 'jungle-reading', form, slug, status: typeof reading.status === 'string' ? reading.status : '', title: typeof meta.title === 'string' ? meta.title : '', sourceUrl: typeof reading.source_url === 'string' ? reading.source_url : '', capture, frontmatter: meta, ...(gist ? { gist } : {}), ...(ideas?.length ? { ideas } : {}), ...(quotes?.length && quotes.every(q => q.text && q.speaker) ? { quotes } : {}), markdownSha256: createHash('sha256').update(markdown).digest('hex'), markdown };
+    return {
+        schemaVersion: 1,
+        source: 'jungle-reading',
+        form,
+        slug,
+        status: typeof reading.status === 'string' ? reading.status : '',
+        title: typeof meta.title === 'string' ? meta.title : '',
+        sourceUrl: typeof reading.source_url === 'string' ? reading.source_url : '',
+        capture,
+        frontmatter: meta,
+        ...(gist ? { gist } : {}),
+        ...(ideas?.length ? { ideas } : {}),
+        ...(quotes?.length && quotes.every((q) => q.text && q.speaker) ? { quotes } : {}),
+        markdownSha256: createHash('sha256').update(markdown).digest('hex'),
+        markdown,
+    };
 }
 const stop = new Set('the a an and or but of to in on for with by from at as is are was were be been it its this that these those not no than then so such into about over under more most less can could would should will just also only very their there they them we our you your he she his her i my me what which who how when where why do does did has have had'.split(' '));
 /** Content-word stems: lowercase, stopwords out, a crude plural/tense strip. Shared by idea assignment and lexical coverage. */
 export function contentTerms(text) {
-    return new Set(foldText(text).toLowerCase().split(/[^a-z0-9]+/).filter(w => w.length > 2 && !stop.has(w)).map(w => w.replace(/(?:ing|ed|es|s)$/, '')).filter(w => w.length > 2));
+    return new Set(foldText(text)
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((w) => w.length > 2 && !stop.has(w))
+        .map((w) => w.replace(/(?:ing|ed|es|s)$/, ''))
+        .filter((w) => w.length > 2));
 }
-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;
+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);
 }
-export const firstSentence = (text) => { const m = /^(.+?[.!?]["”’)]*)\s+(?=["“(]?[A-Z0-9])/.exec(text); return m ? [m[1], text.slice(m[0].length)] : [text, '']; };
+/**
+ * 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) {
     if (note.tags.includes('video'))
         return 'video';
@@ -172,50 +262,62 @@ 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 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);
     }
-    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 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 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;
-    }
-    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 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,33 +1,42 @@
 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';
 /**
  * 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 declare const jungleNamespace = "jungle", jungleRealm = "import:jungle", jungleProducer: {
-    readonly importer: "sponge-jungle-reading";
-    readonly version: "1";
-};
+export declare const jungleNamespace = "jungle", jungleRealm = "import:jungle";
 export type EditorialAction = 'new' | 'unchanged' | 'user-review-wins';
 export type DigestAction = 'new' | 'unchanged' | 'not-convertible' | 'not-digest' | 'user-review-wins' | 'user-digest-wins';
 export type VisibilityAction = 'set-public' | 'set-private' | 'restore-default' | 'unchanged' | 'kept-user-edit' | 'guarded' | 'default-policy';
+/** Local captures only (no web URI of their own): `uri` records the note's `source_url`. Later notes on one capture leave it to the first (`other-note`). */
+export type UriAction = 'new' | 'unchanged' | 'web-capture' | 'other-note' | 'no-source-url' | 'capability';
+/** The first note's title is the item's default title (`noteTitle`); `kept-user-edit` records it while the user's override stays shown. */
+export type TitleAction = 'set' | 'unchanged' | 'other-note' | 'kept-user-edit';
+/** `firstNote` is false for a later note on a capture an earlier note in the same run already used; `firstNoteUri` is the URI that note records (a dry run has not written it). */
 export interface JungleNoteInput {
     itemId: string;
     revisionId: string;
     editorial: JungleEditorial;
-    v1?: DigestV1;
+    digest?: DigestV2;
+    firstNote?: boolean;
+    firstNoteUri?: string;
 }
 export interface JunglePlan {
     editorialId: string;
     editorial: EditorialAction;
-    v1Id?: string;
-    v1: DigestAction;
+    digestId?: string;
+    digest: DigestAction;
+    uri: UriAction;
+    title: TitleAction;
     visibility: VisibilityAction;
 }
-/** What Jungle's `reading.status` asks for: `published` is Jungle's explicit public approval, `draft` stays private. */
-export declare function desiredVisibility(status: string): 'public' | 'private' | undefined;
+/** What a local capture's URI action would be, before or after its item exists. */
+export declare function uriAction(local: boolean, firstNote: boolean, sourceUrl: string, recorded?: string): {
+    action: UriAction;
+    uri?: string;
+};
 /**
  * Jungle's decision becomes an explicit override only while nobody else has set one: once the latest override was not
  * written by this importer, the user's choice wins. A public decision never lifts the capability-URL or local-file guards.
@@ -39,7 +48,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;