@hraness/sponge 0.2.6 → 0.3.0

package/dist/src/cli/worker.js

@@ -3,9 +3,9 @@ import { inspectNative } from '../models/runtime.js';
 import { drainIndexQueue } from '../indexing/runner.js';
 import { drainLibrary } from '../worker/basic.js';
 import { recoverServiceLifetime } from '../service/lifetime.js';
-import { StoreError } from '../store/types.js';
 import { runWorkerService } from '../service/loop.js';
-import { installService, uninstallService, serviceStatus, installedServiceId, serviceEnvironment } from '../service/launch-agent.js';
+import { installService, uninstallService, serviceStatus, installedServiceId, serviceEnvironment, } from '../service/launch-agent.js';
+import { SpongeError, codeOf } from '../errors.js';
 export async function workerAction(store, action, version, environment, options = {}) {
     const env = environment ?? serviceEnvironment(version);
     if (action === 'install')
@@ -14,39 +14,74 @@ export async function workerAction(store, action, version, environment, options
         return uninstallService(store, env);
     return serviceStatus(store, env);
 }
+/** Doctor's read-only view of the background worker: never installs, repairs or signals anything. */
+export async function workerDoctor(store, version, environment) {
+    let env;
+    try {
+        env = environment ?? serviceEnvironment(version);
+    }
+    catch {
+        return { worker: 'unavailable' };
+    }
+    if (env.platform !== 'darwin')
+        return { worker: 'unsupported' };
+    try {
+        const s = await serviceStatus(store, env);
+        if (!s.installed)
+            return { worker: 'not-installed' };
+        const exit = s.lastExit === undefined ? {} : { lastExit: s.lastExit };
+        return s.stale
+            ? { worker: 'drift', drift: s.drift, repair: s.repair, ...exit }
+            : {
+                worker: s.loaded ? 'ready' : 'not-loaded',
+                ...exit,
+                ...(s.loaded ? {} : { repair: 'Run sponge worker install to load it again.' }),
+            };
+    }
+    catch (error) {
+        return { worker: codeOf(error, 'unavailable') };
+    }
+}
 /** Dispatch only work that claimNext can admit; delayed retries retain their due time. */
 export function hasDueAcquisition(store) {
     const now = new Date().toISOString();
-    return store.listJobs().some(job => job.operation !== 'index' && ['queued', 'delayed'].includes(String(job.state)) && job.cancel_requested !== 1 && (job.not_before === null || job.not_before === undefined || String(job.not_before) <= now));
+    return store.queue
+        .list()
+        .some((job) => job.operation !== 'index' &&
+        ['queued', 'delayed'].includes(String(job.state)) &&
+        job.cancel_requested !== 1 &&
+        (job.not_before === null || job.not_before === undefined || String(job.not_before) <= now));
 }
 export async function drainServiceQueues(store, options, version, signal) {
-    if (store.pendingCleanupCount())
-        throw Object.assign(Error('cleanup-required'), { code: 'cleanup-required' });
+    if (store.queue.pendingCleanup())
+        throw new SpongeError('cleanup-required');
     const results = [];
     let acquisitionError;
     if (hasDueAcquisition(store)) {
         try {
-            const runtime = options.runtime ?? await options.resolveCaptureRuntime?.();
+            const runtime = options.runtime ?? (await options.resolveCaptureRuntime?.());
             if (!runtime)
-                throw Object.assign(Error('runtime-missing'), { code: 'runtime-missing' });
+                throw new SpongeError('runtime-missing');
             let asrRuntime = options.asrRuntime;
             try {
                 asrRuntime ??= await inspectNative('asr', join(store.root, 'runtime', 'models'), version);
             }
             catch (error) {
-                if (!['runtime-missing', 'unsupported'].includes(String(error.code)))
+                if (!['runtime-missing', 'unsupported'].includes(codeOf(error)))
                     throw error;
             }
-            results.push(...await drainLibrary(store, { ...options, runtime, asrRuntime, signal, allowPrivateNetwork: false }));
+            results.push(...(await drainLibrary(store, { ...options, runtime, asrRuntime, signal, allowPrivateNetwork: false })));
         }
         catch (error) {
             acquisitionError = error;
         }
     }
     // A missing capture setup must not starve already queued, independently runnable indexes.
-    if (!signal.aborted && store.pendingCleanupCount() === 0 && store.listJobs().some(job => job.operation === 'index' && job.state === 'queued')) {
+    if (!signal.aborted &&
+        store.queue.pendingCleanup() === 0 &&
+        store.queue.list().some((job) => job.operation === 'index' && job.state === 'queued')) {
         const runtime = await inspectNative('embedding', join(store.root, 'runtime', 'models'), version);
-        results.push(...await drainIndexQueue(store, { runtime, signal }));
+        results.push(...(await drainIndexQueue(store, { runtime, signal })));
     }
     if (acquisitionError)
         throw acquisitionError;
@@ -55,8 +90,12 @@ export async function drainServiceQueues(store, options, version, signal) {
 export async function serveWorker(store, options, version, environment) {
     const env = environment ?? serviceEnvironment(version), installationId = installedServiceId(store, env);
     if (!options.signal)
-        throw Error('signal-required');
-    if (!await recoverServiceLifetime(store, installationId, env.alive))
-        throw new StoreError('owner-busy');
-    return runWorkerService(store, { installationId, signal: options.signal, drain: signal => drainServiceQueues(store, options, version, signal) });
+        throw new SpongeError('invalid-input');
+    if (!(await recoverServiceLifetime(store, installationId, env.alive)))
+        throw new SpongeError('owner-busy');
+    return runWorkerService(store, {
+        installationId,
+        signal: options.signal,
+        drain: (signal) => drainServiceQueues(store, options, version, signal),
+    });
 }

package/dist/src/derivations/kinds.d.ts

@@ -0,0 +1,34 @@
+import { type Derivation, type DigestCandidate, type DigestReview } from '../digest/derivation.js';
+import { type Editorial } from '../digest/editorial.js';
+import type { JungleEditorial } from '../importers/jungle-digest.js';
+import type { DerivationKind, ReviewStatus } from './types.js';
+/** The derivation-kind registry: the one place a kind name maps to its rules. Add a kind here and nowhere else. */
+export declare const derivationKinds: {
+    readonly digest: DerivationKind<"digest", import("../digest/schema.js").Digest, DigestReview, DigestReview, DigestCandidate>;
+    readonly editorial: DerivationKind<"editorial", JungleEditorial, {
+        note?: ReviewStatus;
+    }, ReviewStatus | null, {
+        output: JungleEditorial;
+    }>;
+};
+export type Kind = keyof typeof derivationKinds;
+/** Per kind: the stored derivation, what a review takes, and what storing takes besides item, revision and producer. */
+export interface KindTypes {
+    digest: {
+        derivation: Derivation;
+        review: DigestReview;
+        candidate: DigestCandidate;
+    };
+    editorial: {
+        derivation: Editorial;
+        review: ReviewStatus | null;
+        candidate: {
+            output: JungleEditorial;
+        };
+    };
+}
+export type DerivationOf<K extends Kind> = KindTypes[K]['derivation'];
+/** Publishing precedence: an item publishes from the first kind that has a current derivation, and never from two. */
+export declare const publishOrder: readonly Kind[];
+/** Dynamic dispatch on a stored kind name; an unknown kind is invalid input (it may arrive through the change log). */
+export declare function kindOf(name: unknown): DerivationKind<Kind, any, any, any, any>;

package/dist/src/derivations/kinds.js

@@ -0,0 +1,14 @@
+import { digestKind } from '../digest/derivation.js';
+import { editorialKind } from '../digest/editorial.js';
+import { SpongeError } from '../errors.js';
+/** The derivation-kind registry: the one place a kind name maps to its rules. Add a kind here and nowhere else. */
+export const derivationKinds = { digest: digestKind, editorial: editorialKind };
+/** Publishing precedence: an item publishes from the first kind that has a current derivation, and never from two. */
+export const publishOrder = ['digest', 'editorial'];
+const isKind = (value) => typeof value === 'string' && Object.hasOwn(derivationKinds, value);
+/** Dynamic dispatch on a stored kind name; an unknown kind is invalid input (it may arrive through the change log). */
+export function kindOf(name) {
+    if (!isKind(name))
+        throw new SpongeError('invalid-input');
+    return derivationKinds[name];
+}

package/dist/src/derivations/types.d.ts

@@ -0,0 +1,48 @@
+/** A review decision on one field of a derivation. Only accepted fields can ever be published. */
+export type ReviewStatus = 'accepted' | 'rejected';
+/** The public digest shape: what `sponge publish` may carry for an item. */
+export interface PublicDigest {
+    lead?: string;
+    ideas: {
+        claim: string;
+        detail: string;
+        kind?: string;
+        quotes: string[];
+    }[];
+}
+/** One stored derivation: immutable output addressed by content, plus its review (user state, written only through the change log). */
+export interface StoredDerivation<K extends string, Output, Review> {
+    id: string;
+    itemId: string;
+    revisionId: string;
+    kind: K;
+    producer: unknown;
+    inputHash: string;
+    output: Output;
+    review: Review;
+    createdAt: string;
+}
+/** What a kind admits for storage: canonical output JSON, the input hash it is addressed under, and the stored schema version. */
+interface Admitted {
+    output: string;
+    inputHash: string;
+    schemaVersion: number;
+}
+/**
+ * One derivation kind. The store owns the SQL; a kind owns its rules. Every place that stores, reviews, replays or publishes a
+ * derivation consults the kind registry (`kinds.ts`), never a kind name.
+ */
+export interface DerivationKind<K extends string, Output, Review, ReviewInput, Candidate> {
+    readonly kind: K;
+    /** The schema version new objects of this kind are written at. */
+    readonly schemaVersion: number;
+    /** Validate a candidate against the Markdown of the revision it derives from (read lazily), or throw. */
+    admit(candidate: Candidate, source: () => string): Admitted;
+    /** The review paths a review input sets, with their new values, validated against the stored derivation. */
+    reviewPaths(d: StoredDerivation<K, Output, Review>, input: ReviewInput): [path: string, value: ReviewStatus | null][];
+    /** Replay one logged review path onto the stored review: the change-log reducer, so it validates untrusted input. */
+    applyReview(review: Review, output: Output, path: string, value: ReviewStatus | null): Review;
+    /** The publishable subset, for kinds that publish. */
+    publish?(d: StoredDerivation<K, Output, Review>, source: () => string): PublicDigest | undefined;
+}
+export {};

package/dist/src/derivations/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/digest/derivation.d.ts

@@ -0,0 +1,25 @@
+import { type Digest, type DigestOptions } from './schema.js';
+import type { DerivationKind, PublicDigest, ReviewStatus, StoredDerivation } from '../derivations/types.js';
+/** Per-field review of a digest. Only accepted fields can ever be published. */
+export interface DigestReview {
+    gist?: ReviewStatus;
+    ideas?: (ReviewStatus | null)[];
+    quotes?: (ReviewStatus | null)[][];
+}
+export type Derivation = StoredDerivation<'digest', Digest, DigestReview>;
+/** What a digest is stored from: the producer's input hash, the model output, and the checker options it was drafted under. */
+export interface DigestCandidate {
+    inputHash: string;
+    output: unknown;
+    options?: DigestOptions;
+}
+/** A parsed digest serialized in fixed key order, so key order never makes a different object. Optional fields appear only when present. */
+export declare function canonicalDigest(d: Digest): string;
+/** The accepted subset of a digest (v1 or v2). Rejected or unreviewed fields never leave the device; v1 ideas keep their kind. */
+export declare function acceptedDigest(d: Derivation): PublicDigest | undefined;
+/**
+ * Digest: a draft is stored only when it is Digest v2 and every v2 rule passes against the revision it was made from.
+ * Stored v1 digests stay readable; new ones are v2. Each reviewed field is its own logged path: `review.gist`,
+ * `review.ideas.<i>`, `review.quotes.<i>.<j>`.
+ */
+export declare const digestKind: DerivationKind<'digest', Digest, DigestReview, DigestReview, DigestCandidate>;

package/dist/src/digest/derivation.js

@@ -0,0 +1,124 @@
+import { checkDigest, digestSchemaVersion, parseDigest } from './schema.js';
+import { hash } from '../store/files.js';
+import { SpongeError } from '../errors.js';
+const fail = () => {
+    throw new SpongeError('invalid-input');
+};
+/** A parsed digest serialized in fixed key order, so key order never makes a different object. Optional fields appear only when present. */
+export function canonicalDigest(d) {
+    return JSON.stringify({
+        schemaVersion: d.schemaVersion,
+        form: d.form,
+        gist: { lead: d.gist.lead, ...(d.gist.context !== undefined ? { context: d.gist.context } : {}) },
+        ideas: d.ideas.map((i) => ({
+            claim: i.claim,
+            detail: i.detail,
+            ...(i.kind !== undefined ? { kind: i.kind } : {}),
+            ...(i.voice
+                ? { voice: i.voice.type === 'author' ? { type: 'author' } : { type: i.voice.type, name: i.voice.name } }
+                : {}),
+            quotes: i.quotes.map((q) => ({
+                text: q.text,
+                ...(q.speaker !== undefined ? { speaker: q.speaker } : {}),
+                ...(q.attribution !== undefined ? { attribution: q.attribution } : {}),
+                ...(q.locator
+                    ? {
+                        locator: q.locator.type === 'timestamp'
+                            ? { type: 'timestamp', ms: q.locator.ms }
+                            : { type: 'page', page: q.locator.page },
+                    }
+                    : {}),
+            })),
+        })),
+        tags: [...d.tags],
+    });
+}
+/** The accepted subset of a digest (v1 or v2). Rejected or unreviewed fields never leave the device; v1 ideas keep their kind. */
+export function acceptedDigest(d) {
+    const ideas = d.output.ideas.flatMap((idea, i) => d.review.ideas?.[i] === 'accepted'
+        ? [
+            {
+                claim: idea.claim,
+                detail: idea.detail,
+                ...(idea.kind !== undefined ? { kind: idea.kind } : {}),
+                quotes: idea.quotes.filter((_, j) => d.review.quotes?.[i]?.[j] === 'accepted').map((q) => q.text),
+            },
+        ]
+        : []);
+    const lead = d.review.gist === 'accepted' ? d.output.gist.lead : undefined;
+    return lead || ideas.length ? { ...(lead ? { lead } : {}), ideas } : undefined;
+}
+const status = (v) => v === null || v === 'accepted' || v === 'rejected';
+/**
+ * Digest: a draft is stored only when it is Digest v2 and every v2 rule passes against the revision it was made from.
+ * Stored v1 digests stay readable; new ones are v2. Each reviewed field is its own logged path: `review.gist`,
+ * `review.ideas.<i>`, `review.quotes.<i>.<j>`.
+ */
+export const digestKind = {
+    kind: 'digest',
+    schemaVersion: digestSchemaVersion,
+    admit(candidate, source) {
+        hash(candidate.inputHash);
+        const parsed = parseDigest(candidate.output);
+        if (!parsed.digest)
+            throw new SpongeError('invalid-input', { issues: parsed.issues });
+        if (parsed.digest.schemaVersion !== digestSchemaVersion)
+            throw new SpongeError('invalid-input', { issues: [{ path: 'schemaVersion', code: 'superseded' }] });
+        const check = checkDigest(parsed.digest, source(), candidate.options);
+        if (!check.ok)
+            throw new SpongeError('invalid-input', { issues: check.issues });
+        const output = canonicalDigest(parsed.digest);
+        if (Buffer.byteLength(output) > 65536)
+            fail();
+        return { output, inputHash: candidate.inputHash, schemaVersion: parsed.digest.schemaVersion };
+    },
+    reviewPaths(d, review) {
+        if (typeof review !== 'object' ||
+            review === null ||
+            Object.keys(review).some((k) => !['gist', 'ideas', 'quotes'].includes(k)))
+            fail();
+        if (review.gist !== undefined && review.gist !== 'accepted' && review.gist !== 'rejected')
+            fail();
+        if (review.ideas !== undefined &&
+            (!Array.isArray(review.ideas) || review.ideas.length !== d.output.ideas.length || !review.ideas.every(status)))
+            fail();
+        if (review.quotes !== undefined &&
+            (!Array.isArray(review.quotes) ||
+                review.quotes.length !== d.output.ideas.length ||
+                review.quotes.some((q, i) => !Array.isArray(q) || q.length !== d.output.ideas[i].quotes.length || !q.every(status))))
+            fail();
+        const paths = [];
+        if (review.gist !== undefined)
+            paths.push(['review.gist', review.gist, d.review.gist ?? null]);
+        review.ideas?.forEach((v, i) => paths.push([`review.ideas.${i}`, v, d.review.ideas?.[i] ?? null]));
+        review.quotes?.forEach((q, i) => q.forEach((v, j) => paths.push([`review.quotes.${i}.${j}`, v, d.review.quotes?.[i]?.[j] ?? null])));
+        return paths.filter(([, next, prior]) => next !== prior).map(([path, next]) => [path, next]);
+    },
+    /** Review JSON in one canonical shape, whatever order its paths were written in. */
+    applyReview(review, output, path, value) {
+        const ideas = output.ideas.map((_, i) => review.ideas?.[i] ?? null);
+        const quotes = output.ideas.map((idea, i) => idea.quotes.map((_, j) => review.quotes?.[i]?.[j] ?? null));
+        let gist = review.gist ?? null;
+        const m = /^review\.(?:(gist)|ideas\.(\d{1,2})|quotes\.(\d{1,2})\.(\d{1,2}))$/.exec(path) ?? fail();
+        if (m[1])
+            gist = value;
+        else if (m[2] !== undefined) {
+            const i = Number(m[2]);
+            if (i >= ideas.length)
+                fail();
+            ideas[i] = value;
+        }
+        else {
+            const i = Number(m[3]), j = Number(m[4]);
+            if (i >= quotes.length || j >= quotes[i].length)
+                fail();
+            quotes[i][j] = value;
+        }
+        return {
+            ...(gist ? { gist } : {}),
+            ...(ideas.some((v) => v) ? { ideas } : {}),
+            ...(quotes.some((q) => q.some((v) => v)) ? { quotes } : {}),
+        };
+    },
+    publish: (d) => acceptedDigest(d),
+};

package/dist/src/digest/editorial.d.ts

@@ -1,54 +1,17 @@
-import type { DatabaseSync } from 'node:sqlite';
 import { type JungleEditorial } from '../importers/jungle-digest.js';
-import { type ReviewStatus } from '../store/changes.js';
+import type { DerivationKind, ReviewStatus, StoredDerivation } from '../derivations/types.js';
 /**
  * An editorial derivation keeps a reviewed source note whole (today: one Jungle Reading note of any form), without
  * Digest's limits. It is immutable data addressed like a digest; its review is one logged path, `review.note`.
  */
-export interface Editorial {
-    id: string;
-    itemId: string;
-    revisionId: string;
-    kind: 'editorial';
-    producer: unknown;
-    inputHash: string;
-    output: JungleEditorial;
-    review: {
-        note?: ReviewStatus;
-    };
-    createdAt: string;
-}
-/** Bound on one editorial object: Jungle's largest notes (full transcripts) are a few hundred KiB. */
-export declare const editorialBytes: number;
+export type Editorial = StoredDerivation<'editorial', JungleEditorial, {
+    note?: ReviewStatus;
+}>;
 /** Fixed key order, so the same note is the same object on every device. */
 export declare function canonicalEditorial(e: JungleEditorial): string;
-/** The input hash is the note's own Markdown hash: an edited note is a new object, an unchanged one a duplicate. */
-export declare function putEditorial(db: DatabaseSync, input: {
-    itemId: string;
-    revisionId: string;
-    producer: Record<string, unknown>;
+/** Editorial: the input hash is the note's own Markdown hash, so an edited note is a new object and an unchanged one a duplicate. */
+export declare const editorialKind: DerivationKind<'editorial', JungleEditorial, {
+    note?: ReviewStatus;
+}, ReviewStatus | null, {
     output: JungleEditorial;
-}): {
-    id: string;
-    duplicate: boolean;
-};
-export declare function readEditorial(db: DatabaseSync, id: string): Editorial | undefined;
-/** The newest editorial derivation of the item's current revision. */
-export declare function currentEditorial(db: DatabaseSync, itemId: string): Editorial | undefined;
-export declare function listEditorials(db: DatabaseSync, itemId: string): Editorial[];
-/** One logged change, and only when the status differs. */
-export declare function reviewEditorial(db: DatabaseSync, id: string, status: ReviewStatus | null): Editorial;
-/**
- * The public subset of an accepted editorial note, in the public digest shape and within Digest v2's limits: a lead only
- * when the note's first sentence fits the lead limit (never cut), claims with detail, and quotes that occur verbatim in the
- * capture with 4-25 words, assigned to ideas as the importer assigns them (at most 2 per idea and 6 in all), within the
- * per-entry budget (150 words, and the 10% source share with its 25-word floor).
- */
-export declare function publicEditorial(db: DatabaseSync, e: Editorial): {
-    lead?: string;
-    ideas: {
-        claim: string;
-        detail: string;
-        quotes: string[];
-    }[];
-} | undefined;
+}>;

package/dist/src/digest/editorial.js

@@ -1,54 +1,34 @@
 import { locateAll, words } from '../annotations/quote.js';
-import { markdownFor } from '../annotations/store.js';
 import { assignQuotes, firstSentence } from '../importers/jungle-digest.js';
-import { mutate } from '../store/changes.js';
-import { StoreError } from '../store/types.js';
-import { digest } from '../store/files.js';
-import { derivationId } from './store.js';
+import { sha256 } from '../util/hash.js';
 import { digestLimits as L } from './schema.js';
-const now = () => new Date().toISOString();
-const fail = (code = 'invalid-input') => { throw new StoreError(code); };
+import { SpongeError } from '../errors.js';
+const fail = () => {
+    throw new SpongeError('invalid-input');
+};
 /** Bound on one editorial object: Jungle's largest notes (full transcripts) are a few hundred KiB. */
-export const editorialBytes = 1024 ** 2;
+const editorialBytes = 1024 ** 2;
 const str = (v, max = 65536) => typeof v === 'string' && Buffer.byteLength(v) <= max;
 /** Fixed key order, so the same note is the same object on every device. */
 export function canonicalEditorial(e) {
-    return JSON.stringify({ schemaVersion: e.schemaVersion, source: e.source, form: e.form, slug: e.slug, status: e.status, title: e.title, sourceUrl: e.sourceUrl, capture: e.capture, frontmatter: e.frontmatter, ...(e.gist !== undefined ? { gist: e.gist } : {}), ...(e.ideas ? { ideas: e.ideas.map(i => ({ claim: i.claim, detail: i.detail })) } : {}), ...(e.quotes ? { quotes: e.quotes.map(q => ({ text: q.text, attribution: q.attribution, speaker: q.speaker })) } : {}), markdownSha256: e.markdownSha256, markdown: e.markdown });
-}
-/** The input hash is the note's own Markdown hash: an edited note is a new object, an unchanged one a duplicate. */
-export function putEditorial(db, input) {
-    const e = input.output, producer = JSON.stringify(input.producer);
-    if (!producer || Buffer.byteLength(producer) > 4096)
-        fail();
-    if (db.prepare('SELECT item_id FROM revisions WHERE id=?').get(input.revisionId)?.item_id !== input.itemId)
-        fail('unavailable');
-    if (e?.schemaVersion !== 1 || e.source !== 'jungle-reading' || ![e.form, e.slug, e.status, e.title, e.sourceUrl, e.capture].every(v => str(v, 16384)) || !str(e.markdown, 4 * 1024 ** 2) || digest(e.markdown) !== e.markdownSha256)
-        fail();
-    const output = canonicalEditorial(e);
-    if (Buffer.byteLength(output) > editorialBytes)
-        fail();
-    const id = derivationId(input.revisionId, 'editorial', e.markdownSha256, output);
-    if (db.prepare('SELECT 1 FROM derivations WHERE id=?').get(id))
-        return { id, duplicate: true };
-    db.prepare("INSERT INTO derivations(id,item_id,revision_id,kind,schema_version,producer_json,input_hash,output_json,created_at) VALUES(?,?,?,'editorial',1,?,?,?,?)").run(id, input.itemId, input.revisionId, producer, e.markdownSha256, output, now());
-    return { id, duplicate: false };
-}
-function editorialRow(r) { return { id: String(r.id), itemId: String(r.item_id), revisionId: String(r.revision_id), kind: 'editorial', producer: JSON.parse(String(r.producer_json)), inputHash: String(r.input_hash), output: JSON.parse(String(r.output_json)), review: JSON.parse(String(r.review_json)), createdAt: String(r.created_at) }; }
-export function readEditorial(db, id) { const r = db.prepare("SELECT * FROM derivations WHERE id=? AND kind='editorial'").get(id); return r ? editorialRow(r) : undefined; }
-/** The newest editorial derivation of the item's current revision. */
-export function currentEditorial(db, itemId) {
-    const r = db.prepare("SELECT d.* FROM derivations d JOIN items i ON i.id=d.item_id AND i.current_revision=d.revision_id WHERE d.item_id=? AND d.kind='editorial' ORDER BY d.created_at DESC,d.rowid DESC LIMIT 1").get(itemId);
-    return r ? editorialRow(r) : undefined;
-}
-export function listEditorials(db, itemId) { return db.prepare("SELECT * FROM derivations WHERE item_id=? AND kind='editorial' ORDER BY created_at,rowid").all(itemId).map(editorialRow); }
-/** One logged change, and only when the status differs. */
-export function reviewEditorial(db, id, status) {
-    const d = readEditorial(db, id) ?? fail('unavailable');
-    if (status !== null && status !== 'accepted' && status !== 'rejected')
-        fail();
-    if ((d.review.note ?? null) !== status)
-        mutate(db, 'derivation', id, 'review.note', status);
-    return readEditorial(db, id);
+    return JSON.stringify({
+        schemaVersion: e.schemaVersion,
+        source: e.source,
+        form: e.form,
+        slug: e.slug,
+        status: e.status,
+        title: e.title,
+        sourceUrl: e.sourceUrl,
+        capture: e.capture,
+        frontmatter: e.frontmatter,
+        ...(e.gist !== undefined ? { gist: e.gist } : {}),
+        ...(e.ideas ? { ideas: e.ideas.map((i) => ({ claim: i.claim, detail: i.detail })) } : {}),
+        ...(e.quotes
+            ? { quotes: e.quotes.map((q) => ({ text: q.text, attribution: q.attribution, speaker: q.speaker })) }
+            : {}),
+        markdownSha256: e.markdownSha256,
+        markdown: e.markdown,
+    });
 }
 /**
  * The public subset of an accepted editorial note, in the public digest shape and within Digest v2's limits: a lead only
@@ -56,15 +36,15 @@ export function reviewEditorial(db, id, status) {
  * capture with 4-25 words, assigned to ideas as the importer assigns them (at most 2 per idea and 6 in all), within the
  * per-entry budget (150 words, and the 10% source share with its 25-word floor).
  */
-export function publicEditorial(db, e) {
+function publicEditorial(e, capture) {
     if (e.review.note !== 'accepted')
         return undefined;
     const o = e.output, [first] = firstSentence(o.gist ?? ''), lead = first && first.length <= L.leadChars ? first : undefined;
-    const ideas = (o.ideas ?? []).map(i => ({ claim: i.claim, detail: i.detail, quotes: [] }));
+    const ideas = (o.ideas ?? []).map((i) => ({ claim: i.claim, detail: i.detail, quotes: [] }));
     if (ideas.length && o.quotes?.length) {
-        const source = markdownFor(db, e.revisionId), budget = Math.min(L.totalQuoteWords, Math.max(L.quoteWords, Math.floor(words(source) * L.sourceQuoteShare))), taken = [], texts = [];
+        const source = capture(), budget = Math.min(L.totalQuoteWords, Math.max(L.quoteWords, Math.floor(words(source) * L.sourceQuoteShare))), taken = [], texts = [];
         for (const q of o.quotes) {
-            const match = locateAll(source, q.text).find(m => !taken.some(t => m.start < t.end && t.start < m.end));
+            const match = locateAll(source, q.text).find((m) => !taken.some((t) => m.start < t.end && t.start < m.end));
             if (!match)
                 continue;
             const text = source.slice(match.start, match.end), n = words(text);
@@ -74,7 +54,7 @@ export function publicEditorial(db, e) {
             }
         }
         let used = 0, count = 0;
-        assignQuotes(ideas, texts.map(text => ({ text }))).forEach((idea, k) => {
+        assignQuotes(ideas, texts.map((text) => ({ text }))).forEach((idea, k) => {
             const n = words(texts[k]);
             if (idea === null || count >= L.maxQuotes || used + n > budget)
                 return;
@@ -85,3 +65,31 @@ export function publicEditorial(db, e) {
     }
     return lead || ideas.length ? { ...(lead ? { lead } : {}), ideas } : undefined;
 }
+/** Editorial: the input hash is the note's own Markdown hash, so an edited note is a new object and an unchanged one a duplicate. */
+export const editorialKind = {
+    kind: 'editorial',
+    schemaVersion: 1,
+    admit({ output: e }) {
+        if (e?.schemaVersion !== 1 ||
+            e.source !== 'jungle-reading' ||
+            ![e.form, e.slug, e.status, e.title, e.sourceUrl, e.capture].every((v) => str(v, 16384)) ||
+            !str(e.markdown, 4 * 1024 ** 2) ||
+            sha256(e.markdown) !== e.markdownSha256)
+            fail();
+        const output = canonicalEditorial(e);
+        if (Buffer.byteLength(output) > editorialBytes)
+            fail();
+        return { output, inputHash: e.markdownSha256, schemaVersion: 1 };
+    },
+    reviewPaths(d, status) {
+        if (status !== null && status !== 'accepted' && status !== 'rejected')
+            fail();
+        return (d.review.note ?? null) !== status ? [['review.note', status]] : [];
+    },
+    applyReview(_review, _output, path, value) {
+        if (path !== 'review.note')
+            fail();
+        return value ? { note: value } : {};
+    },
+    publish: publicEditorial,
+};