@hraness/sponge 0.4.0 → 0.4.1

package/dist/src/cli/commands.js

@@ -18,7 +18,7 @@ import { pruneText } from '../indexing/prune-run.js';
 import { importAction, jungleAction, jungleText } from './import.js';
 import { digestText, reviewFromSpec, reviewSpec } from './digest.js';
 import { connectEndpoint } from '../digest/endpoint.js';
-import { createDigest } from '../digest/pipeline.js';
+import { createDigest, undigestible } from '../digest/pipeline.js';
 import { createQueryEmbedder, createTextEmbedder } from '../search/query.js';
 import { runtimeGcAction, runtimeGcText, setupRuntimeGc } from './runtimes.js';
 import { drainLibrary } from '../worker/basic.js';
@@ -742,6 +742,13 @@ export const commands = [
                 return 0;
             }
             if (args.flags.draft) {
+                // Refuse an unknown item or a thin capture before the model server spends its startup on it.
+                const item = store.read(args.positional[0]);
+                if (!item)
+                    throw new SpongeError('unavailable');
+                const thin = undigestible(item.markdown);
+                if (thin)
+                    throw new SpongeError(thin);
                 const runtime = await inspectDigest(c.nativeRoot, args.flags.model ?? store.digests.settings().model ?? undefined), result = await withDigestServer(store.root, runtime, (model) => createDigest(store, args.positional[0], model, { signal }), { signal });
                 c.emit({ digest: result.derivation, duplicate: result.duplicate, ...(result.trace ? { trace: result.trace } : {}) }, digestText(result.derivation));
                 return 0;

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

@@ -4,7 +4,7 @@ import type { Derivation, DigestCandidate } from './derivation.js';
  * Model-agnostic Digest v2 drafting. The model sees numbered passages and cites a passage id plus a short exact
  * span; code snaps, prunes and checks. Nothing leaves this module except through the injected model.
  */
-export declare const PROMPT_VERSION = "sponge-digest-prompt-v5";
+export declare const PROMPT_VERSION = "sponge-digest-prompt-v6";
 export type ChatMessage = {
     role: 'system' | 'user' | 'assistant';
     content: string;
@@ -56,8 +56,30 @@ interface Highlight {
  * change digest input hashes.
  */
 export declare function canonicalJson(value: unknown): string;
-/** Paragraph-level passages with raw offsets. Headings label passages; code fences and image-only blocks are not quotable. */
-export declare function passages(markdown: string, maxChars?: number): Passage[];
+/** Where a post starts in a captured thread, and who wrote it as the model is told. */
+export interface Post {
+    start: number;
+    label: string;
+}
+/**
+ * The posts of an X thread capture: top-level list items that carry X's post links. The poster's handle comes from
+ * the item's avatar or name link; the thread's author from the title (`Name (@handle) on X`), else the first post. A
+ * later post without a handle is still a reply. Other list items (an X article's bullets) are not posts, and a thread
+ * with no reply has none.
+ */
+export declare function threadPosts(markdown: string): Post[];
+/** A thread's passages without its replies, which are readers' comments rather than the source; renumbered from 1. */
+export declare function authorPassages(markdown: string): Passage[];
+/**
+ * Paragraph-level passages with raw offsets. Headings label passages; code fences and image-only blocks are not
+ * quotable. `posts` (a thread's) also break blocks, and their labels head the passages that follow.
+ */
+export declare function passages(markdown: string, maxChars?: number, posts?: readonly Post[]): Passage[];
+/**
+ * Why a capture cannot be digested, as a detail code, or undefined when it can: its body (past the frontmatter, images
+ * dropped, link text kept) has under `minProseWords` words with letters, or only an archive's metadata was saved.
+ */
+export declare function undigestible(markdown: string): 'source-too-thin' | undefined;
 /** Pack passages into sections of at most `budget` display characters, preferring heading boundaries past half a budget. */
 export declare function sectionsOf(list: Passage[], budget: number): Passage[][];
 /** JSON Schema for the model's draft. Tags become an enum when a vocabulary is given. */
@@ -160,8 +182,11 @@ export interface DigestStore {
         read(kind: 'digest', id: string): Derivation | undefined;
     };
 }
+type DraftOptions = Omit<DraftInput, 'revisionId' | 'markdown' | 'title' | 'form' | 'model' | 'highlights'>;
+/** What the item's current revision is drafted from: its Markdown, title, form and anchored highlights. */
+export declare function digestInputFor(store: Pick<DigestStore, 'read' | 'annotations'>, itemId: string, model: DigestModel, options?: DraftOptions): DraftInput;
 /** Draft and store a digest for the item's current revision. A matching input hash returns the stored draft without calling the model. */
-export declare function createDigest(store: DigestStore, itemId: string, model: DigestModel, options?: Omit<DraftInput, 'revisionId' | 'markdown' | 'title' | 'form' | 'model' | 'highlights'>): Promise<{
+export declare function createDigest(store: DigestStore, itemId: string, model: DigestModel, options?: DraftOptions): Promise<{
     derivation: Derivation;
     duplicate: boolean;
     trace?: DraftTrace;

package/dist/src/digest/pipeline.js

@@ -6,7 +6,7 @@ import { sha256 } from '../util/hash.js';
  * Model-agnostic Digest v2 drafting. The model sees numbered passages and cites a passage id plus a short exact
  * span; code snaps, prunes and checks. Nothing leaves this module except through the injected model.
  */
-export const PROMPT_VERSION = 'sponge-digest-prompt-v5';
+export const PROMPT_VERSION = 'sponge-digest-prompt-v6';
 /** 24k characters is roughly 6k tokens of passages, leaving room for instructions and output in an 8k context on an 8 GB Mac. */
 const defaultDigestParams = {
     temperature: 0,
@@ -40,14 +40,62 @@ export function canonicalJson(value) {
         throw new SpongeError('invalid-input');
     return JSON.stringify(value ?? null);
 }
-/** Paragraph-level passages with raw offsets. Headings label passages; code fences and image-only blocks are not quotable. */
-export function passages(markdown, maxChars = 1200) {
+const postHandle = [
+    /^- \[!\[@(\w+)\]/,
+    /^- \[\[remote image: @(\w+)\]/,
+    /^-\s+\[[^\]]+\]\(https:\/\/x\.com\/(\w+)\)\s*$/,
+];
+/**
+ * The posts of an X thread capture: top-level list items that carry X's post links. The poster's handle comes from
+ * the item's avatar or name link; the thread's author from the title (`Name (@handle) on X`), else the first post. A
+ * later post without a handle is still a reply. Other list items (an X article's bullets) are not posts, and a thread
+ * with no reply has none.
+ */
+export function threadPosts(markdown) {
+    const author = /^title: ".*\(@(\w+)\) on X"/m.exec(frontmatter(markdown))?.[1], items = [];
+    let at = 0;
+    for (const line of markdown.split('\n')) {
+        if (/^- /.test(line) || /^-\s+\[/.test(line))
+            items.push({ start: at, handle: postHandle.map((r) => r.exec(line)?.[1]).find(Boolean), post: false });
+        const item = items.at(-1);
+        if (item && /x\.com\/(compose\/post\?in_reply_to=|\w+\/status\/\d)/.test(line))
+            item.post = true;
+        at += line.length + 1;
+    }
+    const posts = items.filter((i) => i.post || i.handle), by = author ?? posts[0]?.handle, same = (h) => h.toLowerCase() === by?.toLowerCase(), labelled = posts.map((p, i) => ({
+        start: p.start,
+        label: p.handle && !same(p.handle)
+            ? `Reply by @${p.handle}`
+            : p.handle || i === 0
+                ? `Post by ${by ? `@${by}, ` : ''}the author`
+                : 'Reply (poster not captured)',
+    }));
+    // With no reply there is nobody to tell apart, so the passages stay as they are.
+    return labelled.some((p) => p.label !== labelled[0].label) ? labelled : [];
+}
+/** A thread's passages without its replies, which are readers' comments rather than the source; renumbered from 1. */
+export function authorPassages(markdown) {
+    return passages(markdown, undefined, threadPosts(markdown))
+        .filter((p) => !p.heading?.startsWith('Reply'))
+        .map((p, i) => ({ ...p, id: i + 1 }));
+}
+/**
+ * Paragraph-level passages with raw offsets. Headings label passages; code fences and image-only blocks are not
+ * quotable. `posts` (a thread's) also break blocks, and their labels head the passages that follow.
+ */
+export function passages(markdown, maxChars = 1200, posts = []) {
     const out = [], blocks = [];
     let at = 0, start = -1, fence = false, fenced = false;
+    const breaks = new Set(posts.map((p) => p.start));
     for (const line of markdown.split('\n')) {
         const end = at + line.length, blank = !line.trim(), marker = /^\s{0,3}(```|~~~)/.test(line);
         if (marker)
             fence = !fence;
+        if (!fence && !marker && start >= 0 && breaks.has(at)) {
+            blocks.push({ start, end: at - 1, fence: fenced });
+            start = -1;
+            fenced = false;
+        }
         if (blank && !fence && !marker) {
             if (start >= 0)
                 blocks.push({ start, end: at - 1, fence: fenced });
@@ -64,14 +112,17 @@ export function passages(markdown, maxChars = 1200) {
     }
     if (start >= 0)
         blocks.push({ start, end: markdown.length, fence: fenced });
-    let heading = '';
+    let heading = '', post = '';
+    const label = (start) => posts.findLast((p) => p.start <= start)?.label ?? '';
     for (const b of blocks) {
         const raw = markdown.slice(b.start, b.end).trimEnd(), end = b.start + raw.length;
         if (b.fence || !raw.trim())
             continue;
+        if (label(b.start) !== post)
+            heading = post = label(b.start);
         const h = /^\s{0,3}#{1,6}\s+(.+)$/.exec(raw);
         if (h && !raw.includes('\n')) {
-            heading = collapse(h[1]).slice(0, 200);
+            heading = (post ? `${post}: ` : '') + collapse(h[1]).slice(0, 200);
             continue;
         }
         if (/^(\s*!\[[^\]]*\]\([^)]*\)\s*)+$/.test(raw))
@@ -91,6 +142,32 @@ export function passages(markdown, maxChars = 1200) {
     }
     return out;
 }
+const frontmatter = (markdown) => /^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/u.exec(markdown)?.[0] ?? '';
+/** A `key: "value"` frontmatter field, as captures write them. */
+function captureField(markdown, key) {
+    const match = new RegExp(`^${key}: (".*")\\r?$`, 'm').exec(frontmatter(markdown));
+    try {
+        const value = match ? JSON.parse(match[1]) : undefined;
+        return typeof value === 'string' ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Prose words under which a capture holds nothing to digest: a gallery of numbered images, a bare link list. */
+const minProseWords = 20;
+/**
+ * Why a capture cannot be digested, as a detail code, or undefined when it can: its body (past the frontmatter, images
+ * dropped, link text kept) has under `minProseWords` words with letters, or only an archive's metadata was saved.
+ */
+export function undigestible(markdown) {
+    if (captureField(markdown, 'capture_method') === 'archive-metadata')
+        return 'source-too-thin';
+    const prose = passages(markdown.slice(frontmatter(markdown).length))
+        .map((p) => p.text.replace(/(!?)\[([^\]]*)\]\([^)]*\)/g, (_, image, text) => (image ? ' ' : text)))
+        .join(' ');
+    return (prose.match(/\p{L}[\p{L}\p{M}'’-]*/gu) ?? []).length < minProseWords ? 'source-too-thin' : undefined;
+}
 function lastSentenceEnd(window) {
     let best = -1;
     for (const m of window.matchAll(/[.!?]["')\]]*(?=\s)/g))
@@ -196,7 +273,12 @@ Source: an essay arguing that taste is a skill.
   claim: Volume beats polish early. | detail: Side-by-side comparison of many rough drafts sharpens judgment faster than finishing one.
 Bad claim: The essay explores how practice over time shapes a person's sense of taste.
 Good claim: Taste is trained.`;
-const system = (budget, vocabulary) => `You write a Digest v2 of one source for a private reading library, in the owner's voice: terse, declarative, specific. Reply with JSON only, matching the schema.
+/** Who speaks in each form, so claims are credited to the person who made them. */
+const voices = {
+    thread: 'This source is an X thread. Its replies are left out. When the author quotes or answers someone, that view stays theirs.',
+    video: 'This source is a recording: credit each claim to the person who says it. In an interview or podcast, the guest’s views are the guest’s, not the host’s.',
+};
+const system = (budget, form, vocabulary) => `You write a Digest v2 of one source for a private reading library, in the owner's voice: terse, declarative, specific. Reply with JSON only, matching the schema.
 - lead: one sentence of at most ${L.leadChars} characters stating this source's specific thesis or result: who (author, organization or product by name) shows or argues what, with the number, name or mechanism that makes it this source. Do not restate the title, describe the source ("This article discusses"), or tease.
 - context: 1 or 2 sentences, at most 45 words: the evidence, method, numbers or limits the lead could not hold. Lead and context together stay within ${L.gistWords} words and ${L.gistSentences} sentences.
 - ideas: ${L.minIdeas} to ${L.maxIdeas} (prefer ${L.maxIdeas} when the source has them), in the order the author makes them, covering the whole source including its caveats and limits. Each idea is a claim with detail:
@@ -205,7 +287,12 @@ const system = (budget, vocabulary) => `You write a Digest v2 of one source for
   - quotes: 0 to ${L.maxQuotesPerIdea} that support this idea, each a contiguous span copied character for character from one numbered passage, ${minQuoteWords + 2} to 20 words, with that passage number. A quote is a fragment, not a whole long sentence: when a sentence runs past 20 words, copy only its strongest part. No added quotation marks or ellipses. Give attribution (who said it) when it is not the author. Prefer reader highlights.
 - Attach at least ${L.minQuotes} and at most ${L.maxQuotes} quotes in all; ${L.minQuotes + 1} to 3 is typical. All quotes together stay within ${budget} words and never overlap.
 - tags: 0 to ${L.maxTags} ${vocabulary?.length ? `from: ${vocabulary.join(', ')}` : 'lowercase kebab-case topics'}; usually one subject tag.
-Plain words. Name things and use numbers. No hedges or filler: may, might, potentially, various, significantly, key, crucial, notably, highlights, explores, discusses, "the author argues", "the article".
+Faithfulness comes before style:
+- Credit each view to who holds it. When the source quotes, interviews or reports someone, their claims are theirs: name them in the detail and the quote attribution, never pass them off as the author's.${voices[form] ? `\n- ${voices[form]}` : ''}
+- Keep each number with its own subject, unit and meaning (an area is not a height, a share is not a count, a cost is not a price) and never compute one the source does not give.
+- Keep the source's direction: never invert a claim, comparison or cause.
+- Keep the source's certainty: a forecast, plan, proposal, rumor or question stays one ("plans to", "expects", "asks whether"); never state it as done or settled. Hedge only where the source does.
+Plain words. Name things and use numbers. No filler: various, significantly, key, crucial, notably, highlights, explores, discusses, "the author argues", "the article".
 Use only what the source says.
 
 ${styleExamples}`;
@@ -255,7 +342,9 @@ function fromModel(text, form) {
     }
     if (!object(v) || !Array.isArray(v.ideas) || !Array.isArray(v.tags))
         return { issues: [{ path: '', code: 'shape' }] };
-    const trim = (s) => (typeof s === 'string' ? s.trim() : s), cites = [];
+    const trim = (s) => (typeof s === 'string' ? s.trim() : s), 
+    // Models sometimes end a sentence with the passage it came from ("… market. [2]").
+    prose = (s) => (typeof s === 'string' ? s.replace(/(\s*\[\d+(?:,\s*\d+)*\])+$/, '').trim() : s), cites = [];
     const ideas = v.ideas.map((idea) => {
         if (!object(idea)) {
             cites.push([]);
@@ -264,19 +353,20 @@ function fromModel(text, form) {
         const quotes = Array.isArray(idea.quotes) ? idea.quotes : [];
         cites.push(quotes.map((q) => (Number.isSafeInteger(q?.passage) ? q.passage : undefined)));
         return {
-            claim: trim(idea.claim),
-            detail: trim(idea.detail),
+            claim: prose(idea.claim),
+            detail: prose(idea.detail),
             quotes: quotes.map((q) => {
                 const attribution = trim(q?.attribution);
                 return { text: trim(q?.text), ...(attribution ? { attribution } : {}) };
             }),
         };
     });
-    const context = trim(v.context);
+    // A context the model stopped mid-sentence is dropped; context is optional.
+    const context = ((c) => (typeof c === 'string' && !/[.!?…。！？)"”’]$/.test(c) ? undefined : c))(prose(v.context));
     const parsed = parseDigest({
         schemaVersion: 2,
         form,
-        gist: { lead: trim(v.lead), ...(context ? { context } : {}) },
+        gist: { lead: prose(v.lead), ...(context ? { context } : {}) },
         ideas,
         tags: v.tags.map(trim),
     });
@@ -453,7 +543,10 @@ export async function draftDigest(input) {
             input.vocabulary.length > 256 ||
             input.vocabulary.some((t) => !/^[a-z0-9][a-z0-9-]{0,63}$/.test(t))))
         throw new SpongeError('invalid-input');
-    const inputHash = digestInputHash({ ...input, model: identity }), source = input.markdown, list = passages(source);
+    const thin = undigestible(input.markdown);
+    if (thin)
+        throw new SpongeError(thin);
+    const inputHash = digestInputHash({ ...input, model: identity }), source = input.markdown, list = input.form === 'thread' ? authorPassages(source) : passages(source);
     if (list.length === 0)
         throw new SpongeError('invalid-input');
     const userSignal = input.signal ?? new AbortController().signal, overall = AbortSignal.any([userSignal, AbortSignal.timeout(p.deadlineMs)]);
@@ -564,7 +657,7 @@ export async function draftDigest(input) {
     }
     const budget = quoteBudget(source), schema = draftSchema(list.length, input.vocabulary);
     const messages = [
-        { role: 'system', content: system(budget, input.vocabulary) },
+        { role: 'system', content: system(budget, input.form, input.vocabulary) },
         {
             role: 'user',
             content: (notesText ? `Notes from each part of the source, in order:\n${notesText}\n\n` : '') +
@@ -637,9 +730,16 @@ export async function draftDigest(input) {
     };
     return { output: result.draft.digest, inputHash, producer, options, trace };
 }
-const formFor = (kind) => (kind === 'pdf' ? 'pdf' : kind === 'media' ? 'video' : 'article');
-/** Draft and store a digest for the item's current revision. A matching input hash returns the stored draft without calling the model. */
-export async function createDigest(store, itemId, model, options = {}) {
+/** X thread captures draft as `thread`, whose prompt rules keep replies apart from the author's posts. */
+const formFor = (kind, markdown) => kind === 'pdf'
+    ? 'pdf'
+    : kind === 'media'
+        ? 'video'
+        : captureField(markdown, 'platform') === 'x' && captureField(markdown, 'capture_scope') === 'thread'
+            ? 'thread'
+            : 'article';
+/** What the item's current revision is drafted from: its Markdown, title, form and anchored highlights. */
+export function digestInputFor(store, itemId, model, options = {}) {
     const item = store.read(itemId);
     if (!item)
         throw new SpongeError('unavailable');
@@ -647,21 +747,25 @@ export async function createDigest(store, itemId, model, options = {}) {
         .list(itemId)
         .filter((a) => a.kind === 'highlight' && a.revisionId === item.revisionId && a.anchored !== false)
         .map((a) => ({ text: a.anchor.exact, start: a.anchor.start }));
-    const input = {
+    return {
         ...options,
         revisionId: item.revisionId,
         markdown: item.markdown,
         title: item.title,
-        form: formFor(item.kind),
+        form: formFor(item.kind, item.markdown),
         model,
         highlights,
     };
-    const prior = store.derivations.find('digest', item.revisionId, digestInputHash({ ...input, model: model.identity }));
+}
+/** Draft and store a digest for the item's current revision. A matching input hash returns the stored draft without calling the model. */
+export async function createDigest(store, itemId, model, options = {}) {
+    const input = digestInputFor(store, itemId, model, options);
+    const prior = store.derivations.find('digest', input.revisionId, digestInputHash({ ...input, model: model.identity }));
     if (prior)
         return { derivation: prior, duplicate: true };
     const draft = await draftDigest(input), stored = store.derivations.put('digest', {
         itemId,
-        revisionId: item.revisionId,
+        revisionId: input.revisionId,
         producer: draft.producer,
         inputHash: draft.inputHash,
         output: draft.output,

package/dist/src/errors.d.ts

@@ -19,6 +19,7 @@ declare const parents: {
     readonly 'draft-rejected': "unavailable";
     readonly 'model-unavailable': "unavailable";
     readonly 'model-busy': "unavailable";
+    readonly 'source-too-thin': "unavailable";
     readonly 'parent-missing': "invalid-input";
     readonly 'target-exists': "invalid-input";
 };

package/dist/src/errors.js

@@ -33,6 +33,7 @@ const parents = {
     'draft-rejected': 'unavailable',
     'model-unavailable': 'unavailable',
     'model-busy': 'unavailable',
+    'source-too-thin': 'unavailable',
     'parent-missing': 'invalid-input',
     'target-exists': 'invalid-input',
 };
@@ -84,6 +85,7 @@ export const hints = {
 export const detailHints = {
     'draft-rejected': 'The model draft failed the digest checks listed above, even after one repair. Drafting is deterministic, so the same capture and model fail again; refresh the item or use another model.',
     'model-unavailable': 'The model server did not answer or returned an error. Check that it is still running and has free GPU memory (another loaded model can exhaust it), then retry.',
+    'source-too-thin': 'The capture holds too little text to digest: under 20 words of prose, or only an archive’s metadata. Refresh the item when a fuller capture is possible.',
     'model-busy': 'Another llama-server is running, and two loaded models can exhaust GPU memory. Wait for it to exit, then retry.',
 };
 /** The one error type. `message` is the code, so bare `String(error)` never carries detail, paths or causes. */

package/dist/src/store/digest-jobs.d.ts

@@ -20,8 +20,11 @@ export type DigestOutcome = {
     notBefore?: string;
     countAttempt?: boolean;
 };
-/** Queue a digest of a newly captured revision when auto-digest is on. Runs inside the capture commit's transaction. */
-export declare function enqueueDigest(db: DatabaseSync, itemId: string, revisionId: string): void;
+/**
+ * Queue a digest of a newly captured revision when auto-digest is on and the capture has enough text to digest. Runs
+ * inside the capture commit's transaction.
+ */
+export declare function enqueueDigest(db: DatabaseSync, itemId: string, revisionId: string, markdown: string): void;
 /**
  * Digest jobs under the shared worker lease. A job names one revision; when its item moves on or is deleted before the
  * worker reaches it, the job is cancelled as `superseded`, since the newer revision has a job of its own. The drafting

package/dist/src/store/digest-jobs.js

@@ -3,12 +3,16 @@ import { text } from './files.js';
 import { checkOwner } from './lease.js';
 import { now, transaction } from './context.js';
 import { SpongeError } from '../errors.js';
+import { undigestible } from '../digest/pipeline.js';
 /** Automatic retries a retryable failure gets before it stays failed. */
 const maxAttempts = 3;
 const alias = /^[\w.:/@+-]{1,256}$/;
-/** Queue a digest of a newly captured revision when auto-digest is on. Runs inside the capture commit's transaction. */
-export function enqueueDigest(db, itemId, revisionId) {
-    if (db.prepare('SELECT auto FROM digest_settings WHERE id=1').get()?.auto !== 1)
+/**
+ * Queue a digest of a newly captured revision when auto-digest is on and the capture has enough text to digest. Runs
+ * inside the capture commit's transaction.
+ */
+export function enqueueDigest(db, itemId, revisionId, markdown) {
+    if (db.prepare('SELECT auto FROM digest_settings WHERE id=1').get()?.auto !== 1 || undigestible(markdown))
         return;
     db.prepare("INSERT INTO digest_jobs(id,item_id,revision_id,state,created_at) VALUES(?,?,?,'queued',?) ON CONFLICT(revision_id) DO NOTHING").run(randomUUID(), itemId, revisionId, now());
 }

package/dist/src/store/revisions.js

@@ -154,7 +154,7 @@ export class Revisions {
                 trackLibrary(db);
                 // A capture, not an import: imported libraries are digested on purpose, not as a side effect.
                 if (!imported)
-                    enqueueDigest(db, input.itemId, revisionId);
+                    enqueueDigest(db, input.itemId, revisionId, String(stored.markdown));
             }
             if (imported) {
                 const receipt = importReceipt(db, imported.namespace, imported.sourceKey, imported.sourceHash);

package/native/runtime-manifest.json

@@ -27,14 +27,14 @@
     }
   ],
   "build": {
-    "asrSourceSha256": "21a284b38eca324015bc9d03efb14335a5a73f8b3761b0f547180bf851fce2a3",
+    "asrSourceSha256": "6a84b1b2040f17cb510a71548c1453442df15f820ceb0ac8cec3086b4ccefbdc",
     "clangVersion": "Apple clang version 21.0.0 (clang-2100.1.1.101)",
-    "embeddingSourceSha256": "ff0a27cefa0ddc23e1d8bea7a70a49a112865ee730500a1da69ca9b8e6104adc",
+    "embeddingSourceSha256": "b029dadccaeba029fb9ef302daaefc6a134e8d46440c1e8c227f374d97202ce3",
     "swiftVersion": "Apple Swift version 6.3.3 (swiftlang-6.3.3.1.3 clang-2100.1.1.101)"
   },
   "minimumMacOS": "26.0",
-  "packageVersion": "0.4.0",
+  "packageVersion": "0.4.1",
   "platform": "darwin",
   "schemaVersion": 1,
-  "sourceCommit": "307210823c8523059f896fb64ff92dade3760b59"
+  "sourceCommit": "82fefa4ca18700e2e7390e1372c7c672ddac11fa"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hraness/sponge",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "A local library for captured articles and verified offline assets.",
   "repository": {
     "type": "git",