@poodle64/librarian 2026.10.3 → 2026.10.5

package/dist/transcript.svelte.d.ts

@@ -8,6 +8,7 @@
  */
 import type { AgentEvent } from './client';
 import type { Citation } from './citations';
+import type { Written } from './written';
 export interface TextBlock {
     kind: 'text';
     index: number;
@@ -17,6 +18,10 @@ export interface ThinkingBlock {
     kind: 'thinking';
     index: number;
     text: string;
+    /** Epoch ms the block opened and closed on this page, measured live; absent
+     *  for one the stream delivered whole or read back. */
+    startedAt?: number;
+    endedAt?: number;
 }
 export interface ToolBlock {
     kind: 'tool';
@@ -66,12 +71,6 @@ export interface ToolWords {
     object: string;
     /** One dimmed line under the row. */
     detail?: string;
-    /** How the activity line counts the call, singular and plural:
-     *  `['search', 'searches']` reads "2 searches". Absent is not counted. */
-    tally?: [one: string, many: string];
-    /** How the row counts a run of identical calls: `['page', 'pages']`
-     *  reads "· 5 pages". Absent reads "× 5". */
-    repeat?: [one: string, many: string];
     /** Something the call read that a reader can open, listed under the
      *  answer and handed back to the host's `oncite` when tapped. */
     source?: {
@@ -120,6 +119,8 @@ export declare class Transcript {
     outcome: Outcome | null;
     /** Sources for the answer, from the app's `citations` frame. */
     citations: Citation[];
+    /** The document versions the persona wrote, in order. */
+    written: Written[];
     other: AgentEvent[];
     reset(): void;
     apply(event: AgentEvent): void;
@@ -129,6 +130,7 @@ export interface FoldTarget {
     blocks: Block[];
     outcome: Outcome | null;
     citations?: Citation[];
+    written?: Written[];
 }
 /** Where one turn's fold keeps its place between events. */
 export interface FoldState {
@@ -155,29 +157,18 @@ export declare function fold(into: FoldTarget, state: FoldState, event: AgentEve
 /** A message's content blocks; a user frame may carry a bare string instead. */
 export declare function contentOf(event: AgentEvent): Array<Record<string, unknown>>;
 export interface ActivityStep {
-    /** The block this step stands for; a repeated step keeps the FIRST.
+    /** The block this step stands for.
      *
      * A `text` block here is interstitial narration, not the answer — see
      * `segment()`. */
     block: Block;
-    /** How many identical consecutive steps collapsed into this one. */
-    repeats: number;
-    /** A tool step in the persona's words, resolved once here so the row, the
-     *  count and the collapse all agree. */
+    /** A tool step in the persona's words, resolved once here. */
     words?: ToolWords;
 }
-/** One count on the activity line: "2 searches". */
-export interface Tally {
-    one: string;
-    many: string;
-    count: number;
-}
 export interface ActivityGroup {
     kind: 'activity';
     index: number;
     steps: ActivityStep[];
-    /** What the steps counted as, in the order each first appeared. */
-    tallies: Tally[];
 }
 export type Segment = ActivityGroup | TextBlock;
 /** One question and the answer to it, as the transcript renders it.
@@ -196,6 +187,10 @@ export interface Turn {
     blocks: Block[];
     outcome: Outcome | null;
     citations?: Citation[];
+    /** The names of the files attached to the question. */
+    files?: string[];
+    /** The document versions the persona wrote answering it, in order. */
+    written?: Written[];
     /** Something this turn produced for the reader to open, carded under the
      *  answer once the turn settles. */
     artefact?: Artefact;
@@ -223,15 +218,11 @@ export interface Artefact {
 /**
  * Fold a turn's flat block list into what a reader should actually see.
  *
- * Three problems this solves, all reported off a real transcript:
+ * Two problems this solves, reported off a real transcript:
  *
- * 1. Fifteen tool rows stood between the question and the first word of the
- *    answer, so the answer had to be scrolled to. Contiguous activity becomes
- *    ONE group the caller can collapse.
- * 2. "Reading pspf guidelines 2026" appeared five times in a row — five pages
- *    of one document, which is one act of reading to a human. Consecutive
- *    steps with the same label collapse to one row carrying a count.
- * 3. The persona's between-tool narration was rendering unfolded, as answer prose.
+ * 1. Contiguous activity becomes ONE group, so the answer's prose is never
+ *    split by each step; every step stays its own collapsed row in it.
+ * 2. The persona's between-tool narration was rendering unfolded, as answer prose.
  *    The caller stream carries no `thinking` blocks at all — measured on
  *    production 11/09/2026 — so "Let me also check whether…" arrives as an
  *    ordinary `text` block, indistinguishable from the answer except by
@@ -239,7 +230,7 @@ export interface Artefact {
  *    narration; only the run of text after the LAST tool call is the answer.
  *    Narration folds into the activity group as a thinking-shaped step.
  *
- * That third rule is provisional while a turn streams, and deliberately so: a
+ * That second rule is provisional while a turn streams, and deliberately so: a
  * text block that is currently last IS the answer as far as anything can know,
  * and renders as prose. The tool call that arrives after it re-homes it into
  * the group. Nothing here holds state to make that work — `segment` is pure
@@ -252,12 +243,6 @@ export interface Artefact {
  * off the prose itself would be unexplainable the first time it misfired.
  */
 export declare function segment(blocks: Block[], describeTool?: DescribeTool): Segment[];
-/** One line describing a whole investigation, for the collapsed state.
- *
- * Counts of what the persona did are fine ("1 search · 2 documents read"); how
- * it organises what it knows is not — no collection count, no corpus.
- */
-export declare function summariseActivity(group: ActivityGroup): string;
 /**
  * What a settled answer took, as one quiet line: `56.3s`, then what it cost
  * — only when the host can price it (`formatCost`) and the run actually

package/dist/transcript.svelte.js

@@ -6,6 +6,7 @@
  * deltas that belong to each. An event type this does not know about is kept
  * verbatim under `other`, so nothing is silently dropped.
  */
+import { hostOf } from './web-sources';
 /**
  * The question as the READER asked it.
  *
@@ -39,20 +40,35 @@ export function describe(block) {
     const lines = block.result ? block.result.split('\n').length : 0;
     return lines ? { ...said, detail: lines === 1 ? '1 line' : `${lines} lines` } : said;
 }
-const READ = {
-    tally: ['document read', 'documents read'],
-    repeat: ['page', 'pages']
-};
-const SEARCH = { tally: ['search', 'searches'] };
 function describeCall(block) {
     const input = parseInput(block);
     const command = typeof input.command === 'string' ? input.command : '';
     if (block.name === 'Read') {
         const path = str(input.file_path ?? input.path);
-        return { verb: 'Read', object: documentName(path), ...READ };
+        return { verb: 'Read', object: documentName(path) };
+    }
+    if (block.name === 'Write')
+        return { verb: 'Wrote', object: baseName(str(input.file_path)) };
+    if (block.name === 'Edit')
+        return { verb: 'Edited', object: baseName(str(input.file_path)) };
+    if (block.name === 'mcp__library__search') {
+        return { verb: 'Searched the library for', object: str(input.query) };
+    }
+    if (block.name === 'mcp__library__document_content' || block.name === 'mcp__library__document_detail') {
+        return { verb: 'Read a document', object: '' };
+    }
+    if (block.name === 'mcp__supacrawl__supacrawl_search') {
+        return { verb: 'Searched the web for', object: str(input.query) };
+    }
+    if (block.name === 'mcp__supacrawl__supacrawl_scrape') {
+        return { verb: 'Read', object: hostOf(str(input.url)) };
+    }
+    if (block.name.startsWith('mcp__') && block.name.endsWith('__ocr')) {
+        const file = str(input.file_path ?? input.path ?? input.file ?? input.filename ?? input.url);
+        return { verb: 'Read the scanned pages of', object: baseName(file) };
     }
     if (block.name === 'Grep') {
-        return { verb: 'Looked for', object: str(input.pattern), ...SEARCH };
+        return { verb: 'Looked for', object: str(input.pattern) };
     }
     if (block.name === 'Glob') {
         return { verb: 'Looked for documents', object: '' };
@@ -60,14 +76,14 @@ function describeCall(block) {
     if (block.name === 'Bash') {
         if (/\bgrep\b|\brg\b/.test(command)) {
             const quoted = command.match(/["']([^"']{2,60})["']/);
-            return { verb: 'Looked for', object: quoted?.[1] ?? 'a phrase', ...SEARCH };
+            return { verb: 'Looked for', object: quoted?.[1] ?? 'a phrase' };
         }
         if (/\bls\b/.test(command))
             return { verb: 'Looked through the library', object: '' };
         if (/\bfind\b/.test(command))
             return { verb: 'Looked for documents', object: '' };
         if (/\bcat\b|\bhead\b|\bsed\b/.test(command)) {
-            return { verb: 'Read', object: documentName(lastPath(command)), ...READ };
+            return { verb: 'Read', object: documentName(lastPath(command)) };
         }
         if (/\bwc\b/.test(command))
             return { verb: 'Checked', object: '' };
@@ -88,6 +104,7 @@ function parseInput(block) {
     }
 }
 const str = (value) => (typeof value === 'string' ? value : '');
+const baseName = (path) => path.split('/').filter(Boolean).at(-1) ?? '';
 /** A staged path ends with the document's title slug; that is its name. */
 function documentName(path) {
     if (!path)
@@ -154,12 +171,15 @@ export class Transcript {
     outcome = $state(null);
     /** Sources for the answer, from the app's `citations` frame. */
     citations = $state([]);
+    /** The document versions the persona wrote, in order. */
+    written = $state([]);
     other = $state([]);
     #fold = foldState();
     reset() {
         this.blocks = [];
         this.outcome = null;
         this.citations = [];
+        this.written = [];
         this.other = [];
         this.#fold = foldState();
     }
@@ -204,6 +224,27 @@ export function fold(into, state, event) {
         into.citations = (event.items ?? []).filter((item) => typeof item === 'object' && item !== null);
         return true;
     }
+    // The app emits this right after the tool result of a successful Write or
+    // Edit: one version of one document the persona wrote.
+    if (event.type === 'artefact') {
+        if (typeof event.name === 'string' && typeof event.version === 'number') {
+            // Assigned, then pushed through the state's own proxy: `??=` hands back the raw array, and that push redraws nothing.
+            into.written ??= [];
+            into.written.push({
+                name: event.name,
+                version: event.version,
+                media_type: typeof event.media_type === 'string' ? event.media_type : '',
+                bytes: typeof event.bytes === 'number' ? event.bytes : undefined,
+                formats: Array.isArray(event.formats) ? event.formats.map(String) : [],
+                title: typeof event.title === 'string' && event.title ? event.title : event.name,
+                kind: typeof event.kind === 'string' ? event.kind : null,
+                changes: typeof event.changes === 'string' ? event.changes : null,
+                pages: typeof event.pages === 'number' ? event.pages : 0,
+                at: Date.now()
+            });
+        }
+        return true;
+    }
     // No persona and no sentence at this layer: `client.ts` raises this for a
     // stream that would not open or died half-way, and the turn renders the
     // unreachable line in whichever persona's voice the host named.
@@ -257,7 +298,7 @@ export function fold(into, state, event) {
         if (cb.type === 'text')
             into.blocks.push({ kind: 'text', index: position, text: '' });
         else if (cb.type === 'thinking')
-            into.blocks.push({ kind: 'thinking', index: position, text: '' });
+            into.blocks.push({ kind: 'thinking', index: position, text: '', startedAt: Date.now() });
         else if (cb.type === 'tool_use')
             into.blocks.push({
                 kind: 'tool',
@@ -268,6 +309,12 @@ export function fold(into, state, event) {
             });
         return true;
     }
+    if (inner.type === 'content_block_stop' && inner.index !== undefined) {
+        const block = into.blocks[state.open.get(inner.index) ?? -1];
+        if (block?.kind === 'thinking' && block.startedAt !== undefined)
+            block.endedAt = Date.now();
+        return true;
+    }
     if (inner.type === 'content_block_delta' && inner.index !== undefined) {
         const position = state.open.get(inner.index);
         if (position === undefined)
@@ -321,15 +368,11 @@ function renderResult(content) {
 /**
  * Fold a turn's flat block list into what a reader should actually see.
  *
- * Three problems this solves, all reported off a real transcript:
+ * Two problems this solves, reported off a real transcript:
  *
- * 1. Fifteen tool rows stood between the question and the first word of the
- *    answer, so the answer had to be scrolled to. Contiguous activity becomes
- *    ONE group the caller can collapse.
- * 2. "Reading pspf guidelines 2026" appeared five times in a row — five pages
- *    of one document, which is one act of reading to a human. Consecutive
- *    steps with the same label collapse to one row carrying a count.
- * 3. The persona's between-tool narration was rendering unfolded, as answer prose.
+ * 1. Contiguous activity becomes ONE group, so the answer's prose is never
+ *    split by each step; every step stays its own collapsed row in it.
+ * 2. The persona's between-tool narration was rendering unfolded, as answer prose.
  *    The caller stream carries no `thinking` blocks at all — measured on
  *    production 11/09/2026 — so "Let me also check whether…" arrives as an
  *    ordinary `text` block, indistinguishable from the answer except by
@@ -337,7 +380,7 @@ function renderResult(content) {
  *    narration; only the run of text after the LAST tool call is the answer.
  *    Narration folds into the activity group as a thinking-shaped step.
  *
- * That third rule is provisional while a turn streams, and deliberately so: a
+ * That second rule is provisional while a turn streams, and deliberately so: a
  * text block that is currently last IS the answer as far as anything can know,
  * and renders as prose. The tool call that arrives after it re-homes it into
  * the group. Nothing here holds state to make that work — `segment` is pure
@@ -371,19 +414,11 @@ export function segment(blocks, describeTool) {
         if (block.kind !== 'tool' && !block.text.trim())
             continue;
         if (!current) {
-            current = { kind: 'activity', index: block.index, steps: [], tallies: [] };
+            current = { kind: 'activity', index: block.index, steps: [] };
             out.push(current);
         }
         const words = block.kind === 'tool' ? wordsFor(block, describeTool) : undefined;
-        const last = current.steps.at(-1);
-        if (last && sameStep(last, block, words)) {
-            last.repeats += 1;
-        }
-        else {
-            current.steps.push({ block, repeats: 1, words });
-        }
-        if (words?.tally)
-            count(current, words.tally);
+        current.steps.push({ block, words });
     }
     return out;
 }
@@ -399,33 +434,6 @@ const HANDS_IN = 'StructuredOutput';
 function isStep(block) {
     return block.kind === 'tool' && block.name !== HANDS_IN;
 }
-function sameStep(last, block, words) {
-    if (last.block.kind !== block.kind)
-        return false;
-    if (block.kind === 'thinking')
-        return true;
-    // Two narration sentences are two things the persona said; collapsing them to
-    // one row with a count would lose the second one entirely.
-    if (block.kind === 'text')
-        return false;
-    return last.words?.verb === words?.verb && last.words?.object === words?.object;
-}
-function count(group, [one, many]) {
-    const seen = group.tallies.find((t) => t.one === one && t.many === many);
-    if (seen)
-        seen.count += 1;
-    else
-        group.tallies.push({ one, many, count: 1 });
-}
-/** One line describing a whole investigation, for the collapsed state.
- *
- * Counts of what the persona did are fine ("1 search · 2 documents read"); how
- * it organises what it knows is not — no collection count, no corpus.
- */
-export function summariseActivity(group) {
-    const parts = group.tallies.map((t) => `${t.count} ${t.count === 1 ? t.one : t.many}`);
-    return parts.length ? parts.join(' · ') : 'Looked into it';
-}
 /**
  * What a settled answer took, as one quiet line: `56.3s`, then what it cost
  * — only when the host can price it (`formatCost`) and the run actually

package/dist/visuals.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The renderers for a persona's in-answer visuals, keyed on a fence's language.
+ *
+ * The persona writes a fenced block and the page draws it: the data is the
+ * persona's, every colour, face and size is the app's. A renderer is a
+ * component and the `parse` that turns the block's text into the `value` it
+ * draws, throwing on a block that is not one (the page then shows the code).
+ * `parse` returns anything, not JSON alone, so a renderer for a language that
+ * is not JSON registers the same way.
+ */
+import type { Component } from 'svelte';
+export interface Visual {
+    component: Component<{
+        value: unknown;
+        source: string;
+    }>;
+    /** The block's text as the value its component draws; throws on a block that is invalid. */
+    parse: (source: string) => unknown;
+}
+export interface TimelineValue {
+    title: string;
+    events: Array<{
+        date: string;
+        title: string;
+        detail: string;
+    }>;
+}
+export interface CardValue {
+    name: string;
+    kind: string;
+    summary: string;
+    facts: Array<{
+        label: string;
+        value: string;
+    }>;
+}
+/** A chart, a timeline and an entity card. An app adds to these or replaces one through `ChatExtensions.visuals`. */
+export declare const defaultVisuals: Record<string, Visual>;

package/dist/visuals.js

@@ -0,0 +1,82 @@
+/**
+ * The renderers for a persona's in-answer visuals, keyed on a fence's language.
+ *
+ * The persona writes a fenced block and the page draws it: the data is the
+ * persona's, every colour, face and size is the app's. A renderer is a
+ * component and the `parse` that turns the block's text into the `value` it
+ * draws, throwing on a block that is not one (the page then shows the code).
+ * `parse` returns anything, not JSON alone, so a renderer for a language that
+ * is not JSON registers the same way.
+ */
+import EntityCard from './components/visual-block/entity-card.svelte';
+import Timeline from './components/visual-block/timeline.svelte';
+import VegaChart from './components/visual-block/vega-chart.svelte';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const text = (value) => typeof value === 'string' ? value : typeof value === 'number' ? String(value) : '';
+const object = (source) => {
+    const value = JSON.parse(source);
+    if (!isRecord(value))
+        throw new Error('not an object');
+    return value;
+};
+/** Any string naming an address: a spec that carries one could fetch it, or link to it carrying the conversation out. */
+const ADDRESS = /^[a-z][a-z0-9+.-]*:|\/\//i;
+/**
+ * A spec that names an address anywhere, by key or by value, or carries
+ * `usermeta`, whose `embedOptions` vega-embed merges over the app's own
+ * (`config` or `patch` as a URL is fetched, `actions` turns the export menu back on).
+ */
+function addressed(value) {
+    if (typeof value === 'string')
+        return ADDRESS.test(value.trim());
+    if (Array.isArray(value))
+        return value.some(addressed);
+    if (!isRecord(value))
+        return false;
+    return Object.entries(value).some(
+    // `$schema` names the spec's own version and is never drawn or fetched (`vega-chart` drops it).
+    ([key, inner]) => key !== '$schema' && (key === 'url' || key === 'href' || key === 'usermeta' || addressed(inner)));
+}
+const VIEWS = ['mark', 'layer', 'hconcat', 'vconcat', 'concat', 'facet', 'repeat'];
+function parseVega(source) {
+    const spec = object(source);
+    if (!VIEWS.some((key) => key in spec))
+        throw new Error('not a view');
+    if (addressed(spec))
+        throw new Error('names an address');
+    return spec;
+}
+function parseTimeline(source) {
+    const value = object(source);
+    if (!Array.isArray(value.events))
+        throw new Error('no events');
+    return {
+        title: text(value.title),
+        events: value.events.map((event) => {
+            if (!isRecord(event) || !text(event.title))
+                throw new Error('an event with no title');
+            return { date: text(event.date), title: text(event.title), detail: text(event.detail) };
+        })
+    };
+}
+function parseCard(source) {
+    const value = object(source);
+    if (!text(value.name))
+        throw new Error('no name');
+    const facts = Array.isArray(value.facts) ? value.facts : [];
+    return {
+        name: text(value.name),
+        kind: text(value.kind),
+        summary: text(value.summary),
+        facts: facts
+            .filter(isRecord)
+            .map((fact) => ({ label: text(fact.label), value: text(fact.value) }))
+            .filter((fact) => fact.label || fact.value)
+    };
+}
+/** A chart, a timeline and an entity card. An app adds to these or replaces one through `ChatExtensions.visuals`. */
+export const defaultVisuals = {
+    'vega-lite': { component: VegaChart, parse: parseVega },
+    timeline: { component: Timeline, parse: parseTimeline },
+    card: { component: EntityCard, parse: parseCard }
+};

package/dist/web-sources.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The web pages an answer drew on, listed apart from the library's numbered
+ * sources: the pages the turn's supacrawl calls read, and the Markdown links
+ * in the answer itself. A search's results are what it found, not what the
+ * answer drew on, so they stay in the search's own row (`searchPages`). The
+ * page numbers them after the library's, since the persona cites a page by its
+ * link and nothing here is a passage it was handed with a number.
+ */
+import type { Block, ToolBlock } from './transcript.svelte';
+export interface WebSource {
+    url: string;
+    /** The page's title, or its host where nothing gave one. */
+    title: string;
+    host: string;
+    /** The turn read this page whole (a scrape), rather than only linking it. */
+    read?: true;
+    /** The page's own date, as it gave it, where it gave one. */
+    date?: string;
+}
+/** A page a search found, for its step's expansion. */
+export interface FoundPage {
+    url: string;
+    title: string;
+    host: string;
+    snippet: string;
+}
+/** The key two spellings of one page share. */
+export declare const webKey: (url: string) => string;
+/** A URL's host without a leading `www.`; the text as given where it is no URL. */
+export declare function hostOf(url: string): string;
+/** The pages a successful web search step found. */
+export declare function searchPages(block: ToolBlock): FoundPage[];
+/** The pages, once each, in the order the turn met them. */
+export declare function webSources(blocks: Block[], answer: string): WebSource[];

package/dist/web-sources.js

@@ -0,0 +1,90 @@
+/**
+ * The web pages an answer drew on, listed apart from the library's numbered
+ * sources: the pages the turn's supacrawl calls read, and the Markdown links
+ * in the answer itself. A search's results are what it found, not what the
+ * answer drew on, so they stay in the search's own row (`searchPages`). The
+ * page numbers them after the library's, since the persona cites a page by its
+ * link and nothing here is a passage it was handed with a number.
+ */
+/** The key two spellings of one page share. */
+export const webKey = (url) => url.replace(/#.*$/, '').replace(/\/$/, '');
+/** A URL's host without a leading `www.`; the text as given where it is no URL. */
+export function hostOf(url) {
+    try {
+        return new URL(url).hostname.replace(/^www\./, '');
+    }
+    catch {
+        return url;
+    }
+}
+const LINK = /\[([^\]]+)\]\((https?:\/\/[^\s)]+)\)/g;
+function isWeb(url) {
+    return typeof url === 'string' && /^https?:\/\//i.test(url);
+}
+function parse(text) {
+    try {
+        return text ? JSON.parse(text) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The pages a successful web search step found. */
+export function searchPages(block) {
+    if (block.name !== 'mcp__supacrawl__supacrawl_search' || block.isError)
+        return [];
+    const found = parse(block.result);
+    if (!Array.isArray(found?.results))
+        return [];
+    const pages = [];
+    for (const item of found.results) {
+        if (typeof item !== 'object' || item === null || !isWeb(item.url))
+            continue;
+        const host = hostOf(item.url);
+        const title = [item.title, host].find((t) => typeof t === 'string' && t.trim());
+        const snippet = [item.snippet, item.description, item.content].find((t) => typeof t === 'string' && t.trim());
+        pages.push({ url: item.url, title: title.trim(), host, snippet: (snippet ?? '').trim() });
+    }
+    return pages;
+}
+function fromTool(block) {
+    if (!block.name.startsWith('mcp__supacrawl__') || !block.name.endsWith('_scrape') || block.isError)
+        return [];
+    const input = parse(block.rawInput);
+    if (!isWeb(input?.url))
+        return [];
+    const page = parse(block.result);
+    const title = [page?.title, page?.metadata?.title].find((t) => typeof t === 'string');
+    const date = [
+        page?.metadata?.publishedTime,
+        page?.metadata?.published,
+        page?.metadata?.date,
+        page?.metadata?.modifiedTime
+    ].find((d) => typeof d === 'string' && !Number.isNaN(Date.parse(d)));
+    return [{ url: input.url, title: title, date: date }];
+}
+/** The pages, once each, in the order the turn met them. */
+export function webSources(blocks, answer) {
+    const seen = new Map();
+    const add = (url, title, read) => {
+        const key = webKey(url);
+        if (seen.has(key))
+            return;
+        const host = hostOf(url);
+        if (host === url)
+            return;
+        seen.set(key, {
+            url,
+            title: title?.trim() || host,
+            host,
+            ...(read ? { read: true, date: read.date } : {})
+        });
+    };
+    for (const block of blocks)
+        if (block.kind === 'tool')
+            for (const p of fromTool(block))
+                add(p.url, p.title, { date: p.date });
+    for (const match of answer.matchAll(LINK))
+        add(match[2], match[1]);
+    return [...seen.values()];
+}

package/dist/written.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The documents a persona writes while it answers.
+ *
+ * The app emits an `artefact` frame after each successful Write or Edit, and a
+ * reopened conversation lists the same versions on its turns. The page shows
+ * each version in the reading column and links it for download; the bytes
+ * come from the host's own route, never from this package.
+ */
+import { type ChatCopy } from './copy';
+import type { Turn } from './transcript.svelte';
+/** One version of one document, as the wire names it. */
+export interface Written {
+    /** A path relative to the conversation's folder; may contain "/". */
+    name: string;
+    /** Counts per name from 1 across the whole conversation. */
+    version: number;
+    /** `text/markdown` or `text/html`. */
+    media_type: string;
+    bytes?: number;
+    /** What the app can render it as beyond the source (`docx`, `pdf`); empty
+     *  where it has no renderer. */
+    formats: string[];
+    /** What a reader calls it: "Minute: increased rent ceiling". */
+    title: string;
+    /** What sort of document it is ("minute"); null where nothing says. */
+    kind: string | null;
+    /** What this version changed since the one before it, in a phrase; null
+     *  for the first, or where nothing says. */
+    changes: string | null;
+    /** How many pages it runs to; 0 where the app cannot tell. */
+    pages: number;
+    /** When this page saw the version arrive, epoch ms. Absent for one read back. */
+    at?: number;
+}
+/** The source of one version, to show it in the pane. */
+export type LoadWritten = (name: string, version: number) => Promise<{
+    text: string;
+    mediaType: string;
+}>;
+/** Where one version downloads as `format` (`source` or one of its `formats`). */
+export type WrittenUrl = (name: string, version: number, format: string) => string;
+export declare const writtenKey: (written: Written) => string;
+export declare const isHtml: (mediaType: string) => boolean;
+/** The newest version of each document in `written`, in the order they first appear. */
+export declare function newestPerName(written: Written[]): Written[];
+/** "Minute", or "Document" where the document has no kind. */
+export declare function kindLabel(written: Written, words: ChatCopy): string;
+/** "Minute · 1 page · v1": kind, pages where known, version. */
+export declare function writtenMeta(written: Written, words: ChatCopy): string;
+/** The download a card's chip offers: Word where the app renders it, else the source as written. */
+export declare function chipFor(written: Written, words: ChatCopy): {
+    format: string;
+    file: string;
+    label: string;
+};
+/** A leading `---` front matter block is metadata, not the document. */
+export declare function stripFrontMatter(text: string): string;
+/** Every version of `name` across the conversation, oldest first. */
+export declare function writtenVersions(turns: Turn[], name: string): Written[];
+/** What a version downloads as: its source, then each format the app renders. */
+export declare function downloads(written: Written, words: ChatCopy): Array<{
+    format: string;
+    label: string;
+}>;
+/** An empty sandbox stops scripts, not fetches: a written page's <img> or CSS url() would be a beacon without this. */
+export declare const FRAME_CSP = "<meta http-equiv=\"Content-Security-Policy\" content=\"default-src 'none'; style-src 'unsafe-inline'; img-src data:; font-src data:\">";
+/**
+ * A written HTML page as its sandboxed frame shows it: under `FRAME_CSP`, and
+ * without a refresh, which navigates the frame itself, a fetch no policy stops.
+ */
+export declare function framed(html: string): string;