@poodle64/librarian 2026.9.26 → 2026.9.27

package/README.md

@@ -29,6 +29,7 @@ src/lib/
     conversation/          the whole reading surface: scroll, pill, pane, composer slot
     conversation-list/     past conversations, newest first: reopen, rename, download, delete
     answer-mark/           helpful or not, with a note, on the last answer
+    answer-share/          share an answer read-only, and stop sharing it
     fair-use-notice/       today's allowance, beside the composer
     scope-statement/       what this room answers from, and what it does not hold
     agent-transcript/      one question and everything Milton did answering it
@@ -308,6 +309,7 @@ the transport passes them through:
 | `remove`        | `DELETE conversations/{id}`                           |
 | `download`      | `GET conversations/{id}/export`, as `{ name, body }`  |
 | `mark`          | its answer mark, where the agent takes one (optional) |
+| `share`         | share an answer read-only, or stop (optional)         |
 
 What the controller relies on the routes to say:
 
@@ -339,6 +341,8 @@ the job may go on by itself; `sendWhileRunning` is true.
 | Concern                  | How                                                                                                                                              |
 | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------ |
 | The answer mark          | `onmark(turn, verdict)` on `Conversation`: resolve true once recorded. Offered on the last settled answer only; without it no mark renders       |
+| Sharing an answer        | `onshare(turn, share)` on `Conversation`, over `chat.share`: every settled answer offers Share, which copies the link `StoredTurn.shared` names; a shared one offers Copy link and Stop sharing. Nothing is shared unless the reader asks. A host's own `turn` places `AnswerShare` (`./answer-share`) with the `onshare` and `shared` it is handed |
+| A shared answer, read    | `Conversation` given `[storedTurn(id, 0, answer)]` from `./chat` and no handlers, no composer: the question, the answer and its sources, read-only, citations opening as in the room |
 | Waiting, still answering | `waiting` and `answering` on `Conversation`, from the controller                                                                                 |
 | The allowance            | `FairUseNotice quota={…}` in the composer snippet: a count while there are questions left, a notice with `support_url` once there are none. Nothing for `exempt`, or a `limit` of 0 |
 | Past conversations       | `ConversationList`: newest first, `href` makes each row a link, and each act renders only when its handler is given; a delete asks first        |

package/dist/chat.svelte.d.ts

@@ -45,6 +45,8 @@ export interface StoredTurn {
     kind?: string | null;
     /** How hard the persona worked on this one. */
     depth?: Depth | null;
+    /** Where this answer's read-only view lives while it is shared. */
+    shared?: string | null;
 }
 /** A conversation reopened. */
 export interface ConversationRead extends ConversationSummary {
@@ -107,6 +109,10 @@ export interface RoomTransport {
     /** The answer mark, where the agent takes one. `turn` is the answer's
      *  zero-based position in the conversation. */
     mark?(id: string, turn: number, verdict: Verdict): Promise<void>;
+    /** Shares answer `turn` read-only with whoever may enter the room, or
+     *  stops sharing it. Resolves to where it is read while shared, null once
+     *  it is not. */
+    share?(id: string, turn: number, share: boolean): Promise<string | null>;
 }
 /** A job's routes. */
 export interface JobTransport {
@@ -199,4 +205,10 @@ export declare class Chat {
     download(id: string): Promise<boolean>;
     /** Mark an answer the agent holds. False when it could not be recorded. */
     mark(turn: Turn, verdict: Verdict): Promise<boolean>;
+    /** Share an answer the agent holds, or stop sharing it. False when that
+     *  was not recorded. */
+    share(turn: Turn, share: boolean): Promise<boolean>;
 }
+/** A turn as read back, ready for `Conversation`: given one and no handlers,
+ *  that is the read-only view of a shared answer. */
+export declare function storedTurn(conversation: string, index: number, stored: StoredTurn): Turn;

package/dist/chat.svelte.js

@@ -62,6 +62,8 @@ export class Chat {
     #watch = null;
     #woken = false;
     #wake = null;
+    // The turns the server recorded, which its routes count by place; a mark
+    // or a share on one still being written is the server's to refuse.
     // Plain, as `Session`'s seen-set: nothing renders it.
     // eslint-disable-next-line svelte/prefer-svelte-reactivity
     #held = new Set();
@@ -279,15 +281,33 @@ export class Chat {
         const id = this.conversationId;
         if (!id || !this.#room?.mark || !this.#held.has(turn.id))
             return false;
-        const position = this.turns.filter((t) => this.#held.has(t.id)).findIndex((t) => t.id === turn.id);
         try {
-            await this.#room.mark(id, position, verdict);
+            await this.#room.mark(id, this.#position(turn), verdict);
             return true;
         }
         catch {
             return false;
         }
     }
+    /** Share an answer the agent holds, or stop sharing it. False when that
+     *  was not recorded. */
+    async share(turn, share) {
+        const id = this.conversationId;
+        if (!id || !this.#room?.share || !this.#held.has(turn.id))
+            return false;
+        try {
+            turn.shared = (await this.#room.share(id, this.#position(turn), share)) ?? undefined;
+            this.#version += 1;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** A turn's place among the questions the agent was asked: the server's count. */
+    #position(turn) {
+        return this.turns.filter((t) => this.#held.has(t.id)).findIndex((t) => t.id === turn.id);
+    }
     #leave() {
         this.#generation += 1;
         // A stop still waiting to be addressed is carried on the stream it
@@ -547,7 +567,9 @@ export class Chat {
         return true;
     }
 }
-function storedTurn(conversation, index, stored) {
+/** A turn as read back, ready for `Conversation`: given one and no handlers,
+ *  that is the read-only view of a shared answer. */
+export function storedTurn(conversation, index, stored) {
     return {
         id: `${conversation}:${index}`,
         question: stored.question,
@@ -556,7 +578,8 @@ function storedTurn(conversation, index, stored) {
         outcome: null,
         citations: stored.citations ?? [],
         kind: stored.kind ?? undefined,
-        depth: stored.depth ?? undefined
+        depth: stored.depth ?? undefined,
+        shared: stored.shared ?? undefined
     };
 }
 function epoch(value) {

package/dist/components/agent-transcript/agent-transcript.svelte

@@ -37,6 +37,7 @@
 	import { DEFAULT_PERSONA, personaName, resolveCopy, type LibrarianCopy } from '../../copy';
 	import type { Verdict } from '../../chat.svelte';
 	import AnswerMark from '../answer-mark/answer-mark.svelte';
+	import AnswerShare from '../answer-share/answer-share.svelte';
 	import Working from '../working/working.svelte';
 	import ActivityGroup from '../activity-group/activity-group.svelte';
 	import ArtefactCard from '../artefact-card/artefact-card.svelte';
@@ -90,6 +91,13 @@
 		/** Records a verdict on this answer. Omit and no mark renders: a
 		 *  control that records nothing is worse than none. */
 		onmark?: (verdict: Verdict) => Promise<boolean>;
+		/** Where this answer's read-only view lives while it is shared, as the
+		 *  host's own address. */
+		shared?: string;
+		/** Shares this answer (true) or stops sharing it (false), resolving
+		 *  true once recorded. Omit and nothing about sharing renders: nothing
+		 *  is shared unless the reader asks. */
+		onshare?: (share: boolean) => Promise<boolean>;
 		/** How hard the persona worked on this one, for the footer's cost line
 		 *  (`Quick · 56 s · about A$0.34`). Absent renders the footer exactly
 		 *  as it always has: the duration alone. */
@@ -121,6 +129,8 @@
 		waiting = false,
 		answering,
 		onmark,
+		shared,
+		onshare,
 		depth,
 		formatCost
 	}: AgentTranscriptProps = $props();
@@ -373,6 +383,9 @@
 						<span>{copied ? words.copiedAnswer : words.copyAnswer}</span>
 					</button>
 				{/if}
+				{#if onshare && hasAnswer && !failure}
+					<AnswerShare {onshare} {shared} copy={words} />
+				{/if}
 				{#if onmark && hasAnswer && !failure}
 					<AnswerMark {onmark} copy={words} />
 				{/if}
@@ -570,8 +583,10 @@
 		color: var(--ds-color-muted-foreground);
 	}
 
+	/* 44px tall: each is a thumb's target on a phone. */
 	.ds-lib-action {
 		display: flex;
+		min-height: 2.75rem;
 		align-items: center;
 		gap: 0.375rem;
 		border: 0;

package/dist/components/agent-transcript/agent-transcript.svelte.d.ts

@@ -49,6 +49,13 @@ export interface AgentTranscriptProps {
     /** Records a verdict on this answer. Omit and no mark renders: a
      *  control that records nothing is worse than none. */
     onmark?: (verdict: Verdict) => Promise<boolean>;
+    /** Where this answer's read-only view lives while it is shared, as the
+     *  host's own address. */
+    shared?: string;
+    /** Shares this answer (true) or stops sharing it (false), resolving
+     *  true once recorded. Omit and nothing about sharing renders: nothing
+     *  is shared unless the reader asks. */
+    onshare?: (share: boolean) => Promise<boolean>;
     /** How hard the persona worked on this one, for the footer's cost line
      *  (`Quick · 56 s · about A$0.34`). Absent renders the footer exactly
      *  as it always has: the duration alone. */

package/dist/components/answer-share/answer-share.svelte

@@ -0,0 +1,129 @@
+<!--
+  Share one answer read-only with whoever may ask here, and stop sharing it.
+
+  Rendered by `AgentTranscript` in its action row, and by a host's own turn
+  beside its own presentation, only when the host passes `onshare`: nothing
+  is shared unless the reader asks. A share copies its link at once; a
+  browser that refuses a copy after the round trip (Safari) still has "Copy
+  link". Several roots, as `AnswerMark`: the buttons sit in the row, and the
+  line saying who can open it drops under it.
+-->
+<script lang="ts">
+	import { tick } from 'svelte';
+	import CheckIcon from '@lucide/svelte/icons/check';
+	import LinkIcon from '@lucide/svelte/icons/link';
+	import Share2Icon from '@lucide/svelte/icons/share-2';
+	import { resolveCopy, type LibrarianCopy } from '../../copy';
+
+	interface Props {
+		/** Shares the answer (true) or stops sharing it (false), resolving true
+		 *  once recorded. */
+		onshare: (share: boolean) => Promise<boolean>;
+		/** Where the read-only view lives while the answer is shared, as the
+		 *  host's own address. */
+		shared?: string;
+		copy?: Partial<LibrarianCopy>;
+	}
+
+	let { onshare, shared, copy }: Props = $props();
+
+	const words = $derived(resolveCopy(copy));
+
+	let saving = $state(false);
+	let failed = $state(false);
+	let copied = $state(false);
+
+	async function send(share: boolean) {
+		if (saving) return;
+		saving = true;
+		failed = false;
+		try {
+			failed = !(await onshare(share));
+		} finally {
+			saving = false;
+		}
+		if (share && !failed) {
+			await tick();
+			await copyLink();
+		}
+	}
+
+	async function copyLink() {
+		if (!shared) return;
+		try {
+			await navigator.clipboard.writeText(new URL(shared, location.href).href);
+			copied = true;
+			setTimeout(() => (copied = false), 1600);
+		} catch {
+			// Refused; "Copy link" is still there to tap.
+		}
+	}
+</script>
+
+{#if shared}
+	<button type="button" class="ds-lib-share" onclick={copyLink} disabled={saving}>
+		{#if copied}<CheckIcon size={14} />{:else}<LinkIcon size={14} />{/if}
+		<span>{copied ? words.linkCopied : words.copyLink}</span>
+	</button>
+	<button type="button" class="ds-lib-share" onclick={() => send(false)} disabled={saving}>
+		<span>{words.stopSharing}</span>
+	</button>
+{:else}
+	<button type="button" class="ds-lib-share" onclick={() => send(true)} disabled={saving}>
+		<Share2Icon size={14} />
+		<span>{words.share}</span>
+	</button>
+{/if}
+{#if shared || failed}
+	<p class="ds-lib-share-line" class:is-failed={failed} role="status">
+		{failed ? words.shareFailed : words.sharedWith}
+	</p>
+{/if}
+
+<style>
+	/* 44px tall: a thumb's target on a phone. */
+	.ds-lib-share {
+		display: flex;
+		min-height: 2.75rem;
+		align-items: center;
+		gap: 0.375rem;
+		border: 0;
+		border-radius: var(--ds-radius-md);
+		background: none;
+		padding: 0.25rem 0.375rem;
+		color: inherit;
+		font: inherit;
+		font-size: var(--ds-text-2xs);
+		cursor: pointer;
+		transition:
+			color 150ms ease,
+			background-color 150ms ease;
+	}
+
+	.ds-lib-share:hover:not(:disabled) {
+		background: var(--ds-color-surface-1);
+		color: var(--ds-color-foreground);
+	}
+
+	.ds-lib-share:disabled {
+		cursor: default;
+		opacity: 0.6;
+	}
+
+	.ds-lib-share:focus-visible {
+		outline: 2px solid var(--ds-color-ring);
+		outline-offset: 2px;
+	}
+
+	/* Its own line under the row, whatever sits after the buttons in it. */
+	.ds-lib-share-line {
+		order: 1;
+		flex-basis: 100%;
+		margin: 0 0 0 0.375rem;
+		font-size: var(--ds-text-2xs);
+	}
+
+	.ds-lib-share-line.is-failed {
+		color: var(--ds-color-status-error);
+	}
+</style>

package/dist/components/answer-share/answer-share.svelte.d.ts

@@ -0,0 +1,13 @@
+import { type LibrarianCopy } from '../../copy';
+interface Props {
+    /** Shares the answer (true) or stops sharing it (false), resolving true
+     *  once recorded. */
+    onshare: (share: boolean) => Promise<boolean>;
+    /** Where the read-only view lives while the answer is shared, as the
+     *  host's own address. */
+    shared?: string;
+    copy?: Partial<LibrarianCopy>;
+}
+declare const AnswerShare: import("svelte").Component<Props, {}, "">;
+type AnswerShare = ReturnType<typeof AnswerShare>;
+export default AnswerShare;

package/dist/components/answer-share/index.d.ts

@@ -0,0 +1,2 @@
+export { default as AnswerShare } from './answer-share.svelte';
+export { default } from './answer-share.svelte';

package/dist/components/answer-share/index.js

@@ -0,0 +1,2 @@
+export { default as AnswerShare } from './answer-share.svelte';
+export { default } from './answer-share.svelte';

package/dist/components/conversation/conversation.svelte

@@ -57,6 +57,9 @@
 		/** Records a verdict on an answer. Offered on the last answer only, as
 		 *  asking again is; without it no mark renders. */
 		onmark?: (turn: Turn, verdict: Verdict) => Promise<boolean>;
+		/** Shares an answer read-only, or stops sharing it (`Chat.share`).
+		 *  Offered on every settled answer; without it nothing is shareable. */
+		onshare?: (turn: Turn, share: boolean) => Promise<boolean>;
 		/** The last question waits behind somebody else's (`Chat.waiting`). */
 		waiting?: boolean;
 		/** When the last answer began, epoch ms, where this page did not see it
@@ -111,6 +114,7 @@
 		onregenerate,
 		onsuggest,
 		onmark,
+		onshare,
 		waiting = false,
 		answering = null,
 		copy,
@@ -323,7 +327,10 @@
 							onregenerate: last && !running ? onregenerate : undefined,
 							onsuggest: last && !running ? onsuggest : undefined,
 							onmark:
-								last && !running && onmark ? (verdict: Verdict) => onmark(turn, verdict) : undefined
+								last && !running && onmark ? (verdict: Verdict) => onmark(turn, verdict) : undefined,
+							shared: turn.shared,
+							onshare:
+								onshare && !(last && running) ? (share: boolean) => onshare(turn, share) : undefined
 						} satisfies AgentTranscriptProps}
 						{#if presentTurn}
 							{@render presentTurn(props)}

package/dist/components/conversation/conversation.svelte.d.ts

@@ -33,6 +33,9 @@ interface Props {
     /** Records a verdict on an answer. Offered on the last answer only, as
      *  asking again is; without it no mark renders. */
     onmark?: (turn: Turn, verdict: Verdict) => Promise<boolean>;
+    /** Shares an answer read-only, or stops sharing it (`Chat.share`).
+     *  Offered on every settled answer; without it nothing is shareable. */
+    onshare?: (turn: Turn, share: boolean) => Promise<boolean>;
     /** The last question waits behind somebody else's (`Chat.waiting`). */
     waiting?: boolean;
     /** When the last answer began, epoch ms, where this page did not see it

package/dist/copy.d.ts

@@ -80,6 +80,14 @@ export interface LibrarianCopy {
     markSend: string;
     markNoted: string;
     markFailed: string;
+    /** Sharing an answer: the action, once shared, who can open it, and a
+     *  share or a stop that did not go through. */
+    share: string;
+    copyLink: string;
+    linkCopied: string;
+    stopSharing: string;
+    sharedWith: string;
+    shareFailed: string;
     /** The fair-use notice, while there are questions left and once there are
      *  none, filled by `fill()`: `{resets}` is a time already, "midnight" or
      *  "2:00 pm". */

package/dist/copy.js

@@ -90,6 +90,12 @@ export function copyFor(name = DEFAULT_PERSONA) {
         markSend: 'Send',
         markNoted: 'Thanks, noted.',
         markFailed: "That couldn't be sent. Nothing was recorded.",
+        share: 'Share',
+        copyLink: 'Copy link',
+        linkCopied: 'Link copied',
+        stopSharing: 'Stop sharing',
+        sharedWith: `Shared: anyone who can ask ${who} here can open the link.`,
+        shareFailed: "That didn't go through. Try again.",
         // The industry wording, whole: the number, that it is a fair-use limit
         // rather than a fault, and when it comes back. No apology.
         questionsLeft: '{remaining} of {limit} questions left today. Resets at {resets}.',

package/dist/transcript.svelte.d.ts

@@ -213,6 +213,9 @@ export interface Turn {
     /** How hard the persona worked on this one, as `client.ask()` sent it.
      *  Absent, a host that never offers the choice. */
     depth?: Depth;
+    /** Where this answer's read-only view lives while it is shared, as the
+     *  host's own address. Absent while it is not. */
+    shared?: string;
 }
 /** A turn's artefact, in the host's own words. */
 export interface Artefact {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@poodle64/librarian",
-	"version": "2026.9.26",
+	"version": "2026.9.27",
 	"description": "An agent's conversation surface as a consumable Svelte 5 package: the stream client, transcript state and self-styling chat components (transcript, composer, markdown) every household app renders instead of rebuilding, speaking as whichever persona the app names.",
 	"type": "module",
 	"license": "MIT",