@hraness/sponge 0.2.6 → 0.3.0

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

@@ -6,28 +6,37 @@ 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 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;
     digest?: DigestV2;
+    firstNote?: boolean;
+    firstNoteUri?: string;
 }
 export interface JunglePlan {
     editorialId: string;
     editorial: EditorialAction;
     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.

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

@@ -1,18 +1,62 @@
-import { canonicalDigest, derivationId, putDigest, reviewDigest } from '../digest/store.js';
-import { canonicalEditorial, putEditorial, reviewEditorial } from '../digest/editorial.js';
+import { canonicalDigest } from '../digest/derivation.js';
+import { canonicalEditorial } from '../digest/editorial.js';
+import { derivationId, putDerivation, reviewDerivation } from '../store/derivations.js';
 import { parseDigest } from '../digest/schema.js';
-import { visibility as visibilityState, setVisibility } from '../identity/visibility.js';
-import { digest } from '../store/files.js';
+import { visibility as visibilityState, setVisibility, hasWebUri, metadataUri, setMetadataUri, } from '../identity/visibility.js';
+import { isCapabilityUrl } from '../identity/query-policy.js';
+import { isResolvable, maxUriBytes, shareableWebUri } from '../identity/uri.js';
+import { mutate } from '../store/changes.js';
+import { sha256 } from '../util/hash.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' };
+export const jungleNamespace = 'jungle', jungleRealm = 'import:jungle';
+const 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';
+/**
+ * The note's `reading.source_url` as a shareable URI: http(s) only, through the same derivation as a captured locator.
+ * A capability URL (query-policy.ts) is refused outright, so its stripped form never becomes a public address either.
+ */
+function noteUri(sourceUrl) {
+    if (!/^https?:\/\//i.test(sourceUrl))
+        return { refused: 'no-source-url' };
+    if (isCapabilityUrl(sourceUrl))
+        return { refused: 'capability' };
+    let uri;
+    try {
+        uri = shareableWebUri(sourceUrl);
+    }
+    catch {
+        return { refused: 'no-source-url' };
+    }
+    return Buffer.byteLength(uri) <= maxUriBytes && isResolvable(uri) && !isCapabilityUrl(uri)
+        ? { uri }
+        : { refused: 'no-source-url' };
+}
+/** What a local capture's URI action would be, before or after its item exists. */
+export function uriAction(local, firstNote, sourceUrl, recorded) {
+    if (!firstNote)
+        return { action: 'other-note' };
+    if (!local)
+        return { action: 'web-capture' };
+    const { uri, refused } = noteUri(sourceUrl);
+    return uri ? { action: uri === recorded ? 'unchanged' : 'new', uri } : { action: refused };
+}
+function titleAction(db, input) {
+    if (input.firstNote === false)
+        return 'other-note';
+    const title = input.editorial.title.trim(), item = db.prepare('SELECT title_note,title_override FROM items WHERE id=?').get(input.itemId);
+    if (item?.title_override !== null && item?.title_override !== undefined)
+        return 'kept-user-edit';
+    return !title || Buffer.byteLength(title) > 4096 || title === item?.title_note ? 'unchanged' : 'set';
+}
 /** 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; }
+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.
@@ -30,45 +74,73 @@ export function visibilityAction(state, status, userOverride) {
         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);
+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)));
+    return !db
+        .prepare('SELECT 1 FROM import_receipts WHERE namespace=? AND source_key=? AND source_hash=?')
+        .get(visibilityReceipts, itemId, sha256(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';
+    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;
+        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))
+        else if (digests.some((r) => r.id === digestId))
             action = 'unchanged';
-        else if (digests.some(r => !imported(r)))
+        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))))))
+        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 };
+    const local = !hasWebUri(db, itemId), uri = uriAction(local, input.firstNote !== false, editorial.sourceUrl, metadataUri(db, itemId));
+    const visibility = visibilityAction(visibilityState(db, itemId, uri.uri ?? (input.firstNote === false ? input.firstNoteUri : undefined) ?? metadataUri(db, itemId)), editorial.status, userOverride(db, itemId)).action;
+    return {
+        editorialId,
+        editorial: editorialAction,
+        ...(digestId ? { digestId } : {}),
+        digest: action,
+        uri: uri.action,
+        title: titleAction(db, input),
+        visibility,
+    };
 }
 /**
  * Apply one note; the caller holds the write transaction. A new editorial object is accepted through `review.note` unless
@@ -78,19 +150,41 @@ export function planJungleNote(db, input) {
 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 });
+        putDerivation(db, 'editorial', {
+            itemId: input.itemId,
+            revisionId: input.revisionId,
+            producer,
+            output: input.editorial,
+        });
         if (plan.editorial === 'new')
-            reviewEditorial(db, plan.editorialId, 'accepted');
+            reviewDerivation(db, 'editorial', plan.editorialId, 'accepted');
     }
+    // A local capture takes the note's web address and title before visibility is decided, so the published state applies to it.
+    if (plan.uri === 'new')
+        setMetadataUri(db, input.itemId, uriAction(true, true, input.editorial.sourceUrl).uri);
+    // The note's title is the item's default; a refresh changes only the captured title, and the user's override wins over both.
+    const title = input.editorial.title.trim();
+    if (input.firstNote !== false &&
+        title &&
+        Buffer.byteLength(title) <= 4096 &&
+        title !== db.prepare('SELECT title_note FROM items WHERE id=?').get(input.itemId)?.title_note)
+        mutate(db, 'item', input.itemId, 'noteTitle', title);
     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 stored = putDerivation(db, 'digest', {
+            itemId: input.itemId,
+            revisionId: input.revisionId,
+            producer: { ...producer, editorial: plan.editorialId },
+            inputHash: plan.editorialId,
+            output: input.digest,
+            options: { tags: jungleTags },
+        });
+        reviewDerivation(db, 'digest', 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');
+        db.prepare('INSERT OR IGNORE INTO import_receipts VALUES(?,?,?,?,?,?)').run(visibilityReceipts, input.itemId, sha256(String(latest.id)), jungleProducer.version, input.itemId, 'visibility');
     }
     return plan;
 }

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

@@ -1,13 +1,14 @@
 import type { LibraryStore } from '../store/index.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 QuoteDrop } from './jungle-digest.js';
+import { type DigestAction, type EditorialAction, type TitleAction, type UriAction, 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 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.
+ * overflowing quotes are dropped and reported); the note's title becomes the item's default title (a user override still wins), and a
+ * local capture (no web URI of its own) takes the note's `source_url`;
+ * `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;
@@ -16,16 +17,16 @@ export interface JungleImportOptions {
     offset?: number;
     signal?: AbortSignal;
 }
-export type JungleSkip = 'not-reading-note' | 'malformed-note' | 'no-capture' | 'capture-missing' | 'item-deleted' | 'capture-unsupported' | 'capture-failed';
+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 {
+interface JungleQuoteReport {
     assigned: number;
     dropped: {
         quote: number;
         reason: QuoteDrop;
     }[];
 }
-export interface JungleEntry {
+interface JungleEntry {
     slug: string;
     form?: string;
     status?: string;
@@ -35,11 +36,13 @@ export interface JungleEntry {
     digest?: DigestAction;
     digestIssues?: string[];
     quotes?: JungleQuoteReport;
+    uri?: UriAction;
+    title?: TitleAction;
     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`. */
+/** 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`. `uri` and `title` were added within schema 2. */
 export interface JungleImportReport {
     schemaVersion: 2;
     dryRun: boolean;
@@ -55,16 +58,13 @@ export interface JungleImportReport {
             assigned: number;
             dropped: Record<string, number>;
         };
+        uri: Record<string, number>;
+        title: Record<string, number>;
         visibility: Record<string, number>;
         skipped: Record<string, number>;
     };
     entries: JungleEntry[];
     nextOffset: number | null;
 }
-/** 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>;
+export {};

package/dist/src/importers/jungle.js

@@ -1,48 +1,107 @@
 import { readdir, realpath } from 'node:fs/promises';
 import { dirname, isAbsolute, join } from 'node:path';
-import { readConfined, hash } from '../acquisition/files.js';
+import { readConfined } from '../acquisition/files.js';
+import { sha256 as hash } from '../util/hash.js';
 import { object } from '../acquisition/normalize.js';
 import { localizeMarkdown } from '../app/markdown.js';
 import { checkDigest } from '../digest/schema.js';
 import { accessClass, defaultVisibility } from '../identity/uri.js';
-import { convertJungleDigest, parseJungleEditorial, jungleTags, JungleDigestError } from './jungle-digest.js';
-import { jungleNamespace, jungleRealm, visibilityAction } from './jungle-store.js';
+import { convertJungleDigest, parseJungleEditorial, jungleTags, } from './jungle-digest.js';
+import { jungleNamespace, jungleRealm, uriAction, visibilityAction, } from './jungle-store.js';
 import { importBundleEntry, importBundleHash } from './apply.js';
+import { SpongeError, codeOf } from '../errors.js';
 const noteBytes = 4 * 1024 ** 2, captureBytes = 16 * 1024 ** 2;
-const errorCode = (error) => String(error?.code ?? (error instanceof Error ? error.message : 'unclassified'));
+const errorCode = (error) => codeOf(error);
 /** 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; }
+function captureLink(link) {
+    if (isAbsolute(link) ||
+        link.includes('\\') ||
+        link.split('/').length < 2 ||
+        link.split('/').some((p) => !p || p === '.' || p === '..'))
+        throw new SpongeError('no-capture');
+    return link;
+}
 /** Digest v2 when the note converts and passes every rule against this revision's Markdown; otherwise the reasons. */
-export function jungleDigest(editorial, markdown) {
+function jungleDigest(editorial, markdown) {
     if (editorial.form !== 'digest')
         return { 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 }] : []) };
+    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) {
+    // An untrusted bundle fails as `integrity`, exactly as apply's `inspectImportBundle` reports it.
+    try {
+        return await previewBundle(kb, bundle, link);
+    }
+    catch (error) {
+        if (error instanceof SpongeError)
+            throw error;
+        throw new SpongeError('integrity', { cause: error });
+    }
+}
+async function previewBundle(kb, bundle, link) {
     const manifest = object(JSON.parse((await readConfined(kb, join(bundle, 'capture.json'), captureBytes)).toString('utf8'))), pdf = manifest.kind === 'pdf';
-    const listed = (pdf ? (Array.isArray(manifest.images) ? manifest.images.map(i => object(i).asset) : []) : Array.isArray(manifest.assets) ? manifest.assets : []).flatMap(raw => { const a = raw && typeof raw === 'object' ? raw : {}; return typeof a.path === 'string' && typeof a.sha256 === 'string' ? [{ relativePath: a.path, sha256: a.sha256, bytes: Number(a.bytes), mediaType: String(a.mimeType) }] : []; });
+    const listed = (pdf
+        ? Array.isArray(manifest.images)
+            ? manifest.images.map((i) => object(i).asset)
+            : []
+        : Array.isArray(manifest.assets)
+            ? manifest.assets
+            : []).flatMap((raw) => {
+        const a = raw && typeof raw === 'object' ? raw : {};
+        return typeof a.path === 'string' && typeof a.sha256 === 'string'
+            ? [{ relativePath: a.path, sha256: a.sha256, bytes: Number(a.bytes), mediaType: String(a.mimeType) }]
+            : [];
+    });
     const text = (await readConfined(kb, link + '.md', captureBytes)).toString('utf8'), markdown = localizeMarkdown(pdf ? text.replace(/^<!-- pdf-page: ([1-9][0-9]*) -->$/gm, '## Page $1') : text, listed).markdown;
     const locator = pdf ? String(object(manifest.source ?? {}).requestedUrl ?? '') : String(manifest.sourceUrl ?? '');
     return { markdown, locator };
 }
 export async function importJungle(store, jungle, options = {}) {
     if (!isAbsolute(jungle))
-        throw Object.assign(Error('invalid-input'), { code: 'invalid-input' });
-    const kb = await realpath(join(jungle, 'kb')), notesDir = join(kb, 'notes', 'reading'), files = (await readdir(notesDir)).filter(f => /^[a-z0-9][a-z0-9-]*\.md$/.test(f)).sort();
+        throw new SpongeError('invalid-input');
+    const kb = await realpath(join(jungle, 'kb')), notesDir = join(kb, 'notes', 'reading'), files = (await readdir(notesDir)).filter((f) => /^[a-z0-9][a-z0-9-]*\.md$/.test(f)).sort();
     const limit = options.limit ?? 1000, offset = options.offset ?? 0, dryRun = options.dryRun !== false;
-    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000 || !Number.isSafeInteger(offset) || offset < 0 || offset > files.length)
-        throw Object.assign(Error('invalid-input'), { code: 'invalid-input' });
+    if (!Number.isSafeInteger(limit) ||
+        limit < 1 ||
+        limit > 1000 ||
+        !Number.isSafeInteger(offset) ||
+        offset < 0 ||
+        offset > files.length)
+        throw new SpongeError('invalid-input');
     if (!dryRun && !options.verify)
-        throw Object.assign(Error('runtime-missing'), { code: 'runtime-missing' });
-    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();
+        throw new SpongeError('runtime-missing');
+    const report = {
+        schemaVersion: 2,
+        dryRun,
+        captureVerification: dryRun ? 'deferred' : 'verified',
+        notes: files.length,
+        counts: {
+            newItems: 0,
+            existingItems: 0,
+            editorial: {},
+            digest: {},
+            digestIssues: {},
+            quotes: { assigned: 0, dropped: {} },
+            uri: {},
+            title: {},
+            visibility: {},
+            skipped: {},
+        },
+        entries: [],
+        nextOffset: offset + limit < files.length ? offset + limit : null,
+    };
+    const bump = (m, k) => {
+        m[k] = (m[k] ?? 0) + 1;
+    }, seen = new Map();
     for (const file of files.slice(offset, offset + limit)) {
         if (options.signal?.aborted)
-            throw Object.assign(Error('cancelled'), { code: 'cancelled' });
+            throw new SpongeError('cancelled');
         const slug = file.slice(0, -3);
         let entry = { slug };
         try {
@@ -51,8 +110,9 @@ export async function importJungle(store, jungle, options = {}) {
                 editorial = parseJungleEditorial((await readConfined(notesDir, file, noteBytes)).toString('utf8'));
             }
             catch (error) {
-                const code = error instanceof JungleDigestError ? error.code : 'malformed';
-                entry.skipped = code === 'not-digest' ? 'not-reading-note' : code === 'no-capture' ? 'no-capture' : 'malformed-note';
+                const raw = codeOf(error), code = raw === 'not-digest' || raw === 'no-capture' ? raw : 'malformed';
+                entry.skipped =
+                    code === 'not-digest' ? 'not-reading-note' : code === 'no-capture' ? 'no-capture' : 'malformed-note';
                 throw entry;
             }
             entry = { slug, form: editorial.form, status: editorial.status };
@@ -72,23 +132,51 @@ export async function importJungle(store, jungle, options = {}) {
                 entry.skipped = 'capture-missing';
                 throw entry;
             }
-            const prior = store.importedItem(jungleRealm, hash(JSON.stringify([jungleNamespace, link])));
+            const prior = store.imports.item(jungleRealm, hash(JSON.stringify([jungleNamespace, link])));
             if (prior?.deleted) {
                 entry.skipped = 'item-deleted';
                 entry.itemId = prior.itemId;
                 throw entry;
             }
             // Two notes on one capture share its item, in a dry run too.
-            entry.item = prior || seen.has(link) ? 'existing' : 'new';
-            seen.add(link);
+            // The first note on a capture decides its default title and a local capture's URI; later notes see the URI it records.
+            const firstNote = !seen.has(link), firstNoteUri = seen.get(link);
+            entry.item = prior || !firstNote ? 'existing' : 'new';
+            if (firstNote)
+                seen.set(link, uriAction(true, true, editorial.sourceUrl).uri);
             if (dryRun) {
                 if (prior?.revisionId) {
-                    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 });
+                    const markdown = store.revisions.markdown(prior.revisionId), { digest, issues, quotes } = jungleDigest(editorial, markdown), plan = store.imports.planJungleNote({
+                        itemId: prior.itemId,
+                        revisionId: prior.revisionId,
+                        editorial,
+                        ...(digest ? { digest } : {}),
+                        firstNote,
+                        ...(firstNoteUri ? { firstNoteUri } : {}),
+                    });
+                    Object.assign(entry, {
+                        itemId: prior.itemId,
+                        editorial: plan.editorial,
+                        digest: plan.digest,
+                        ...(issues.length ? { digestIssues: issues } : {}),
+                        ...(quotes ? { quotes } : {}),
+                        uri: plan.uri,
+                        title: plan.title,
+                        visibility: plan.visibility,
+                    });
                 }
+                // A capture without a web locator is stored as a local file; predict the URI, title and access it would get.
                 else {
-                    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 });
+                    const preview = await previewCapture(kb, bundle, link), { digest, issues, quotes } = jungleDigest(editorial, preview.markdown), local = !/^https?:/i.test(preview.locator), uri = uriAction(local, firstNote, editorial.sourceUrl), access = accessClass(jungleRealm, local ? 'file:' : preview.locator, uri.uri ?? firstNoteUri), noteTitle = editorial.title.trim();
+                    Object.assign(entry, {
+                        editorial: 'new',
+                        digest: editorial.form !== 'digest' ? 'not-digest' : digest ? 'new' : 'not-convertible',
+                        ...(issues.length ? { digestIssues: issues } : {}),
+                        ...(quotes ? { quotes } : {}),
+                        uri: uri.action,
+                        title: !firstNote ? 'other-note' : noteTitle && Buffer.byteLength(noteTitle) <= 4096 ? 'set' : 'unchanged',
+                        visibility: visibilityAction({ access, default: defaultVisibility(access, 'private'), override: null }, editorial.status, false).action,
+                    });
                 }
             }
             else {
@@ -104,19 +192,36 @@ 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), { 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 });
+                const itemId = imported.itemId, revisionId = store.imports.revision(itemId, importBundleHash(imported.sourceHash)), markdown = store.revisions.markdown(revisionId), { digest, issues, quotes } = jungleDigest(editorial, markdown);
+                const plan = store.imports.applyJungleNote({
+                    itemId,
+                    revisionId,
+                    editorial,
+                    ...(digest ? { digest } : {}),
+                    firstNote,
+                });
+                Object.assign(entry, {
+                    itemId,
+                    editorial: plan.editorial,
+                    digest: plan.digest,
+                    ...(issues.length ? { digestIssues: issues } : {}),
+                    ...(quotes ? { quotes } : {}),
+                    uri: plan.uri,
+                    title: plan.title,
+                    visibility: plan.visibility,
+                });
             }
             bump(report.counts.editorial, entry.editorial);
             bump(report.counts.digest, entry.digest);
-            for (const i of new Set((entry.digestIssues ?? []).map(i => i.replace(/\.\d+/g, '.N'))))
+            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.uri, entry.uri);
+            bump(report.counts.title, entry.title);
             bump(report.counts.visibility, entry.visibility);
             if (entry.item === 'new')
                 report.counts.newItems++;