@hraness/sponge 0.2.6 → 0.3.1

package/dist/src/portability/gc.js

@@ -2,30 +2,64 @@ import { DatabaseSync } from 'node:sqlite';
 import { lstatSync, readdirSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { safeDirectory } from '../store/files.js';
-import { StoreError } from '../store/types.js';
-import { blobPath, describe, exact, fileDescriptor, invalid, bounded, maximumBlobBytes, maximumEntries, syncDirectory } from './files.js';
-function libraryId(store) { const db = new DatabaseSync(join(store.root, 'library.sqlite'), { readOnly: true }); try {
-    return String(db.prepare('SELECT uuid FROM library_info WHERE id=1').get()?.uuid);
+import { blobPath, describe, exact, fileDescriptor, invalid, bounded, maximumBlobBytes, maximumEntries, } from './files.js';
+import { syncDirectory } from '../util/fsync.js';
+import { SpongeError } from '../errors.js';
+function libraryId(store) {
+    const db = new DatabaseSync(join(store.root, 'library.sqlite'), { readOnly: true });
+    try {
+        return String(db.prepare('SELECT uuid FROM library_info WHERE id=1').get()?.uuid);
+    }
+    finally {
+        db.close();
+    }
+}
+function candidate(root, path) {
+    const absolute = join(root, path);
+    const record = describe(absolute, path, maximumBlobBytes);
+    if (path !== blobPath(record.sha256))
+        invalid();
+    const stat = lstatSync(absolute, { bigint: true });
+    return { ...record, device: Number(stat.dev), inode: Number(stat.ino), mtimeNs: String(stat.mtimeNs) };
 }
-finally {
-    db.close();
-} }
-function candidate(root, path) { const absolute = join(root, path); const record = describe(absolute, path, maximumBlobBytes); if (path !== blobPath(record.sha256))
-    invalid(); const stat = lstatSync(absolute, { bigint: true }); return { ...record, device: Number(stat.dev), inode: Number(stat.ino), mtimeNs: String(stat.mtimeNs) }; }
 function parseReport(value) {
     const r = exact(value, ['format', 'version', 'libraryId', 'revisionEpoch', 'createdAt', 'candidates']);
-    if (r.format !== 'sponge-gc' || r.version !== 1 || typeof r.libraryId !== 'string' || r.libraryId.length > 256 || typeof r.createdAt !== 'string' || !Number.isFinite(Date.parse(r.createdAt)) || !Array.isArray(r.candidates) || r.candidates.length > maximumEntries)
+    if (r.format !== 'sponge-gc' ||
+        r.version !== 1 ||
+        typeof r.libraryId !== 'string' ||
+        r.libraryId.length > 256 ||
+        typeof r.createdAt !== 'string' ||
+        !Number.isFinite(Date.parse(r.createdAt)) ||
+        !Array.isArray(r.candidates) ||
+        r.candidates.length > maximumEntries)
         invalid();
-    const candidates = r.candidates.map(value => { const row = exact(value, ['path', 'sha256', 'bytes', 'device', 'inode', 'mtimeNs']); const file = fileDescriptor({ path: row.path, sha256: row.sha256, bytes: row.bytes }); if (file.path === 'library.sqlite' || typeof row.mtimeNs !== 'string' || !/^\d{1,30}$/u.test(row.mtimeNs))
-        invalid(); return { ...file, device: bounded(row.device, Number.MAX_SAFE_INTEGER), inode: bounded(row.inode, Number.MAX_SAFE_INTEGER), mtimeNs: row.mtimeNs }; });
-    if (new Set(candidates.map(c => c.path)).size !== candidates.length)
+    const candidates = r.candidates.map((value) => {
+        const row = exact(value, ['path', 'sha256', 'bytes', 'device', 'inode', 'mtimeNs']);
+        const file = fileDescriptor({ path: row.path, sha256: row.sha256, bytes: row.bytes });
+        if (file.path === 'library.sqlite' || typeof row.mtimeNs !== 'string' || !/^\d{1,30}$/u.test(row.mtimeNs))
+            invalid();
+        return {
+            ...file,
+            device: bounded(row.device, Number.MAX_SAFE_INTEGER),
+            inode: bounded(row.inode, Number.MAX_SAFE_INTEGER),
+            mtimeNs: row.mtimeNs,
+        };
+    });
+    if (new Set(candidates.map((c) => c.path)).size !== candidates.length)
         invalid();
-    return { format: 'sponge-gc', version: 1, libraryId: r.libraryId, revisionEpoch: bounded(r.revisionEpoch, Number.MAX_SAFE_INTEGER), createdAt: r.createdAt, candidates };
+    return {
+        format: 'sponge-gc',
+        version: 1,
+        libraryId: r.libraryId,
+        revisionEpoch: bounded(r.revisionEpoch, Number.MAX_SAFE_INTEGER),
+        createdAt: r.createdAt,
+        candidates,
+    };
 }
 export function createGcReport(store) {
     const epoch = store.revisionEpoch;
-    return store.withGcFence(epoch, references => {
-        const known = new Set(references.map(r => r.relativePath)), candidates = [];
+    return store.blobs.withGcFence(epoch, (references) => {
+        const known = new Set(references.map((r) => r.relativePath)), candidates = [];
         const root = join(store.root, 'blobs', 'sha256');
         safeDirectory(root);
         let count = 0;
@@ -35,7 +69,7 @@ export function createGcReport(store) {
             safeDirectory(join(root, prefix));
             for (const sha of readdirSync(join(root, prefix)).sort()) {
                 if (++count > maximumEntries)
-                    throw new StoreError('limit-exceeded');
+                    throw new SpongeError('limit-exceeded');
                 if (!/^[a-f0-9]{64}$/u.test(sha) || !sha.startsWith(prefix))
                     invalid();
                 const path = blobPath(sha);
@@ -43,15 +77,24 @@ export function createGcReport(store) {
                     candidates.push(candidate(store.root, path));
             }
         }
-        return { format: 'sponge-gc', version: 1, libraryId: libraryId(store), revisionEpoch: epoch, createdAt: new Date().toISOString(), candidates };
+        return {
+            format: 'sponge-gc',
+            version: 1,
+            libraryId: libraryId(store),
+            revisionEpoch: epoch,
+            createdAt: new Date().toISOString(),
+            candidates,
+        };
     });
 }
 export function applyGcReport(store, value) {
     const report = parseReport(value);
-    if (report.libraryId !== libraryId(store) || Date.now() - Date.parse(report.createdAt) > 86400_000 || Date.parse(report.createdAt) > Date.now() + 1000)
-        throw new StoreError('invalid-input');
-    return store.withGcFence(report.revisionEpoch, references => {
-        const known = new Set(references.map(r => r.relativePath));
+    if (report.libraryId !== libraryId(store) ||
+        Date.now() - Date.parse(report.createdAt) > 86400_000 ||
+        Date.parse(report.createdAt) > Date.now() + 1000)
+        throw new SpongeError('invalid-input');
+    return store.blobs.withGcFence(report.revisionEpoch, (references) => {
+        const known = new Set(references.map((r) => r.relativePath));
         // Validate the entire report before any deletion. Changes invalidate, never broaden it.
         for (const entry of report.candidates) {
             if (known.has(entry.path) || JSON.stringify(candidate(store.root, entry.path)) !== JSON.stringify(entry))

package/dist/src/publish/component.js

@@ -84,7 +84,7 @@ export const componentSource = String.raw `/* sponge-list: renders a Sponge read
   if (typeof customElements !== 'undefined' && !customElements.get('sponge-list')) customElements.define('sponge-list', SpongeList);
 })();
 `;
-const html = (s) => s.replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
+const html = (s) => s.replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
 /** A complete static page around the component; it carries the feed title only. */
 export function indexHtml(title) {
     return `<!doctype html>

package/dist/src/publish/feed.d.ts

@@ -1,4 +1,4 @@
-import type { PublicEntry } from '../store/foundation.js';
+import type { PublicEntry } from './projection.js';
 /** feed.json and feed.xml carry the newest entries; every entry also lives in its month's shard. */
 export declare const feedLimit = 100;
 export declare const manifestPath = "index.json", signaturePath = "index.json.sig";
@@ -12,7 +12,7 @@ export interface SiteOptions {
     baseUrl?: string;
 }
 /** Sorted keys, no whitespace, undefined fields dropped: equal values always give equal bytes. */
-export declare function canonical(value: unknown): string;
+export declare const canonical: (value: unknown) => string;
 /** An https origin and path, with no credentials, query or fragment, ending in `/`. */
 export declare function baseUrl(value: string): string;
 /** XML 1.0 text and attribute escaping; characters XML cannot carry become U+FFFD. */

package/dist/src/publish/feed.js

@@ -1,28 +1,25 @@
-import { createHash } from 'node:crypto';
-import { StoreError } from '../store/types.js';
+import { sha256 } from '../util/hash.js';
+import { canonicalJson } from '../util/canonical.js';
 import { componentSource, indexHtml } from './component.js';
+import { SpongeError } from '../errors.js';
 /** feed.json and feed.xml carry the newest entries; every entry also lives in its month's shard. */
 export const feedLimit = 100;
 export const manifestPath = 'index.json', signaturePath = 'index.json.sig';
 const about = 'https://github.com/hraness/sponge/blob/main/docs/decisions/publish-feed.md';
-const fail = (code = 'integrity') => { throw new StoreError(code); };
+const fail = (code = 'integrity') => {
+    throw new SpongeError(code);
+};
 /** Sorted keys, no whitespace, undefined fields dropped: equal values always give equal bytes. */
-export function canonical(value) {
-    if (Array.isArray(value))
-        return '[' + value.map(canonical).join(',') + ']';
-    if (value && typeof value === 'object')
-        return '{' + Object.keys(value).sort().filter(k => value[k] !== undefined).map(k => JSON.stringify(k) + ':' + canonical(value[k])).join(',') + '}';
-    if (typeof value === 'number' && !Number.isSafeInteger(value) || !['string', 'number', 'boolean'].includes(typeof value) && value !== null)
-        fail();
-    return JSON.stringify(value);
-}
+export const canonical = (value) => canonicalJson(value, fail);
 /** An https origin and path, with no credentials, query or fragment, ending in `/`. */
 export function baseUrl(value) {
     let url;
     try {
         url = new URL(value);
     }
-    catch { /* rejected below */ }
+    catch {
+        /* rejected below */
+    }
     if (!url || url.protocol !== 'https:' || url.username || url.password || /[?#]/.test(value) || value.length > 2048)
         fail('invalid-input');
     return url.href.endsWith('/') ? url.href : url.href + '/';
@@ -31,17 +28,42 @@ const web = (uri) => /^https?:\/\//.test(uri);
 const xmlInvalid = /[^\t\n\r -퟿-�\u{10000}-\u{10ffff}]/gu;
 const xmlEntities = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' };
 /** XML 1.0 text and attribute escaping; characters XML cannot carry become U+FFFD. */
-export function xml(value) { return value.replace(xmlInvalid, '�').replace(/[&<>"']/g, c => xmlEntities[c]); }
-const date = (e) => /^\d{4}-\d{2}-\d{2}$/.test(e.listedOn) ? e.listedOn + 'T00:00:00Z' : fail();
-const summaryText = (e) => [e.digest?.lead, ...(e.digest?.ideas ?? []).map(i => '- ' + i.claim)].filter(Boolean).join('\n') || e.title;
+export function xml(value) {
+    return value.replace(xmlInvalid, '�').replace(/[&<>"']/g, (c) => xmlEntities[c]);
+}
+const date = (e) => (/^\d{4}-\d{2}-\d{2}$/.test(e.listedOn) ? e.listedOn + 'T00:00:00Z' : fail());
+const summaryText = (e) => [e.digest?.lead, ...(e.digest?.ideas ?? []).map((i) => '- ' + i.claim)].filter(Boolean).join('\n') || e.title;
 function item(e) {
-    return { id: e.uri, url: web(e.uri) ? e.uri : undefined, title: e.title, content_text: summaryText(e), summary: e.digest?.lead, date_published: date(e), authors: e.authors ? [{ name: e.authors }] : undefined,
-        _sponge: { uri: e.uri, aliases: e.aliases, kind: e.kind, site: e.site, published: e.published, digest: e.digest } };
+    return {
+        id: e.uri,
+        url: web(e.uri) ? e.uri : undefined,
+        title: e.title,
+        content_text: summaryText(e),
+        summary: e.digest?.lead,
+        date_published: date(e),
+        authors: e.authors ? [{ name: e.authors }] : undefined,
+        _sponge: { uri: e.uri, aliases: e.aliases, kind: e.kind, site: e.site, published: e.published, digest: e.digest },
+    };
 }
 function atom(entries, identity, options) {
-    const base = options.baseUrl, updated = entries.length ? date(entries.reduce((a, b) => b.listedOn > a.listedOn ? b : a)) : identity.created + 'T00:00:00Z';
-    const lines = ['<?xml version="1.0" encoding="utf-8"?>', '<feed xmlns="http://www.w3.org/2005/Atom">', `<id>tag:sponge.computer,2026:feed/${xml(identity.publicKey)}</id>`, `<title>${xml(options.title)}</title>`, `<updated>${updated}</updated>`, `<author><name>${xml(options.title)}</name></author>`, '<generator>Sponge</generator>',
-        ...(base ? [`<link rel="self" type="application/atom+xml" href="${xml(base + 'feed.xml')}"/>`, `<link rel="alternate" type="text/html" href="${xml(base)}"/>`] : [])];
+    const base = options.baseUrl, updated = entries.length
+        ? date(entries.reduce((a, b) => (b.listedOn > a.listedOn ? b : a)))
+        : identity.created + 'T00:00:00Z';
+    const lines = [
+        '<?xml version="1.0" encoding="utf-8"?>',
+        '<feed xmlns="http://www.w3.org/2005/Atom">',
+        `<id>tag:sponge.computer,2026:feed/${xml(identity.publicKey)}</id>`,
+        `<title>${xml(options.title)}</title>`,
+        `<updated>${updated}</updated>`,
+        `<author><name>${xml(options.title)}</name></author>`,
+        '<generator>Sponge</generator>',
+        ...(base
+            ? [
+                `<link rel="self" type="application/atom+xml" href="${xml(base + 'feed.xml')}"/>`,
+                `<link rel="alternate" type="text/html" href="${xml(base)}"/>`,
+            ]
+            : []),
+    ];
     for (const e of entries)
         lines.push('<entry>', `<id>${xml(e.uri)}</id>`, `<title>${xml(e.title)}</title>`, ...(web(e.uri) ? [`<link rel="alternate" href="${xml(e.uri)}"/>`] : []), `<updated>${date(e)}</updated>`, ...(e.authors ? [`<author><name>${xml(e.authors)}</name></author>`] : []), ...(e.digest?.lead ? [`<summary>${xml(e.digest.lead)}</summary>`] : []), `<content type="text">${xml(summaryText(e))}</content>`, '</entry>');
     return lines.concat('</feed>', '').join('\n');
@@ -51,27 +73,51 @@ function atom(entries, identity, options) {
  * no clock, no randomness, sorted keys. The manifest lists each file's sha256 and is signed once.
  */
 export function buildSite(entries, identity, options, sign) {
-    if (identity.algorithm !== 'Ed25519' || !/^[A-Za-z0-9_-]{43}$/.test(identity.publicKey) || !/^\d{4}-\d{2}-\d{2}$/.test(identity.created))
+    if (identity.algorithm !== 'Ed25519' ||
+        !/^[A-Za-z0-9_-]{43}$/.test(identity.publicKey) ||
+        !/^\d{4}-\d{2}-\d{2}$/.test(identity.created))
         fail();
-    const base = options.baseUrl, link = (from, to) => base ? base + to : from.includes('/') && to.startsWith(from.slice(0, from.lastIndexOf('/') + 1)) ? to.slice(from.lastIndexOf('/') + 1) : to;
+    const base = options.baseUrl, link = (from, to) => base
+        ? base + to
+        : from.includes('/') && to.startsWith(from.slice(0, from.lastIndexOf('/') + 1))
+            ? to.slice(from.lastIndexOf('/') + 1)
+            : to;
     const months = new Map();
     for (const e of entries) {
         const month = date(e).slice(0, 7);
-        months.set(month, [...months.get(month) ?? [], e]);
+        months.set(month, [...(months.get(month) ?? []), e]);
     }
     const order = [...months.keys()].sort().reverse(), shard = (month) => `items/${month}.json`;
     const signed = { about, schemaVersion: 1, algorithm: identity.algorithm, publicKey: identity.publicKey };
-    const feed = (path, list, next, extra) => Buffer.from(canonical({ version: 'https://jsonfeed.org/version/1.1', title: options.title, home_page_url: base, feed_url: base && base + path, next_url: next && link(path, next), items: list.map(item), _sponge: { ...signed, manifest: link(path, manifestPath), ...extra } }) + '\n');
+    const feed = (path, list, next, extra) => Buffer.from(canonical({
+        version: 'https://jsonfeed.org/version/1.1',
+        title: options.title,
+        home_page_url: base,
+        feed_url: base && base + path,
+        next_url: next && link(path, next),
+        items: list.map(item),
+        _sponge: { ...signed, manifest: link(path, manifestPath), ...extra },
+    }) + '\n');
     const files = new Map(), head = entries.slice(0, feedLimit), omitted = entries[feedLimit];
-    files.set('feed.json', feed('feed.json', head, omitted && shard(date(omitted).slice(0, 7)), { total: entries.length, shards: order.map(m => ({ month: m, url: link('feed.json', shard(m)), items: months.get(m).length })) }));
+    files.set('feed.json', feed('feed.json', head, omitted && shard(date(omitted).slice(0, 7)), {
+        total: entries.length,
+        shards: order.map((m) => ({ month: m, url: link('feed.json', shard(m)), items: months.get(m).length })),
+    }));
     order.forEach((m, i) => files.set(shard(m), feed(shard(m), months.get(m), order[i + 1] && shard(order[i + 1]), { month: m })));
     files.set('feed.xml', Buffer.from(atom(head, identity, options)));
-    files.set('identity.json', Buffer.from(canonical({ schemaVersion: 1, algorithm: identity.algorithm, publicKey: identity.publicKey, created: identity.created }) + '\n'));
+    files.set('identity.json', Buffer.from(canonical({
+        schemaVersion: 1,
+        algorithm: identity.algorithm,
+        publicKey: identity.publicKey,
+        created: identity.created,
+    }) + '\n'));
     files.set('sponge-list.js', Buffer.from(componentSource));
     files.set('index.html', Buffer.from(indexHtml(options.title)));
-    const listed = [...files.keys()].sort().map(path => ({ path, bytes: files.get(path).length, sha256: createHash('sha256').update(files.get(path)).digest('hex') }));
+    const listed = [...files.keys()]
+        .sort()
+        .map((path) => ({ path, bytes: files.get(path).length, sha256: sha256(files.get(path)) }));
     const manifest = Buffer.from(canonical({ ...signed, files: listed }) + '\n');
     files.set(manifestPath, manifest);
     files.set(signaturePath, Buffer.from(Buffer.from(sign(manifest)).toString('base64url') + '\n'));
-    return new Map([...files.entries()].sort(([a], [b]) => a < b ? -1 : 1));
+    return new Map([...files.entries()].sort(([a], [b]) => (a < b ? -1 : 1)));
 }

package/dist/src/publish/identity.d.ts

@@ -2,5 +2,9 @@ import type { PublicIdentity } from './feed.js';
 export interface Identity extends PublicIdentity {
     sign(bytes: Uint8Array): Buffer;
 }
-/** The publishing key never leaves the library: `keys/publish-ed25519.json`, mode 0600 inside a 0700 directory. */
+/** Library-relative key path. Backups carry it as a typed entry; item exports never do. */
+export declare const publishKeyPath = "keys/publish-ed25519.json", maximumPublishKeyBytes = 4096;
+/** The publishing key never leaves the library (except inside a private backup): `keys/publish-ed25519.json`, mode 0600 inside a 0700 directory. */
 export declare function publishIdentity(root: string): Identity;
+/** Load and verify an existing key without creating one. */
+export declare function loadPublishKey(path: string): Identity;

package/dist/src/publish/identity.js

@@ -1,24 +1,34 @@
-import { chmodSync, closeSync, constants, fstatSync, fsyncSync, linkSync, openSync, readFileSync, unlinkSync } from 'node:fs';
+import { chmodSync, closeSync, constants, fstatSync, fsyncSync, linkSync, openSync, readFileSync, unlinkSync, } from 'node:fs';
 import { createPrivateKey, createPublicKey, generateKeyPairSync, randomUUID, sign } from 'node:crypto';
 import { join } from 'node:path';
-import { pathExists, regularFile, safeDirectory, syncDirectory } from '../store/files.js';
-import { StoreError } from '../store/types.js';
+import { pathExists, regularFile, safeDirectory } from '../store/files.js';
+import { syncDirectory } from '../util/fsync.js';
 import { writeAll } from '../portability/files.js';
-const fail = () => { throw new StoreError('integrity'); };
+import { SpongeError } from '../errors.js';
+const fail = () => {
+    throw new SpongeError('integrity');
+};
 const b64 = (v, n) => typeof v === 'string' && new RegExp(`^[A-Za-z0-9_-]{${n}}$`).test(v) ? v : fail();
-/** The publishing key never leaves the library: `keys/publish-ed25519.json`, mode 0600 inside a 0700 directory. */
+/** Library-relative key path. Backups carry it as a typed entry; item exports never do. */
+export const publishKeyPath = 'keys/publish-ed25519.json', maximumPublishKeyBytes = 4096;
+/** The publishing key never leaves the library (except inside a private backup): `keys/publish-ed25519.json`, mode 0600 inside a 0700 directory. */
 export function publishIdentity(root) {
     const dir = safeDirectory(join(root, 'keys'), true);
     chmodSync(dir, 0o700);
     const path = join(dir, 'publish-ed25519.json');
     if (!pathExists(path))
         create(dir, path);
-    return load(path);
+    return loadPublishKey(path);
 }
 /** Write a temporary file, then hard-link it into place, so a concurrent first publish keeps one key. */
 function create(dir, path) {
     const jwk = generateKeyPairSync('ed25519').privateKey.export({ format: 'jwk' });
-    const body = JSON.stringify({ schemaVersion: 1, algorithm: 'Ed25519', created: new Date().toISOString().slice(0, 10), privateKey: { kty: jwk.kty, crv: jwk.crv, x: jwk.x, d: jwk.d } }) + '\n';
+    const body = JSON.stringify({
+        schemaVersion: 1,
+        algorithm: 'Ed25519',
+        created: new Date().toISOString().slice(0, 10),
+        privateKey: { kty: jwk.kty, crv: jwk.crv, x: jwk.x, d: jwk.d },
+    }) + '\n';
     const temp = join(dir, randomUUID() + '.tmp'), fd = openSync(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
     try {
         writeAll(fd, Buffer.from(body));
@@ -39,13 +49,17 @@ function create(dir, path) {
     unlinkSync(temp);
     syncDirectory(dir);
 }
-function load(path) {
+/** Load and verify an existing key without creating one. */
+export function loadPublishKey(path) {
     regularFile(path);
     const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     let raw;
     try {
         const stat = fstatSync(fd);
-        if (!stat.isFile() || (stat.mode & 0o777) !== 0o600 || stat.size > 4096 || stat.uid !== process.getuid?.())
+        if (!stat.isFile() ||
+            (stat.mode & 0o777) !== 0o600 ||
+            stat.size > maximumPublishKeyBytes ||
+            stat.uid !== process.getuid?.())
             fail();
         raw = readFileSync(fd, 'utf8');
     }
@@ -59,10 +73,16 @@ function load(path) {
     catch {
         fail();
     }
-    if (!value || value.schemaVersion !== 1 || value.algorithm !== 'Ed25519' || typeof value.created !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value.created) || value.privateKey?.kty !== 'OKP' || value.privateKey?.crv !== 'Ed25519')
+    if (!value ||
+        value.schemaVersion !== 1 ||
+        value.algorithm !== 'Ed25519' ||
+        typeof value.created !== 'string' ||
+        !/^\d{4}-\d{2}-\d{2}$/.test(value.created) ||
+        value.privateKey?.kty !== 'OKP' ||
+        value.privateKey?.crv !== 'Ed25519')
         fail();
     const x = b64(value.privateKey.x, 43), key = createPrivateKey({ key: { kty: 'OKP', crv: 'Ed25519', x, d: b64(value.privateKey.d, 43) }, format: 'jwk' });
     if (createPublicKey(key).export({ format: 'jwk' }).x !== x)
         fail();
-    return { algorithm: 'Ed25519', created: value.created, publicKey: x, sign: bytes => sign(null, bytes, key) };
+    return { algorithm: 'Ed25519', created: value.created, publicKey: x, sign: (bytes) => sign(null, bytes, key) };
 }

package/dist/src/publish/index.d.ts

@@ -1,6 +1,5 @@
-import type { PublicEntry } from '../store/foundation.js';
-export { buildSite, canonical, xml, feedLimit } from './feed.js';
-export declare const publishMarker = ".sponge-publish", markerBody = "sponge-publish-v1\n";
+import type { PublicEntry } from './projection.js';
+export declare const publishMarker = ".sponge-publish";
 export interface PublishOptions {
     output: string;
     title?: string;

package/dist/src/publish/index.js

@@ -1,14 +1,18 @@
-import { closeSync, constants, fsyncSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { closeSync, constants, fsyncSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync, } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { basename, dirname, isAbsolute, join, parse, relative, resolve, sep } from 'node:path';
-import { digest, pathExists, regularFile, safeDirectory, syncDirectory, verifyFile } from '../store/files.js';
-import { StoreError } from '../store/types.js';
+import { pathExists, regularFile, safeDirectory, verifyFile } from '../store/files.js';
+import { sha256 } from '../util/hash.js';
+import { syncDirectory } from '../util/fsync.js';
 import { writeAll } from '../portability/files.js';
 import { baseUrl, buildSite, manifestPath, signaturePath } from './feed.js';
 import { publishIdentity } from './identity.js';
-export { buildSite, canonical, xml, feedLimit } from './feed.js';
-export const publishMarker = '.sponge-publish', markerBody = 'sponge-publish-v1\n';
-const fail = (code = 'invalid-input') => { throw new StoreError(code); };
+import { SpongeError } from '../errors.js';
+export const publishMarker = '.sponge-publish';
+const markerBody = 'sponge-publish-v1\n';
+const fail = (code = 'invalid-input') => {
+    throw new SpongeError(code);
+};
 /** Drop entries listed fewer than `days` days ago, so listing dates do not reveal what is read right now. */
 export function minAge(entries, days = 0, now = new Date()) {
     if (!Number.isSafeInteger(days) || days < 0 || days > 3650)
@@ -16,7 +20,7 @@ export function minAge(entries, days = 0, now = new Date()) {
     if (!days)
         return entries;
     const cutoff = new Date(now.getTime() - days * 86_400_000).toISOString().slice(0, 10);
-    return entries.filter(e => e.listedOn <= cutoff);
+    return entries.filter((e) => e.listedOn <= cutoff);
 }
 /** Files a previous publish wrote, or a refusal: an unmarked directory or unlisted files are not ours to replace. */
 function previousOutput(target, stat) {
@@ -26,27 +30,29 @@ function previousOutput(target, stat) {
     if (!pathExists(marker))
         fail();
     regularFile(marker);
-    verifyFile(marker, digest(markerBody), Buffer.byteLength(markerBody));
+    verifyFile(marker, sha256(markerBody), Buffer.byteLength(markerBody));
     let listed;
     try {
         const manifest = join(target, manifestPath);
         regularFile(manifest);
-        listed = new Set(JSON.parse(readFileSync(manifest, 'utf8')).files.map(f => f.path));
+        listed = new Set(JSON.parse(readFileSync(manifest, 'utf8')).files.map((f) => f.path));
     }
     catch {
         return fail();
     }
     for (const path of [manifestPath, signaturePath, publishMarker])
         listed.add(path);
-    const walk = (dir) => { for (const name of readdirSync(dir)) {
-        const path = join(dir, name), s = lstatSync(path), rel = relative(target, path).split(sep).join('/');
-        if (s.isSymbolicLink())
-            fail('integrity');
-        if (s.isDirectory())
-            walk(path);
-        else if (!s.isFile() || !listed.has(rel))
-            fail();
-    } };
+    const walk = (dir) => {
+        for (const name of readdirSync(dir)) {
+            const path = join(dir, name), s = lstatSync(path), rel = relative(target, path).split(sep).join('/');
+            if (s.isSymbolicLink())
+                fail('integrity');
+            if (s.isDirectory())
+                walk(path);
+            else if (!s.isFile() || !listed.has(rel))
+                fail();
+        }
+    };
     walk(target);
 }
 function writeTree(root, files) {
@@ -88,7 +94,7 @@ export function publishSite(source, options) {
         throw error;
     }
     const target = join(parent, basename(output)), library = safeDirectory(source.root), inside = relative(library, target);
-    if (!inside || !inside.startsWith('..') && !isAbsolute(inside) || !relative(target, library).startsWith('..'))
+    if (!inside || (!inside.startsWith('..') && !isAbsolute(inside)) || !relative(target, library).startsWith('..'))
         fail();
     const title = options.title ?? 'Reading list';
     if (!title.trim() || title.length > 200 || /[\u0000-\u001f\u007f]/.test(title))
@@ -105,7 +111,7 @@ export function publishSite(source, options) {
     if (previous)
         previousOutput(target, previous);
     const projection = source.publicProjection(), entries = minAge(projection.entries, options.minAgeDays, options.now), identity = publishIdentity(library);
-    const files = buildSite(entries, identity, { title, ...(base ? { baseUrl: base } : {}) }, bytes => identity.sign(bytes));
+    const files = buildSite(entries, identity, { title, ...(base ? { baseUrl: base } : {}) }, (bytes) => identity.sign(bytes));
     const id = randomUUID(), temp = join(parent, `.${basename(target)}.${id}.tmp`);
     try {
         writeTree(temp, files);
@@ -133,5 +139,12 @@ export function publishSite(source, options) {
     else
         renameSync(temp, target);
     syncDirectory(parent);
-    return { output: target, entries: entries.length, held: projection.entries.length - entries.length, skipped: projection.skipped.length, files: files.size, publicKey: identity.publicKey };
+    return {
+        output: target,
+        entries: entries.length,
+        held: projection.entries.length - entries.length,
+        skipped: projection.skipped.length,
+        files: files.size,
+        publicKey: identity.publicKey,
+    };
 }

package/dist/src/publish/projection.d.ts

@@ -1,4 +1,5 @@
 import type { DatabaseSync } from 'node:sqlite';
+import type { PublicDigest } from '../derivations/types.js';
 /** One public list entry. Metadata only: no captured text, paths, account realms or local fingerprints. */
 export interface PublicEntry {
     uri: string;
@@ -9,15 +10,7 @@ export interface PublicEntry {
     published?: string;
     site?: string;
     listedOn: string;
-    digest?: {
-        lead?: string;
-        ideas: {
-            claim: string;
-            detail: string;
-            kind?: string;
-            quotes: string[];
-        }[];
-    };
+    digest?: PublicDigest;
 }
 /** What `sponge publish` would publish now, newest first. Items without a resolvable URI are listed as skipped. */
 export declare function publicProjection(db: DatabaseSync): {

package/dist/src/publish/projection.js

@@ -1,26 +1,23 @@
 import { itemUris, visibility } from '../identity/visibility.js';
-import { acceptedDigest, currentDigest } from '../digest/store.js';
-import { currentEditorial, publicEditorial } from '../digest/editorial.js';
+import { publicDerivation } from '../store/derivations.js';
 /** The first selected (or unmarked) claim among `fields`; string lists are joined. */
 function selectedClaim(db, revisionId, fields) {
     for (const field of fields) {
-        const r = db.prepare('SELECT value_json FROM metadata_claims WHERE revision_id=? AND field=? AND selected IS NOT 0 ORDER BY selected IS NOT 1,rowid LIMIT 1').get(revisionId, field);
-        const raw = r ? JSON.parse(String(r.value_json)) : undefined, v = Array.isArray(raw) && raw.every(x => typeof x === 'string') ? raw.join(', ') : raw;
+        const r = db
+            .prepare('SELECT value_json FROM metadata_claims WHERE revision_id=? AND field=? AND selected IS NOT 0 ORDER BY selected IS NOT 1,rowid LIMIT 1')
+            .get(revisionId, field);
+        const raw = r ? JSON.parse(String(r.value_json)) : undefined, v = Array.isArray(raw) && raw.every((x) => typeof x === 'string') ? raw.join(', ') : raw;
         if (typeof v === 'string' && v.trim() && v.length <= 1024)
             return v.trim();
     }
     return undefined;
 }
-/**
- * The public digest: the accepted fields of the current digest (v2, or a stored v1), else the public subset of an accepted
- * editorial note (lead, claims, verbatim quotes within the v2 limits). Never both, never attributions, and never the note's other content.
- */
-function publicDigest(db, id) { const d = currentDigest(db, id); if (d)
-    return acceptedDigest(d); const e = currentEditorial(db, id); return e && publicEditorial(db, e); }
 /** What `sponge publish` would publish now, newest first. Items without a resolvable URI are listed as skipped. */
 export function publicProjection(db) {
     const entries = [], skipped = [];
-    for (const item of db.prepare('SELECT id,kind,title,current_revision,created_at FROM items WHERE deleted_at IS NULL ORDER BY created_at DESC,id').all()) {
+    for (const item of db
+        .prepare('SELECT id,kind,title,current_revision,created_at FROM items WHERE deleted_at IS NULL ORDER BY created_at DESC,id')
+        .all()) {
         const id = String(item.id);
         if (visibility(db, id).effective !== 'public')
             continue;
@@ -28,16 +25,26 @@ export function publicProjection(db) {
             skipped.push({ itemId: id, reason: 'not-captured' });
             continue;
         }
-        const uris = itemUris(db, id).filter(u => u.resolvable), primary = uris.find(u => u.role === 'primary') ?? uris[0];
+        const uris = itemUris(db, id).filter((u) => u.resolvable), primary = uris.find((u) => u.role === 'primary') ?? uris[0];
         if (!primary) {
             skipped.push({ itemId: id, reason: 'no-public-uri' });
             continue;
         }
-        const revision = String(item.current_revision), authors = selectedClaim(db, revision, ['authors', 'author']), published = selectedClaim(db, revision, ['publishedAt', 'published']), accepted = publicDigest(db, id);
+        const revision = String(item.current_revision), authors = selectedClaim(db, revision, ['authors', 'author']), published = selectedClaim(db, revision, ['publishedAt', 'published']), accepted = publicDerivation(db, id);
         let site;
         if (/^https?:/.test(primary.uri))
             site = new URL(primary.uri).hostname.replace(/^www\./, '');
-        entries.push({ uri: primary.uri, aliases: uris.filter(u => u !== primary).map(u => u.uri), kind: String(item.kind), title: String(item.title), ...(authors ? { authors } : {}), ...(published ? { published } : {}), ...(site ? { site } : {}), listedOn: String(item.created_at).slice(0, 10), ...(accepted ? { digest: accepted } : {}) });
+        entries.push({
+            uri: primary.uri,
+            aliases: uris.filter((u) => u !== primary).map((u) => u.uri),
+            kind: String(item.kind),
+            title: String(item.title),
+            ...(authors ? { authors } : {}),
+            ...(published ? { published } : {}),
+            ...(site ? { site } : {}),
+            listedOn: String(item.created_at).slice(0, 10),
+            ...(accepted ? { digest: accepted } : {}),
+        });
     }
     return { entries, skipped };
 }

package/dist/src/search/extension.js

@@ -12,6 +12,8 @@ export function initializeVectorExtension(db) {
         try {
             db.enableLoadExtension(false);
         }
-        catch { /* Database created without extension support is already closed to loading. */ }
+        catch {
+            /* Database created without extension support is already closed to loading. */
+        }
     }
 }