@khorsheed/dsh-reader 0.2.1 → 0.3.1

package/lib/types/client/SpeakerLegend.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The transcript's speakers, one chip each, above the tabs: the colour that
+ * marks their paragraphs and their name — click to rename (Enter keeps it,
+ * Esc drops it, an empty name goes back to 说话人 A). A rename applies to the
+ * whole transcript and is kept on the host.
+ *
+ * @module @khorsheed/dsh-reader/client/SpeakerLegend
+ */
+import { type ReactNode } from 'react';
+export interface SpeakerLegendProps {
+    readonly count: number;
+    readonly label: (speaker: number) => string;
+    readonly onRename: (speaker: number, name: string) => void;
+    readonly hint: string;
+    readonly renameTitle: string;
+}
+export declare function SpeakerLegend(props: SpeakerLegendProps): ReactNode;
+//# sourceMappingURL=SpeakerLegend.d.ts.map

package/lib/types/client/SpeakerLegend.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The transcript's speakers, one chip each, above the tabs: the colour that
+ * marks their paragraphs and their name — click to rename (Enter keeps it,
+ * Esc drops it, an empty name goes back to 说话人 A). A rename applies to the
+ * whole transcript and is kept on the host.
+ *
+ * @module @khorsheed/dsh-reader/client/SpeakerLegend
+ */
+import { useState } from 'react';
+import css from './ReaderPane.module.css';
+export function SpeakerLegend(props) {
+    const { count, label, onRename, hint, renameTitle } = props;
+    const [editing, setEditing] = useState(null);
+    const [draft, setDraft] = useState('');
+    return (_jsxs("div", { className: css.speakerLegend, children: [Array.from({ length: count }, (_, speaker) => (editing === speaker
+                ? (_jsx("input", { className: css.speakerInput, "data-spk": speaker, autoFocus: true, value: draft, "aria-label": renameTitle, onChange: event => { setDraft(event.target.value); }, onBlur: () => { setEditing(null); }, onKeyDown: event => {
+                        if (event.key === 'Enter') {
+                            onRename(speaker, draft);
+                            setEditing(null);
+                        }
+                        if (event.key === 'Escape')
+                            setEditing(null);
+                    } }, speaker))
+                : (_jsx("button", { type: "button", className: css.speakerChip, "data-spk": speaker, title: renameTitle, onClick: () => { setDraft(label(speaker)); setEditing(speaker); }, children: label(speaker) }, speaker)))), _jsx("span", { className: css.speakerHint, children: hint })] }));
+}

package/lib/types/client/canvas-sync.d.ts

@@ -0,0 +1,84 @@
+/**
+ * 「同步到画布」: a note (or a discussion note) becomes a kept card on a canvas
+ * the reader picks.
+ *
+ * The canvas is another package. Its client provides `ctx.canvasInbox`
+ * (`@khorsheed/dsh-canvas/client/inbox.ts`); this module mirrors that shape
+ * structurally instead of importing it, and the pane hides the gesture when
+ * the probe answers nothing. One direction only: the reader writes to the
+ * canvas, the canvas never reaches back.
+ *
+ * The card carries its provenance as text (the article, the ¶, a link to the
+ * original) because the canvas does not render a card's `source` field; the
+ * structured `source` rides along for the model.
+ *
+ * @module @khorsheed/dsh-reader/client/canvas-sync
+ */
+import type { ReaderDiscussion, ReaderNote } from '../notes-types.ts';
+/** One canvas a card can go to (the inbox's list row). */
+export interface SyncCanvas {
+    readonly id: string;
+    readonly title: string;
+    readonly cardCount: number;
+}
+/** One category a card can be filed under. */
+export interface SyncKind {
+    readonly id: string;
+    readonly label: string;
+}
+/** What putting a card answers. */
+export type SyncOutcome = {
+    readonly ok: true;
+    readonly cardId: string;
+} | {
+    readonly ok: false;
+    readonly error: 'needs-kind';
+    readonly kinds: readonly SyncKind[];
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+/** The card source the canvas stores (its BoardCardSource). */
+export interface SyncSource {
+    readonly type: 'url' | 'paste';
+    readonly ref: string;
+    readonly title?: string;
+}
+/** The canvas inbox, as this package sees it. */
+export interface CanvasInboxLike {
+    current(): string | null;
+    listCanvases(): Promise<SyncCanvas[]>;
+    addCard(sessionId: string, request: {
+        canvasId: string;
+        text: string;
+        kind?: string;
+        source?: SyncSource;
+    }): Promise<SyncOutcome>;
+    openCard(canvasId: string, cardId: string): void;
+}
+/** The article a card comes from. */
+export interface SyncArticle {
+    readonly title: string;
+    readonly url?: string;
+}
+/** The localized words a card needs. */
+export interface SyncWords {
+    readonly conclusion: string;
+    readonly original: string;
+    readonly kindCheck: string;
+    readonly kindDiscussion: string;
+}
+/** The canvas the reader synced to last, when the browser remembers one. */
+export declare function lastCanvas(): string | null;
+/** Remember the canvas the reader just synced to. */
+export declare function rememberCanvas(canvasId: string): void;
+/** The structured source the canvas keeps (the model reads it). */
+export declare function sourceOf(article: SyncArticle): SyncSource;
+/**
+ * One note as card text: the excerpt (and its translation), the comment, the
+ * conclusions under it when asked for, and where it came from.
+ */
+export declare function noteCardText(note: ReaderNote, article: SyncArticle, words: SyncWords, withReplies: boolean): string;
+/** One discussion note as card text: its points (with ¶), the aside, where it came from. */
+export declare function discussionCardText(discussion: ReaderDiscussion, article: SyncArticle, words: SyncWords): string;
+//# sourceMappingURL=canvas-sync.d.ts.map

package/lib/types/client/canvas-sync.js

@@ -0,0 +1,59 @@
+/** Where the last sync went, remembered per browser (a convenience only). */
+const LAST_CANVAS_KEY = 'dsh-reader.lastCanvas';
+/** The canvas the reader synced to last, when the browser remembers one. */
+export function lastCanvas() {
+    try {
+        return globalThis.localStorage?.getItem(LAST_CANVAS_KEY) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Remember the canvas the reader just synced to. */
+export function rememberCanvas(canvasId) {
+    try {
+        globalThis.localStorage?.setItem(LAST_CANVAS_KEY, canvasId);
+    }
+    catch {
+        // A private window or blocked storage: the picker just preselects the first canvas.
+    }
+}
+/** The provenance line every synced card ends with. */
+function provenance(article, words, para) {
+    const where = `— 《${article.title}》${para === undefined ? '' : ` ¶${String(para)}`}`;
+    return article.url === undefined ? where : `${where} · [${words.original}](${article.url})`;
+}
+/** The structured source the canvas keeps (the model reads it). */
+export function sourceOf(article) {
+    return article.url === undefined
+        ? { type: 'paste', ref: article.title }
+        : { type: 'url', ref: article.url, title: article.title };
+}
+/**
+ * One note as card text: the excerpt (and its translation), the comment, the
+ * conclusions under it when asked for, and where it came from.
+ */
+export function noteCardText(note, article, words, withReplies) {
+    const lines = note.anchor.quote.split('\n').map(line => `> ${line}`);
+    if (note.anchor.translated !== undefined)
+        lines.push(`> （${note.anchor.translated}）`);
+    if (note.comment !== undefined)
+        lines.push('', note.comment);
+    if (withReplies) {
+        for (const reply of note.replies ?? [])
+            lines.push('', `${reply.by === 'agent' ? words.conclusion : ''}${reply.text}`);
+    }
+    lines.push('', provenance(article, words, note.anchor.block + 1));
+    return lines.join('\n');
+}
+/** One discussion note as card text: its points (with ¶), the aside, where it came from. */
+export function discussionCardText(discussion, article, words) {
+    const head = `${discussion.kind === 'check' ? words.kindCheck : words.kindDiscussion}${discussion.title === '' ? '' : ` · ${discussion.title}`}`;
+    const lines = [head, ''];
+    for (const point of discussion.points)
+        lines.push(`- ${point.text}${point.para === undefined ? '' : `（¶${String(point.para)}）`}`);
+    if (discussion.aside !== undefined)
+        lines.push('', discussion.aside);
+    lines.push('', provenance(article, words));
+    return lines.join('\n');
+}

package/lib/types/client/contract.d.ts

@@ -10,8 +10,10 @@
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
 import type { GlobalStandardProps, InjectFace, PropsLocale, PropsStore } from '@deepseek-ai/dsh-client-ui-slots';
-import type { ReaderAddFailure, ReaderAddOutcome, ReaderAddRefusal, ReaderAnnotationOutcome, ReaderBackfillCandidate, ReaderEntryBodyView, ReaderEntryFetchState, ReaderBody, ReaderCapabilities, ReaderEntryTranslationView, ReaderMutationOutcome, ReaderRefreshResult, ReaderRecentEntry, ReaderSentenceLearn, ReaderSourceSummary, ReaderStorageStats, ReaderTag } from '../types.ts';
+import type { ReaderAddFailure, ReaderAddOutcome, ReaderAddRefusal, ReaderAnnotationOutcome, ReaderBackfillCandidate, ReaderEntryBodyView, ReaderEntryFetchState, ReaderBody, ReaderCapabilities, ReaderEntryTranslationView, ReaderImageResult, ReaderMutationOutcome, ReaderRefreshResult, ReaderRecentEntry, ReaderSentenceLearn, ReaderSourceSummary, ReaderStorageStats, ReaderTag, LocalTranscriptStatus, MediaCardStates, ReaderMedia, ReaderPolishView } from '../types.ts';
+import type { ReaderEntryIdentity, ReaderEntryNotes, ReaderNote, ReaderNoteInput, ReaderNoteOutcome } from '../notes-types.ts';
 import type { createReaderStore } from './store.ts';
+import type { CanvasInboxLike } from './canvas-sync.ts';
 export type { RemoteResult };
 /** The result of extracting one article, as the detail view consumes it. */
 export interface ReaderArticle {
@@ -48,6 +50,15 @@ export interface ReaderExtractedMeta {
     readonly title?: string;
     readonly excerpt?: string;
 }
+/**
+ * Which leg of one entry fetch is running, reported between the awaits.
+ *
+ * The fetch is a relay — the host downloads, THIS process extracts, the host
+ * stores — and a long article makes each leg visible to the reader. The pane
+ * renders the phase (plus elapsed time) so a slow fetch reads as work in
+ * progress, not as a dead click.
+ */
+export type ReaderFetchPhase = 'downloading' | 'extracting' | 'storing';
 /**
  * The business face every reader surface receives from its registration.
  *
@@ -140,9 +151,18 @@ export interface ReaderPaneInjected {
     /**
      * Fetch one entry's article, extract it in THIS process (the host has no
      * parser) and cache what came out. One call from the view's perspective; the
-     * extracted title/excerpt ride along for the card upgrade.
+     * extracted title/excerpt ride along for the card upgrade. `onPhase` fires
+     * between the legs, so a slow fetch has something to show.
+     */
+    fetchEntryBody: (entryId: string, url: string, onPhase?: (phase: ReaderFetchPhase) => void) => Promise<ReaderEntryBodyView & ReaderExtractedMeta>;
+    /**
+     * Fetch one image through the host, for an `<img>` the browser already
+     * failed on (CORP/hotlink protection — the bytes answer 200 to a direct
+     * fetch but are withheld from a cross-origin page). The pane re-points the
+     * image at a `data:` URI built from the answer; a host without the verb (or
+     * an origin that refuses the host too) leaves the broken image alone.
      */
-    fetchEntryBody: (entryId: string, url: string) => Promise<ReaderEntryBodyView & ReaderExtractedMeta>;
+    fetchImage: (url: string) => Promise<RemoteResult<ReaderImageResult>>;
     /** The tags on one entry. */
     entryTags: (entryId: string) => Promise<RemoteResult<{
         tags: ReaderTag[];
@@ -246,6 +266,121 @@ export interface ReaderPaneInjected {
      * never cached, never thrown.
      */
     captureRemote: () => ReaderCaptureRemote | undefined;
+    /** One article's notes and the conversations that discussed it. */
+    entryNotes: (entryId: string) => Promise<RemoteResult<{
+        entry?: ReaderEntryNotes;
+    }>>;
+    /** How many notes each article carries. */
+    noteCounts: () => Promise<RemoteResult<{
+        counts: Record<string, number>;
+    }>>;
+    /** Keep one excerpt (and its comment). */
+    addNote: (request: ReaderNoteInput) => Promise<RemoteResult<ReaderNote | 'empty' | 'full'>>;
+    /** Change or clear one note's comment. */
+    updateNote: (request: {
+        entryId: string;
+        noteId: string;
+        comment: string;
+    }) => Promise<RemoteResult<ReaderNoteOutcome>>;
+    /** Delete one note. */
+    deleteNote: (request: {
+        entryId: string;
+        noteId: string;
+    }) => Promise<RemoteResult<ReaderNoteOutcome>>;
+    /** Add the reader's own line under a note. */
+    addReply: (request: {
+        entryId: string;
+        noteId: string;
+        text: string;
+    }) => Promise<RemoteResult<ReaderNoteOutcome>>;
+    /** Rewrite (or, with empty text, remove) one line under a note. */
+    editReply: (request: {
+        entryId: string;
+        noteId: string;
+        index: number;
+        text: string;
+    }) => Promise<RemoteResult<ReaderNoteOutcome>>;
+    /** Remember that a note or a discussion note became a canvas card. */
+    markSynced: (request: {
+        entryId: string;
+        noteId?: string;
+        discussionId?: string;
+        canvasId: string;
+        cardId: string;
+        canvasTitle: string;
+    }) => Promise<RemoteResult<ReaderNoteOutcome>>;
+    /** The canvas plugin's inbox, probed live; absent hides 「同步到画布」. */
+    canvasInbox: () => CanvasInboxLike | undefined;
+    /** Delete one discussion note. */
+    deleteDiscussion: (request: {
+        entryId: string;
+        discussionId: string;
+    }) => Promise<RemoteResult<ReaderNoteOutcome>>;
+    /** Remember that this conversation discussed the article. */
+    recordDiscussion: (request: ReaderEntryIdentity & {
+        sessionId: string;
+        sessionTitle?: string;
+    }) => Promise<RemoteResult<'ok' | 'empty'>>;
+    /** Hand the host the article's original text for the model. */
+    snapshotEntry: (request: ReaderEntryIdentity & {
+        paragraphs: string[];
+    }) => Promise<RemoteResult<'ok' | 'empty'>>;
+    /** A video entry's transcript from its platform captions (stored; `none` when it has none). */
+    mediaTranscript: (request: {
+        entryId: string;
+        url: string;
+    }) => Promise<RemoteResult<{
+        entryId: string;
+        html?: string;
+        captions: 'platform' | 'none' | 'failed';
+        language?: string;
+        error?: string;
+    }>>;
+    /** Start (or rejoin) local transcription of an entry without captions; `unavailable` without the engine, `needs-models` until the first download is confirmed. */
+    startLocalTranscript: (request: {
+        entryId: string;
+        url: string;
+        media: ReaderMedia;
+        title?: string;
+        confirmModels?: boolean;
+    }) => Promise<RemoteResult<LocalTranscriptStatus>>;
+    /** Where an entry's local transcription stands, with the transcript so far. */
+    localTranscript: (request: {
+        entryId: string;
+    }) => Promise<RemoteResult<LocalTranscriptStatus>>;
+    /** The article's 润色 layer, when there is one for its current text. */
+    polish: (request: {
+        entryId: string;
+    }) => Promise<RemoteResult<ReaderPolishView | null>>;
+    /** Show one paragraph's machine translation instead of the 润色 (or back). */
+    setPolishOff: (request: {
+        entryId: string;
+        paragraph: number;
+        off: boolean;
+    }) => Promise<RemoteResult<ReaderPolishView | null>>;
+    /** The reader's names for a transcript's speakers, by index. */
+    speakerNames: (request: {
+        entryId: string;
+    }) => Promise<RemoteResult<Record<string, string>>>;
+    /** Name one speaker (empty: back to the default); answers all the names. */
+    nameSpeaker: (request: {
+        entryId: string;
+        speaker: number;
+        name: string;
+    }) => Promise<RemoteResult<Record<string, string>>>;
+    /** The wall's video / audio cards: what each one's transcript is. */
+    mediaStates: (request: {
+        entryIds: string[];
+    }) => Promise<RemoteResult<MediaCardStates>>;
+    /** Leave (withdraws a queued job) or, with `force`, stop an entry's local transcription. */
+    cancelLocalTranscript: (request: {
+        entryId: string;
+        force: boolean;
+    }) => Promise<RemoteResult<LocalTranscriptStatus>>;
+    /** Whether a conversation can be opened from the pane (probed live). */
+    canOpenSession: () => boolean;
+    /** Open a conversation in the main area; a no-op when the seam is absent. */
+    openSession: (sessionId: string) => void;
 }
 /** Full props of the reader pane: the seat's session + store + locale + face. */
 export type ReaderPaneProps = {

package/lib/types/client/extract-article.d.ts

@@ -14,7 +14,10 @@
  * - {@link normalizeRichText} takes markup that is ALREADY known to be a body
  *   (a feed's `content:encoded`, or the block extraction selected) and puts it
  *   through a tag whitelist, so the renderer never sees third-party scripts,
- *   styles, forms or event handlers.
+ *   styles, forms or event handlers. The one sanctioned exception: a content
+ *   embed (`embedElement`) survives as a sandboxed iframe — `allow-scripts`
+ *   without `allow-same-origin`, an opaque origin that cannot see the pane —
+ *   or as a native controls-only media element.
  *
  * Everything runs in the browser because the host runtime has no DOM parser at
  * all; nothing here touches the network.
@@ -73,6 +76,40 @@ export declare function extractArticle(pageHtml: string, baseUrl: string): Extra
  * @returns whitelisted HTML, or an empty string when nothing survives.
  */
 export declare function normalizeRichText(html: string, baseUrl?: string): string;
+/**
+ * Rewrite every `var(--…)` in a kept SVG value to something that paints here.
+ *
+ * A statically served chart colors itself through the PAGE's custom
+ * properties (`style="stroke:var(--line)"`), defined in a stylesheet the
+ * extraction never carries. Left as-is, each reference resolves against the
+ * reader's document instead: an undefined one drops the stroke (an axis-less
+ * scatter of black dots — claude.dev's Figure 1), and a name that collides
+ * with a host token paints in a color nobody chose. So no reference survives:
+ * a declared fallback wins, a ground-like name becomes `none` (callout discs
+ * stop hiding what lies under them), and every other one becomes
+ * `currentColor` — the article's ink, legible in both themes. A
+ * capture-rendered page never reaches this: its styles arrive computed.
+ *
+ * @param value - one attribute value.
+ * @returns the value with no custom-property reference left.
+ */
+export declare function resolveSvgVars(value: string): string;
+/**
+ * Bring a body stored by an older extractor up to the current rules.
+ *
+ * Bodies are extracted once and cached, so the fixes above that can be
+ * replayed on whitelisted markup (`resolveSvgVars`, `isResponsiveAlternate`,
+ * `settleMathJaxTwins`, `settleListLabels`) would otherwise reach only
+ * articles fetched after they shipped — a cached claude.dev post kept drawing
+ * its figure as bare dots until its TTL ran out. This replays them at display
+ * time. A body with no `<svg>` or `<li>`, or one the current extractor wrote,
+ * comes back as the same string. (What the old extractor DROPPED — a
+ * foreignObject's labels — is not here to restore; that takes a refetch.)
+ *
+ * @param html - a stored (already whitelisted) article body.
+ * @returns the body under the current rules.
+ */
+export declare function repairStoredBody(html: string): string;
 /**
  * The payload size that separates a real inlined figure from a 1px tracking
  * placeholder. A transparent-gif placeholder is ~70 characters of base64; the