@poodle64/librarian 2026.10.3 → 2026.10.5

package/dist/components/visual-block/visual-block.svelte

@@ -0,0 +1,53 @@
+<!--
+  One fenced block of a language the host has a renderer for.
+
+  While its closing fence has not arrived the block is a placeholder: half a
+  JSON document is not a chart. A closed block is parsed by its renderer, and
+  one that will not parse is shown as the code it was, never a blank.
+-->
+<script lang="ts">
+	import type { ChatCopy } from '../../copy';
+	import type { Visual } from '../../visuals';
+
+	interface Props {
+		lang: string;
+		visual: Visual;
+		source: string;
+		closed: boolean;
+		streaming: boolean;
+		words: ChatCopy;
+	}
+
+	let { lang, visual, source, closed, streaming, words }: Props = $props();
+
+	const drawn = $derived.by(() => {
+		if (!closed) return null;
+		try {
+			return { value: visual.parse(source) };
+		} catch {
+			return null;
+		}
+	});
+	const Drawing = $derived(visual.component);
+</script>
+
+{#if !closed && streaming}
+	<p class="ds-lib-drawing" role="status">{words.drawing}</p>
+{:else if drawn}
+	<Drawing value={drawn.value} {source} />
+{:else}
+	<!-- Marked, so the highlighter that follows the prose leaves what this owns. -->
+	<pre data-highlighted="true"><code class="language-{lang}">{source}</code></pre>
+{/if}
+
+<style>
+	.ds-lib-drawing {
+		margin: 0.75em 0;
+		border: 1px dashed var(--ds-color-border);
+		border-radius: var(--ds-radius-lg);
+		padding: 1.25rem 1rem;
+		color: var(--ds-color-muted-foreground);
+		font-size: 0.875rem;
+		text-align: center;
+	}
+</style>

package/dist/components/visual-block/visual-block.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { ChatCopy } from '../../copy';
+import type { Visual } from '../../visuals';
+interface Props {
+    lang: string;
+    visual: Visual;
+    source: string;
+    closed: boolean;
+    streaming: boolean;
+    words: ChatCopy;
+}
+declare const VisualBlock: import("svelte").Component<Props, {}, "">;
+type VisualBlock = ReturnType<typeof VisualBlock>;
+export default VisualBlock;

package/dist/components/written-card/index.d.ts

@@ -0,0 +1,2 @@
+export { default as WrittenCard } from './written-card.svelte';
+export { default } from './written-card.svelte';

package/dist/components/written-card/index.js

@@ -0,0 +1,2 @@
+export { default as WrittenCard } from './written-card.svelte';
+export { default } from './written-card.svelte';

package/dist/components/written-card/written-card.svelte

@@ -0,0 +1,178 @@
+<!--
+  A document the persona wrote, as a card in the turn: a page icon, its title,
+  "Minute · 1 page · v1" and Open (the reading column shows that version),
+  with a chip under it that downloads it: Word where the app renders one, else
+  the source as written.
+-->
+<script lang="ts">
+	import DownloadIcon from '@lucide/svelte/icons/download';
+	import FileTextIcon from '@lucide/svelte/icons/file-text';
+	import { fill, resolveCopy, type ChatCopy } from '../../copy';
+	import { chipFor, writtenMeta, type Written, type WrittenUrl } from '../../written';
+
+	interface Props {
+		written: Written;
+		/** The column is showing this version now. */
+		open?: boolean;
+		/** Omit and the card lists and links but does not open. */
+		onopen?: () => void;
+		/** Omit and no download chip renders. */
+		url?: WrittenUrl;
+		copy?: Partial<ChatCopy>;
+	}
+
+	let { written, open = false, onopen, url, copy }: Props = $props();
+
+	const words = $derived(resolveCopy(copy));
+	const chip = $derived(chipFor(written, words));
+</script>
+
+<div class="ds-lib-written">
+	<div class="ds-lib-written-card" class:is-open={open}>
+		<span class="ds-lib-written-icon" aria-hidden="true"><FileTextIcon size={20} /></span>
+		<span class="ds-lib-written-text">
+			<span class="ds-lib-written-name">{written.title}</span>
+			<span class="ds-lib-written-meta">{writtenMeta(written, words)}</span>
+		</span>
+		{#if onopen}
+			<button type="button" class="ds-lib-written-open" onclick={onopen}>
+				{open ? words.showingArtefact : words.openArtefact}
+			</button>
+		{/if}
+	</div>
+	{#if url}
+		<a
+			class="ds-lib-written-chip"
+			href={url(written.name, written.version, chip.format)}
+			download={chip.file}
+		>
+			<FileTextIcon size={14} aria-hidden="true" />
+			<span class="ds-lib-written-file">{chip.file}</span>
+			<span class="ds-lib-written-format">
+				{chip.label} · {fill(words.writtenVersion, { n: written.version })}
+			</span>
+			<span class="ds-lib-written-download">
+				<DownloadIcon size={14} aria-hidden="true" />{words.download}
+			</span>
+		</a>
+	{/if}
+</div>
+
+<style>
+	.ds-lib-written {
+		display: flex;
+		flex-direction: column;
+		align-items: flex-start;
+		gap: 0.5rem;
+	}
+
+	.ds-lib-written-card {
+		display: flex;
+		width: 100%;
+		max-width: 36rem;
+		align-items: center;
+		gap: 0.75rem;
+		border: 1px solid var(--ds-color-border);
+		border-radius: var(--ds-radius-lg);
+		background: var(--ds-color-surface-1);
+		padding: 0.625rem 0.75rem;
+	}
+
+	.ds-lib-written-card.is-open {
+		border-color: var(--ds-color-primary);
+	}
+
+	/* A sheet of paper: light in either theme, as the document is. */
+	.ds-lib-written-icon {
+		display: flex;
+		width: 2.5rem;
+		height: 2.75rem;
+		flex: none;
+		align-items: center;
+		justify-content: center;
+		border-radius: var(--ds-radius-sm);
+		background: var(--ds-paper, #f1f1ef);
+		color: var(--ds-paper-ink, #1c1c1c);
+	}
+
+	.ds-lib-written-text {
+		display: flex;
+		min-width: 0;
+		flex: 1;
+		flex-direction: column;
+	}
+
+	.ds-lib-written-name {
+		font-size: 0.9375rem;
+		font-weight: 600;
+		line-height: 1.25rem;
+		overflow-wrap: anywhere;
+	}
+
+	.ds-lib-written-meta {
+		color: var(--ds-color-muted-foreground);
+		font-size: var(--ds-text-2xs);
+	}
+
+	.ds-lib-written-open {
+		flex: none;
+		border: 0;
+		border-radius: var(--ds-radius-md);
+		background: none;
+		padding: 0.5rem 0.625rem;
+		color: var(--ds-color-muted-foreground);
+		font: inherit;
+		font-size: 0.8125rem;
+		cursor: pointer;
+	}
+
+	.ds-lib-written-open:hover {
+		color: var(--ds-color-foreground);
+	}
+
+	.ds-lib-written-open:focus-visible,
+	.ds-lib-written-chip:focus-visible {
+		outline: 2px solid var(--ds-color-ring);
+		outline-offset: 2px;
+	}
+
+	.ds-lib-written-chip {
+		display: inline-flex;
+		max-width: 100%;
+		min-height: 2.25rem;
+		align-items: center;
+		gap: 0.5rem;
+		border: 1px solid var(--ds-color-border);
+		border-radius: var(--ds-radius-full);
+		padding: 0.25rem 0.75rem;
+		color: var(--ds-color-foreground);
+		font-size: 0.8125rem;
+		text-decoration: none;
+	}
+
+	.ds-lib-written-chip:hover {
+		background: var(--ds-color-surface-2);
+	}
+
+	.ds-lib-written-file {
+		min-width: 0;
+		font-weight: 600;
+		overflow-wrap: anywhere;
+	}
+
+	.ds-lib-written-format {
+		color: var(--ds-color-muted-foreground);
+		font-size: var(--ds-text-2xs);
+		white-space: nowrap;
+	}
+
+	.ds-lib-written-download {
+		display: inline-flex;
+		align-items: center;
+		gap: 0.25rem;
+		border-inline-start: 1px solid var(--ds-color-border);
+		padding-inline-start: 0.5rem;
+		font-size: var(--ds-text-2xs);
+		white-space: nowrap;
+	}
+</style>

package/dist/components/written-card/written-card.svelte.d.ts

@@ -0,0 +1,15 @@
+import { type ChatCopy } from '../../copy';
+import { type Written, type WrittenUrl } from '../../written';
+interface Props {
+    written: Written;
+    /** The column is showing this version now. */
+    open?: boolean;
+    /** Omit and the card lists and links but does not open. */
+    onopen?: () => void;
+    /** Omit and no download chip renders. */
+    url?: WrittenUrl;
+    copy?: Partial<ChatCopy>;
+}
+declare const WrittenCard: import("svelte").Component<Props, {}, "">;
+type WrittenCard = ReturnType<typeof WrittenCard>;
+export default WrittenCard;

package/dist/copy.d.ts

@@ -69,6 +69,79 @@ export interface ChatCopy {
     showingArtefact: string;
     /** Beside the clock on an answer this page did not start. */
     stillAnswering: string;
+    /** An expanded tool step: what went in, what came back, and a call that failed. */
+    stepInput: string;
+    stepResult: string;
+    stepFailed: string;
+    /** Editing a question already asked: the control, the send, and what the
+     *  edit does not carry. */
+    editQuestion: string;
+    editSend: string;
+    editFilesNote: string;
+    /** The fold over a turn's steps: its sentence is composed from the steps,
+     *  each phrase lower-case and joined by `stepsAnd` ("Read your attachment,
+     *  searched the library and the web, and wrote a minute"). `{kind}` is the
+     *  document's own kind, or `documentKind`. */
+    stepsRead: string;
+    stepsSearchedLibrary: string;
+    stepsSearchedWeb: string;
+    stepsSearchedBoth: string;
+    stepsOpened: string;
+    stepsWrote: string;
+    stepsEdited: string;
+    stepsThought: string;
+    stepsOther: string;
+    stepsAnd: string;
+    /** What is happening now, while the turn runs. */
+    nowRead: string;
+    nowLibrary: string;
+    nowWeb: string;
+    nowOpen: string;
+    nowWrite: string;
+    nowEdit: string;
+    nowThought: string;
+    nowOther: string;
+    stepCount: string;
+    stepCountOne: string;
+    /** The right-hand count of a step's row. */
+    stepFound: string;
+    stepPagesRead: string;
+    stepPageRead: string;
+    /** A thinking row: while it streams, once done, and with its duration. */
+    thinking: string;
+    thought: string;
+    thoughtFor: string;
+    /** The kind of a document that names none. */
+    documentKind: string;
+    pagesCount: string;
+    pageCount: string;
+    /** The pane: when a version was written, what changed, and copying it. */
+    paneWritten: string;
+    paneEdited: string;
+    justNow: string;
+    changedSince: string;
+    copyDocument: string;
+    copiedDocument: string;
+    /** The sources fold: its summary and its two groups. */
+    sourcesCount: string;
+    sourcesCountOne: string;
+    sourcesLibrary: string;
+    sourcesWeb: string;
+    fromTheLibrary: string;
+    readToday: string;
+    readOn: string;
+    /** A fenced block still being written. */
+    drawing: string;
+    /** Web pages an answer drew on, listed apart from its numbered sources. */
+    fromTheWeb: string;
+    /** A document the persona wrote: its version (`{n}`), the version switcher's
+     *  name, and what each download is called. */
+    writtenVersion: string;
+    writtenVersions: string;
+    formatMarkdown: string;
+    formatHtml: string;
+    formatWord: string;
+    formatPdf: string;
     /** The answer mark: the two verdicts, the optional note, and after. */
     markHelpful: string;
     markNotHelpful: string;

package/dist/copy.js

@@ -80,6 +80,62 @@ export function copyFor(name = DEFAULT_PERSONA) {
         openArtefact: 'Open',
         showingArtefact: 'Showing',
         stillAnswering: `${who} is still answering`,
+        stepInput: 'Input',
+        stepResult: 'Result',
+        stepFailed: 'Failed',
+        editQuestion: 'Edit',
+        editSend: 'Send',
+        editFilesNote: 'Files attached to the original question are not sent again.',
+        stepsRead: 'read your attachment',
+        stepsSearchedLibrary: 'searched the library',
+        stepsSearchedWeb: 'searched the web',
+        stepsSearchedBoth: 'searched the library and the web',
+        stepsOpened: 'opened a document',
+        stepsWrote: 'wrote a {kind}',
+        stepsEdited: 'edited the {kind}',
+        stepsThought: 'thought',
+        stepsOther: 'looked into it',
+        stepsAnd: 'and',
+        nowRead: 'Reading your attachment…',
+        nowLibrary: 'Searching the library…',
+        nowWeb: 'Searching the web…',
+        nowOpen: 'Opening a document…',
+        nowWrite: 'Writing a {kind}…',
+        nowEdit: 'Editing the {kind}…',
+        nowThought: 'Thinking…',
+        nowOther: 'Working on it…',
+        stepCount: '{n} steps',
+        stepCountOne: '1 step',
+        stepFound: '{n} found',
+        stepPagesRead: '{n} pages read',
+        stepPageRead: '1 page read',
+        thinking: 'Thinking…',
+        thought: 'Thought',
+        thoughtFor: 'Thought for {n}s',
+        documentKind: 'document',
+        pagesCount: '{n} pages',
+        pageCount: '1 page',
+        paneWritten: 'written {when}',
+        paneEdited: 'edited {when}',
+        justNow: 'just now',
+        changedSince: 'Changed since v{n}: {changes}',
+        copyDocument: 'Copy',
+        copiedDocument: 'Copied',
+        sourcesCount: '{n} sources',
+        sourcesCountOne: '1 source',
+        sourcesLibrary: '{n} library',
+        sourcesWeb: '{n} web',
+        fromTheLibrary: 'From the library',
+        readToday: 'read today',
+        readOn: 'read {date}',
+        drawing: 'Drawing…',
+        fromTheWeb: 'From the web',
+        writtenVersion: 'v{n}',
+        writtenVersions: 'Version',
+        formatMarkdown: 'Markdown',
+        formatHtml: 'HTML',
+        formatWord: 'Word',
+        formatPdf: 'PDF',
         markHelpful: 'Helpful',
         markNotHelpful: 'Not helpful',
         markNote: 'Anything to add? (optional)',

package/dist/diff.d.ts

@@ -0,0 +1,8 @@
+/**
+ * What a version changed, read off the rendered document: each block of the
+ * new one that the old one has no block of the same text for is marked
+ * `data-changed`, for a bar beside it. A block is a top-level paragraph,
+ * heading, quote or code block, a list item, or a table row.
+ */
+/** Mark each block of `now` that `before` has no block of the same text for, on the DOM `render` sanitised. */
+export declare function markChanges(now: Element, before: Element): void;

package/dist/diff.js

@@ -0,0 +1,37 @@
+/**
+ * What a version changed, read off the rendered document: each block of the
+ * new one that the old one has no block of the same text for is marked
+ * `data-changed`, for a bar beside it. A block is a top-level paragraph,
+ * heading, quote or code block, a list item, or a table row.
+ */
+function blocksOf(body) {
+    const blocks = [];
+    for (const el of body.children) {
+        if (el.tagName === 'UL' || el.tagName === 'OL')
+            blocks.push(...el.querySelectorAll(':scope > li'));
+        else if (el.tagName === 'TABLE')
+            blocks.push(...el.querySelectorAll('tr'));
+        else
+            blocks.push(el);
+    }
+    return blocks;
+}
+const textOf = (el) => (el.textContent ?? '').replace(/\s+/g, ' ').trim();
+/** Mark each block of `now` that `before` has no block of the same text for, on the DOM `render` sanitised. */
+export function markChanges(now, before) {
+    const held = new Map();
+    for (const block of blocksOf(before)) {
+        const text = textOf(block);
+        held.set(text, (held.get(text) ?? 0) + 1);
+    }
+    for (const block of blocksOf(now)) {
+        const text = textOf(block);
+        if (!text)
+            continue;
+        const left = held.get(text) ?? 0;
+        if (left > 0)
+            held.set(text, left - 1);
+        else
+            block.setAttribute('data-changed', '');
+    }
+}

package/dist/steps.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A turn's steps, said in one sentence.
+ *
+ * The turn folds its steps behind one line composed from them ("Read your
+ * attachment, searched the library and the web, and wrote a minute"), the way
+ * Claude.ai folds its own. Composed here from what each step IS (its tool and,
+ * for a document, the document's own kind), never from the persona's words.
+ */
+import { type ChatCopy } from './copy';
+import type { ActivityStep, Block } from './transcript.svelte';
+import type { Written } from './written';
+export type StepKind = 'attachment' | 'library' | 'web' | 'open' | 'write' | 'edit' | 'thought' | 'other';
+/** What sort of step a block is. */
+export declare function stepKind(block: Block): StepKind;
+/**
+ * The fold's line: the sentence, and what trails it ("6 steps", or the
+ * version a lone edit made).
+ */
+export declare function stepsSummary(steps: ActivityStep[], written: Written[], words: ChatCopy): {
+    sentence: string;
+    trail: string;
+};
+/** What is happening now: the step still running, or the latest one. */
+export declare function stepsNow(steps: ActivityStep[], written: Written[], words: ChatCopy): string;
+/** The count at a step's right hand, where its result shows one. */
+export declare function stepMeta(block: Block, words: ChatCopy): string;
+/** How long a thinking block ran, in whole seconds, where it was timed. */
+export declare function thoughtSeconds(block: Block): number | undefined;

package/dist/steps.js

@@ -0,0 +1,168 @@
+/**
+ * A turn's steps, said in one sentence.
+ *
+ * The turn folds its steps behind one line composed from them ("Read your
+ * attachment, searched the library and the web, and wrote a minute"), the way
+ * Claude.ai folds its own. Composed here from what each step IS (its tool and,
+ * for a document, the document's own kind), never from the persona's words.
+ */
+import { fill } from './copy';
+const WEB = new Set(['mcp__supacrawl__supacrawl_search', 'mcp__supacrawl__supacrawl_scrape']);
+/** What sort of step a block is. */
+export function stepKind(block) {
+    if (block.kind !== 'tool')
+        return 'thought';
+    const { name } = block;
+    if (name === 'mcp__library__search')
+        return 'library';
+    if (name === 'mcp__library__document_content' || name === 'mcp__library__document_detail')
+        return 'open';
+    if (WEB.has(name))
+        return 'web';
+    if (name === 'Write')
+        return 'write';
+    if (name === 'Edit')
+        return 'edit';
+    if (name.startsWith('mcp__') && name.endsWith('__ocr'))
+        return 'attachment';
+    if (name === 'Read') {
+        // A staged library page reads as a document opened; anything else Read
+        // takes is what the person attached.
+        const path = pathOf(block);
+        return /page-\d+\.md$/.test(path) ? 'open' : 'attachment';
+    }
+    return 'other';
+}
+function inputOf(block) {
+    try {
+        const parsed = JSON.parse(block.rawInput);
+        return typeof parsed === 'object' && parsed !== null ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+const pathOf = (block) => {
+    const input = inputOf(block);
+    const path = input.file_path ?? input.path;
+    return typeof path === 'string' ? path : '';
+};
+/** The document a Write or Edit step made a version of, by the name it wrote to. */
+function documentOf(block, written) {
+    const path = pathOf(block);
+    if (!path)
+        return undefined;
+    return written.filter((w) => path === w.name || path.endsWith(`/${w.name}`)).at(-1);
+}
+const kindWord = (doc, words) => ((doc?.kind ?? '').trim() || words.documentKind).toLowerCase();
+const upper = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+function join(phrases, and) {
+    if (phrases.length <= 2)
+        return phrases.join(` ${and} `);
+    return `${phrases.slice(0, -1).join(', ')}, ${and} ${phrases.at(-1)}`;
+}
+/**
+ * The fold's line: the sentence, and what trails it ("6 steps", or the
+ * version a lone edit made).
+ */
+export function stepsSummary(steps, written, words) {
+    let library = false;
+    let web = false;
+    let searchAt = -1;
+    const phrases = [];
+    const add = (phrase) => {
+        if (!phrases.includes(phrase))
+            phrases.push(phrase);
+    };
+    for (const { block } of steps) {
+        const kind = stepKind(block);
+        const doc = block.kind === 'tool' ? documentOf(block, written) : undefined;
+        if (kind === 'library' || kind === 'web') {
+            if (kind === 'library')
+                library = true;
+            else
+                web = true;
+            if (searchAt < 0) {
+                searchAt = phrases.length;
+                phrases.push('');
+            }
+        }
+        else if (kind === 'attachment')
+            add(words.stepsRead);
+        else if (kind === 'open')
+            add(words.stepsOpened);
+        else if (kind === 'write')
+            add(fill(words.stepsWrote, { kind: kindWord(doc, words) }));
+        else if (kind === 'edit')
+            add(fill(words.stepsEdited, { kind: kindWord(doc, words) }));
+        else if (kind === 'other')
+            add(words.stepsOther);
+    }
+    if (searchAt >= 0)
+        phrases[searchAt] =
+            library && web ? words.stepsSearchedBoth : library ? words.stepsSearchedLibrary : words.stepsSearchedWeb;
+    // Thinking is told only where it is all there was.
+    if (phrases.length === 0)
+        phrases.push(words.stepsThought);
+    const only = steps.length === 1 ? steps[0].block : undefined;
+    const lone = only?.kind === 'tool' && stepKind(only) === 'edit' ? documentOf(only, written) : undefined;
+    return {
+        sentence: upper(join(phrases, words.stepsAnd)),
+        trail: lone
+            ? fill(words.writtenVersion, { n: lone.version })
+            : steps.length === 1
+                ? words.stepCountOne
+                : fill(words.stepCount, { n: steps.length })
+    };
+}
+/** What is happening now: the step still running, or the latest one. */
+export function stepsNow(steps, written, words) {
+    const step = steps.findLast(({ block }) => block.kind === 'tool' && block.result === undefined)
+        ?? steps.at(-1);
+    if (!step)
+        return words.nowOther;
+    const kind = stepKind(step.block);
+    const doc = step.block.kind === 'tool' ? documentOf(step.block, written) : undefined;
+    const now = {
+        attachment: words.nowRead,
+        library: words.nowLibrary,
+        web: words.nowWeb,
+        open: words.nowOpen,
+        write: fill(words.nowWrite, { kind: kindWord(doc, words) }),
+        edit: fill(words.nowEdit, { kind: kindWord(doc, words) }),
+        thought: words.nowThought,
+        other: words.nowOther
+    };
+    return now[kind];
+}
+function parse(text) {
+    try {
+        return text ? JSON.parse(text) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The count at a step's right hand, where its result shows one. */
+export function stepMeta(block, words) {
+    if (block.kind !== 'tool' || block.isError || block.result === undefined)
+        return '';
+    if (block.name === 'mcp__library__search') {
+        const found = parse(block.result);
+        const list = Array.isArray(found) ? found : (found?.hits ?? found?.results);
+        return Array.isArray(list) ? fill(words.stepFound, { n: list.length }) : '';
+    }
+    if (block.name === 'mcp__supacrawl__supacrawl_search') {
+        const found = parse(block.result)?.results;
+        if (!Array.isArray(found))
+            return '';
+        return found.length === 1 ? words.stepPageRead : fill(words.stepPagesRead, { n: found.length });
+    }
+    return '';
+}
+/** How long a thinking block ran, in whole seconds, where it was timed. */
+export function thoughtSeconds(block) {
+    if (block.kind !== 'thinking' || block.startedAt === undefined || block.endedAt === undefined)
+        return undefined;
+    return Math.max(1, Math.round((block.endedAt - block.startedAt) / 1000));
+}