@hraness/sponge 0.2.4 → 0.2.6

package/dist/src/identity/visibility.js

@@ -0,0 +1,75 @@
+import { accessClass, defaultVisibility, deriveUris } from './uri.js';
+import { mutate } from '../store/changes.js';
+import { StoreError } from '../store/types.js';
+import { text } from '../store/files.js';
+const fail = (code = 'invalid-input') => { throw new StoreError(code); };
+function firstSource(db, itemId) { return db.prepare('SELECT realm_key,locator FROM source_refs WHERE item_id=? ORDER BY rowid LIMIT 1').get(itemId); }
+/** Recompute derived URIs; metadata and user URIs are left alone. Idempotent. */
+export function syncUris(db, itemId) {
+    const source = firstSource(db, itemId);
+    if (!source)
+        return;
+    const pdf = db.prepare("SELECT ra.sha256 FROM items i JOIN revision_assets ra ON ra.revision_id=i.current_revision WHERE i.id=? AND ra.relationship='source-pdf' ORDER BY ra.ordinal LIMIT 1").get(itemId);
+    const uris = deriveUris({ itemId, locator: String(source.locator), ...(pdf ? { sourcePdfSha256: String(pdf.sha256) } : {}) });
+    const current = db.prepare("SELECT uri,role,resolvable,origin FROM item_uris WHERE item_id=? AND origin IN ('locator','revision') ORDER BY uri").all(itemId).map(r => `${r.uri}|${r.role}|${r.resolvable}|${r.origin}`).join('\n');
+    const next = uris.map(u => `${u.uri}|${u.role}|${Number(u.resolvable)}|${u.origin}`).sort().join('\n');
+    if (current === next)
+        return;
+    db.prepare("DELETE FROM item_uris WHERE item_id=? AND origin IN ('locator','revision')").run(itemId);
+    // A derived primary replaces any other primary; keep later metadata/user URIs as aliases.
+    db.prepare("UPDATE item_uris SET role='alias' WHERE item_id=?").run(itemId);
+    for (const u of uris)
+        db.prepare('INSERT INTO item_uris VALUES(?,?,?,?,?) ON CONFLICT(item_id,uri) DO UPDATE SET role=excluded.role,resolvable=excluded.resolvable,origin=excluded.origin').run(itemId, u.uri, u.role, Number(u.resolvable), u.origin);
+}
+/**
+ * Fill URIs for items created before schema 5, inside migration 5. Each item is its own savepoint:
+ * one hostile locator leaves that item without URIs instead of making the library unopenable.
+ */
+export function backfillUris(db) {
+    const missing = db.prepare("SELECT i.id FROM items i WHERE NOT EXISTS (SELECT 1 FROM item_uris u WHERE u.item_id=i.id AND u.role='primary') AND EXISTS (SELECT 1 FROM source_refs r WHERE r.item_id=i.id)").all().map(r => String(r.id));
+    let skipped = 0;
+    for (const id of missing) {
+        db.exec('SAVEPOINT backfill_uri');
+        try {
+            syncUris(db, id);
+            db.exec('RELEASE backfill_uri');
+        }
+        catch {
+            db.exec('ROLLBACK TO backfill_uri; RELEASE backfill_uri');
+            skipped++;
+        }
+    }
+    return { filled: missing.length - skipped, skipped };
+}
+export function itemUris(db, itemId) {
+    return db.prepare("SELECT uri,role,resolvable,origin FROM item_uris WHERE item_id=? ORDER BY role='alias',uri").all(itemId).map(r => ({ uri: String(r.uri), role: r.role, resolvable: !!r.resolvable, origin: r.origin }));
+}
+/** Items sharing any URI with `uri`: the local half of "who else is reading this". */
+export function itemsForUri(db, uri) {
+    text(uri, 8192);
+    return db.prepare('SELECT DISTINCT u.item_id FROM item_uris u JOIN items i ON i.id=u.item_id WHERE u.uri=? AND i.deleted_at IS NULL ORDER BY u.item_id').all(uri).map(r => String(r.item_id));
+}
+export function visibility(db, itemId) {
+    const item = db.prepare('SELECT visibility,deleted_at FROM items WHERE id=?').get(itemId) ?? fail('unavailable'), source = firstSource(db, itemId);
+    const access = source ? accessClass(String(source.realm_key), String(source.locator)) : 'local';
+    const reading = db.prepare('SELECT state_json FROM reading_state WHERE item_id=?').get(itemId);
+    let importedPrivacy;
+    try {
+        importedPrivacy = reading ? JSON.parse(String(reading.state_json))?.sourcePrivacy : undefined;
+    }
+    catch {
+        importedPrivacy = undefined;
+    }
+    const base = defaultVisibility(access, importedPrivacy), override = (item.visibility ?? null);
+    return { access, default: base, override, effective: item.deleted_at ? 'private' : override ?? base };
+}
+export function setVisibility(db, itemId, value) {
+    if (value !== null && value !== 'public' && value !== 'private')
+        fail();
+    const item = db.prepare('SELECT visibility,deleted_at FROM items WHERE id=?').get(itemId);
+    if (!item || item.deleted_at)
+        fail('unavailable');
+    if ((item.visibility ?? null) !== value)
+        mutate(db, 'item', itemId, 'visibility', value);
+    return visibility(db, itemId);
+}

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

@@ -1,4 +1,5 @@
 import type { LibraryStore } from '../store/index.js';
+import { type ImportEntry } from './manifest.js';
 import { type BundleVerifier } from './inspect.js';
 import type { CaptureRuntime } from '../acquisition/runtime.js';
 export interface ImportOptions {
@@ -25,5 +26,14 @@ export interface ImportReport {
     }[];
     nextOffset: number | null;
 }
+/** One verified bundle: a receipt short-circuits, a dry run stops after verification, otherwise the capture is promoted through the queue. */
+export declare function importBundleEntry(store: LibraryStore, root: string, namespace: string, entry: ImportEntry, verify: BundleVerifier, dryRun: boolean, signal?: AbortSignal): Promise<{
+    status: 'ready' | 'imported' | 'duplicate';
+    sourceHash: string;
+    historicalIntegrity: 'verified' | 'unavailable';
+    itemId?: string;
+}>;
+/** The revision a bundle import committed: content-addressed by its source hash. */
+export declare const importBundleHash: (sourceHash: string) => string;
 /** Additive bounded batches. Every applied entry is reverified; source bundles are read-only. */
 export declare function importManifest(store: LibraryStore, path: string, options: ImportOptions): Promise<ImportReport>;

package/dist/src/importers/apply.js

@@ -27,7 +27,7 @@ async function promote(context, bundle, namespace, entry, sourceHash) {
             throw Error('cancelled');
         await checkpoint('promoting');
         const title = selectedMetadata(bundle.metadata, 'title')?.value;
-        store.commitRevision({ ...attempt, itemId: source.itemId, bundleHash: hash(JSON.stringify(['wordcell-import-v1', sourceHash])), markdown: localized.markdown, title: typeof title === 'string' ? title : undefined, extractor: { name: 'sponge-wordcell-import', version: '1' }, status: bundle.status === 'partial' || localized.missingImages ? 'partial' : 'complete', metadata: [...bundle.metadata, ...Object.entries({ importNamespace: namespace, externalSourceId: entry.id, sourcePrivacy: entry.privacy }).map(([field, value]) => ({ field, value, source: bundle.kind === 'pdf' ? 'pdf' : 'html', observedAt: new Date().toISOString(), rule: 'sponge-import-v1' }))], assets, warnings: bundle.status === 'partial' || localized.missingImages ? ['partial'] : [], importedState: { namespace, sourceKey: entry.id, sourceHash, importerVersion: '1', notes: entry.notes, readingState: entry.readingState, privacy: entry.privacy } });
+        store.commitRevision({ ...attempt, itemId: source.itemId, bundleHash: importBundleHash(sourceHash), markdown: localized.markdown, title: typeof title === 'string' ? title : undefined, extractor: { name: 'sponge-wordcell-import', version: '1' }, status: bundle.status === 'partial' || localized.missingImages ? 'partial' : 'complete', metadata: [...bundle.metadata, ...Object.entries({ importNamespace: namespace, externalSourceId: entry.id, sourcePrivacy: entry.privacy }).map(([field, value]) => ({ field, value, source: bundle.kind === 'pdf' ? 'pdf' : 'html', observedAt: new Date().toISOString(), rule: 'sponge-import-v1' }))], assets, warnings: bundle.status === 'partial' || localized.missingImages ? ['partial'] : [], importedState: { namespace, sourceKey: entry.id, sourceHash, importerVersion: '1', notes: entry.notes, readingState: entry.readingState, privacy: entry.privacy } });
         committed = true;
         result = { ok: true, itemId: source.itemId };
     }
@@ -39,6 +39,28 @@ async function promote(context, bundle, namespace, entry, sourceHash) {
     store.settleAttempt(attempt);
     return { ...result, cleanup: 'settled' };
 }
+/** One verified bundle: a receipt short-circuits, a dry run stops after verification, otherwise the capture is promoted through the queue. */
+export async function importBundleEntry(store, root, namespace, entry, verify, dryRun, signal) {
+    const bundle = await inspectImportBundle(await importBundleRoot(root, entry), verify), sourceHash = hash(JSON.stringify([bundle.importHash, entry])), receipt = store.lookupImportReceipt(namespace, entry.id, sourceHash);
+    if (signal?.aborted)
+        throw Object.assign(Error('cancelled'), { code: 'cancelled' });
+    const base = { sourceHash, historicalIntegrity: bundle.historicalIntegrity };
+    if (receipt)
+        return { ...base, status: 'duplicate', itemId: receipt.itemId };
+    if (dryRun)
+        return { ...base, status: 'ready' };
+    const submission = store.submitSource({ kind: bundle.kind, sourceKey: hash(JSON.stringify([namespace, entry.id])), locator: bundle.sourceUrl, realm: 'import:' + namespace, idempotencyKey: 'import:' + hash(JSON.stringify([namespace, entry.id, sourceHash])), intent: 'refresh' });
+    const job = store.listJobs().find(row => row.id === submission.jobId);
+    if (job && ['failed', 'needs-auth', 'needs-permission', 'unsupported'].includes(String(job.state)))
+        store.retryJob(submission.jobId, { automatic: false });
+    const results = await drainQueue(store, { jobId: submission.jobId, signal, handlers: { [bundle.kind]: context => promote(context, bundle, namespace, entry, sourceHash) } });
+    const result = results[0];
+    if (!result || !result.ok)
+        throw Object.assign(Error(result && !result.ok ? result.code : 'integrity'), { code: result && !result.ok ? result.code : 'integrity' });
+    return { ...base, status: 'imported', itemId: submission.itemId };
+}
+/** The revision a bundle import committed: content-addressed by its source hash. */
+export const importBundleHash = (sourceHash) => hash(JSON.stringify(['wordcell-import-v1', sourceHash]));
 /** Additive bounded batches. Every applied entry is reverified; source bundles are read-only. */
 export async function importManifest(store, path, options) {
     const { root, manifest, sha256 } = await readImportManifest(path), limit = options.limit ?? 20, offset = options.offset ?? 0;
@@ -50,27 +72,8 @@ export async function importManifest(store, path, options) {
         if (options.signal?.aborted)
             throw Object.assign(Error('cancelled'), { code: 'cancelled' });
         try {
-            const bundle = await inspectImportBundle(await importBundleRoot(root, entry), verify), sourceHash = hash(JSON.stringify([bundle.importHash, entry])), receipt = store.lookupImportReceipt(manifest.namespace, entry.id, sourceHash);
-            if (options.signal?.aborted)
-                throw Object.assign(Error('cancelled'), { code: 'cancelled' });
-            const base = { id: entry.id, sourceHash, historicalIntegrity: bundle.historicalIntegrity, privacy: entry.privacy };
-            if (receipt) {
-                report.entries.push({ ...base, status: 'duplicate', itemId: receipt.itemId });
-                continue;
-            }
-            if (dryRun) {
-                report.entries.push({ ...base, status: 'ready' });
-                continue;
-            }
-            const submission = store.submitSource({ kind: bundle.kind, sourceKey: hash(JSON.stringify([manifest.namespace, entry.id])), locator: bundle.sourceUrl, realm: 'import:' + manifest.namespace, idempotencyKey: 'import:' + hash(JSON.stringify([manifest.namespace, entry.id, sourceHash])), intent: 'refresh' });
-            const job = store.listJobs().find(row => row.id === submission.jobId);
-            if (job && ['failed', 'needs-auth', 'needs-permission', 'unsupported'].includes(String(job.state)))
-                store.retryJob(submission.jobId, { automatic: false });
-            const results = await drainQueue(store, { jobId: submission.jobId, signal: options.signal, handlers: { [bundle.kind]: context => promote(context, bundle, manifest.namespace, entry, sourceHash) } });
-            const result = results[0];
-            if (!result || !result.ok)
-                throw Object.assign(Error(result && !result.ok ? result.code : 'integrity'), { code: result && !result.ok ? result.code : 'integrity' });
-            report.entries.push({ ...base, status: 'imported', itemId: submission.itemId });
+            const result = await importBundleEntry(store, root, manifest.namespace, entry, verify, dryRun, options.signal), base = { id: entry.id, sourceHash: result.sourceHash, historicalIntegrity: result.historicalIntegrity, privacy: entry.privacy };
+            report.entries.push({ ...base, status: result.status, ...(result.itemId ? { itemId: result.itemId } : {}) });
         }
         catch (error) {
             const code = errorCode(error);

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

@@ -0,0 +1,107 @@
+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 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; 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';
+    constructor(code: 'not-digest' | 'malformed' | 'no-capture');
+}
+export interface JungleQuote {
+    text: string;
+    attribution: string;
+    speaker: string;
+}
+export interface JungleNote {
+    slug: string;
+    title: string;
+    status: string;
+    sourceUrl: string;
+    authors: string[];
+    tags: string[];
+    capture?: string;
+    gist: string;
+    ideas: {
+        claim: string;
+        detail: string;
+    }[];
+    quotes: JungleQuote[];
+}
+/**
+ * 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;
+    /** 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;
+    }[];
+    /** 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, 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;
+};
+/** Capture Markdown without its YAML frontmatter: what a Sponge revision of the same page would hold. */
+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 limits.
+ * `capture` is the evidence the note is about: the first `synthesizes` relation, else the first `evidenced-by`.
+ */
+export interface JungleEditorial {
+    schemaVersion: 1;
+    source: 'jungle-reading';
+    form: string;
+    slug: string;
+    status: string;
+    title: string;
+    sourceUrl: string;
+    capture: string;
+    frontmatter: Yaml;
+    gist?: string;
+    ideas?: {
+        claim: string;
+        detail: string;
+    }[];
+    quotes?: JungleQuote[];
+    markdownSha256: string;
+    markdown: string;
+}
+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;
+/**
+ * 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;
+}[], 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), 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

@@ -0,0 +1,196 @@
+import { createHash } from 'node:crypto';
+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 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; 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); };
+/** 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();
+        }
+    } 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 = [];
+            while (i < lines.length && indent(lines[i]) === at && lines[i].trimStart().startsWith('- ')) {
+                const rest = lines[i].trimStart().slice(2);
+                if (/^[\w-]+:(\s|$)/.test(rest)) {
+                    lines[i] = ' '.repeat(at + 2) + rest;
+                    list.push(map(at + 2));
+                }
+                else {
+                    list.push(scalar(rest));
+                    i++;
+                }
+            }
+            return list;
+        }
+        return map(at);
+    };
+    const map = (at) => {
+        const out = {};
+        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]] = '';
+        }
+        return out;
+    };
+    const value = lines.length ? map(0) : {};
+    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();
+/** 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 };
+}
+/** Capture Markdown without its YAML frontmatter: what a Sponge revision of the same page would hold. */
+export function captureBody(capture) { return frontmatter(capture).body; }
+/** `## Heading` sections of a note body, trimmed. */
+function sectionsOf(body) {
+    const sections = new Map();
+    for (const part of body.split(/^## /m).slice(1)) {
+        const nl = part.indexOf('\n');
+        sections.set(part.slice(0, nl < 0 ? undefined : nl).trim(), nl < 0 ? '' : part.slice(nl + 1).trim());
+    }
+    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() }; });
+/** 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:'));
+    if (at < 1)
+        fail();
+    const text = lines.slice(0, at).join(' ').replace(/\s+/g, ' ').trim(), attribution = lines[at].slice('Attribution:'.length).trim();
+    return { text, attribution, speaker: attribution.split(/,|;|\s\(|\s—\s|\s-\s/)[0].trim() };
+});
+export function parseJungleNote(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');
+    const reading = meta.reading;
+    if (reading.form !== 'digest')
+        fail('not-digest');
+    const sections = sectionsOf(body);
+    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))
+        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 };
+}
+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');
+    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');
+    // 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');
+    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 };
+}
+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));
+}
+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); }
+/**
+ * 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';
+    if (note.tags.includes('x'))
+        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), 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), 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 = 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

@@ -0,0 +1,45 @@
+import type { DatabaseSync } from 'node:sqlite';
+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: "2";
+};
+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';
+export interface JungleNoteInput {
+    itemId: string;
+    revisionId: string;
+    editorial: JungleEditorial;
+    digest?: DigestV2;
+}
+export interface JunglePlan {
+    editorialId: string;
+    editorial: EditorialAction;
+    digestId?: string;
+    digest: DigestAction;
+    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;
+/**
+ * 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.
+ */
+export declare function visibilityAction(state: Pick<VisibilityState, 'access' | 'default' | 'override'>, status: string, userOverride: boolean): {
+    action: VisibilityAction;
+    target?: 'public' | 'private' | null;
+};
+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 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

@@ -0,0 +1,96 @@
+import { canonicalDigest, derivationId, putDigest, reviewDigest } from '../digest/store.js';
+import { canonicalEditorial, putEditorial, reviewEditorial } from '../digest/editorial.js';
+import { parseDigest } from '../digest/schema.js';
+import { visibility as visibilityState, setVisibility } from '../identity/visibility.js';
+import { digest } from '../store/files.js';
+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: '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. */
+export function desiredVisibility(status) { return status === 'published' ? 'public' : status === 'draft' ? 'private' : undefined; }
+/**
+ * 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.
+ */
+export function visibilityAction(state, status, userOverride) {
+    const desired = desiredVisibility(status);
+    if (!desired)
+        return { action: 'default-policy' };
+    if (userOverride)
+        return { action: 'kept-user-edit' };
+    if (desired === 'public' && state.access !== 'imported' && state.access !== 'public')
+        return { action: 'guarded' };
+    const target = desired === state.default ? null : desired;
+    if ((state.override ?? null) === target)
+        return { action: 'unchanged' };
+    return { action: target === null ? 'restore-default' : target === 'public' ? 'set-public' : 'set-private', target };
+}
+const allAccepted = (o) => ({ gist: 'accepted', ideas: o.ideas.map(() => 'accepted'), quotes: o.ideas.map(i => i.quotes.map(() => 'accepted')) });
+const imported = (r) => { try {
+    return JSON.parse(String(r.producer_json))?.importer === jungleProducer.importer;
+}
+catch {
+    return false;
+} };
+const latestVisibility = (db, itemId) => db.prepare("SELECT id FROM changes WHERE entity='item' AND entity_id=? AND field='visibility' ORDER BY seq DESC LIMIT 1").get(itemId);
+/** The latest logged visibility write was not this importer's: the user chose, even when the choice was `default`. */
+function userOverride(db, itemId) {
+    const latest = latestVisibility(db, itemId);
+    if (!latest)
+        return (db.prepare('SELECT visibility FROM items WHERE id=?').get(itemId)?.visibility ?? null) !== null;
+    return !db.prepare('SELECT 1 FROM import_receipts WHERE namespace=? AND source_key=? AND source_hash=?').get(visibilityReceipts, itemId, digest(String(latest.id)));
+}
+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';
+    // 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)))
+            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))))))
+            action = 'user-review-wins';
+        else
+            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, ...(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 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) {
+    const plan = planJungleNote(db, input), producer = { ...jungleProducer, note: input.editorial.slug };
+    if (plan.editorial !== 'unchanged') {
+        putEditorial(db, { itemId: input.itemId, revisionId: input.revisionId, producer, output: input.editorial });
+        if (plan.editorial === 'new')
+            reviewEditorial(db, plan.editorialId, 'accepted');
+    }
+    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) {
+        setVisibility(db, input.itemId, action.target);
+        const latest = latestVisibility(db, input.itemId);
+        db.prepare('INSERT OR IGNORE INTO import_receipts VALUES(?,?,?,?,?,?)').run(visibilityReceipts, input.itemId, digest(String(latest.id)), jungleProducer.version, input.itemId, 'visibility');
+    }
+    return plan;
+}