@khorsheed/dsh-reader 0.2.1 → 0.3.1

package/lib/types/client/notes.js

@@ -0,0 +1,334 @@
+import { formatClock } from "../captions.js";
+/** The highlight registry names (the pane's stylesheet paints them). */
+export const NOTE_HIGHLIGHT = 'reader-note';
+export const NOTE_FLASH_HIGHLIGHT = 'reader-note-flash';
+/** Collapse whitespace the way stored excerpts are collapsed. */
+export function normalizeText(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+/** True for a node `translate.ts` inserted (a reveal of original sentences). */
+function isReveal(element) {
+    return element.getAttribute('data-reader-reveal') === '1';
+}
+/** The article's blocks: top-level children, reveals excluded. */
+export function blockElements(article) {
+    return [...article.children].filter(child => !isReveal(child));
+}
+/**
+ * The block a node sits in, as an index into {@link blockElements}.
+ *
+ * A node inside a sibling-placed reveal belongs to the block the reveal
+ * follows; one inside an inside-placed reveal is already inside its block.
+ */
+export function blockIndexOf(article, node) {
+    let current = node;
+    while (current !== null && current.parentNode !== article)
+        current = current.parentNode;
+    if (current === null || !(current instanceof Element))
+        return 0;
+    let block = current;
+    while (block !== null && isReveal(block))
+        block = block.previousElementSibling;
+    if (block === null)
+        return 0;
+    const index = blockElements(article).indexOf(block);
+    return index < 0 ? 0 : index;
+}
+/** A transcript paragraph's start (`data-t`), when the block is one. */
+function timeOf(element) {
+    const value = element?.getAttribute('data-t');
+    if (value === null || value === undefined)
+        return undefined;
+    const seconds = Number(value);
+    return Number.isFinite(seconds) ? seconds : undefined;
+}
+/** The segments a range touches whose span shows a TRANSLATION right now. */
+function translatedSegmentsIn(built, range) {
+    if (built.view === 'orig')
+        return [];
+    const touched = [];
+    for (const block of built.blocks) {
+        for (const segment of block.segments) {
+            if (segment.translated === null)
+                continue;
+            if (segment.span.closest('[data-reader-reveal="1"]') !== null)
+                continue;
+            if (range.intersectsNode(segment.span))
+                touched.push(segment);
+        }
+    }
+    return touched;
+}
+/**
+ * Read the current selection as an excerpt of this article.
+ *
+ * Selected in the translated view, the excerpt is the ORIGINAL of every
+ * sentence the selection touched, and the selected translation rides along —
+ * the stored quote is always original text (decision D8). Selected in the
+ * original (or in a reveal's original lines), the selection is the quote.
+ *
+ * @param article - the rendered article root.
+ * @param built - the translation segmentation, when there is one.
+ * @param selection - the selection to read (defaults to the window's).
+ * @returns the excerpt, or `null` when nothing in this article is selected.
+ */
+export function captureSelection(article, built, selection = typeof window === 'undefined' ? null : window.getSelection()) {
+    if (selection === null || selection.rangeCount === 0 || selection.isCollapsed)
+        return null;
+    const range = selection.getRangeAt(0);
+    if (!article.contains(range.commonAncestorContainer))
+        return null;
+    const shown = normalizeText(selection.toString());
+    if (shown.length === 0)
+        return null;
+    const block = blockIndexOf(article, range.startContainer);
+    const element = blockElements(article)[block];
+    const time = timeOf(element);
+    const timed = time === undefined ? {} : { time };
+    if (built !== null) {
+        const segments = translatedSegmentsIn(built, range);
+        if (segments.length > 0) {
+            return { block, quote: normalizeText(segments.map(segment => segment.original).join(' ')), translated: shown, ...timed };
+        }
+    }
+    let start;
+    if (element !== undefined && element.contains(range.startContainer)) {
+        const before = element.ownerDocument.createRange();
+        before.setStart(element, 0);
+        before.setEnd(range.startContainer, range.startOffset);
+        start = normalizeText(before.toString()).length;
+    }
+    return { block, ...(start === undefined ? {} : { start }), quote: shown, ...timed };
+}
+/**
+ * The article's original prose, one string per block, for the host snapshot.
+ *
+ * Parsed from the stored markup rather than read off the screen: the screen may
+ * be showing a translation, and the model must read what the author wrote.
+ *
+ * @param html - the article markup the pane renders.
+ * @returns the blocks' text (a bare-text body is one block).
+ */
+export function paragraphsOf(html, speakerLabel) {
+    const doc = new DOMParser().parseFromString(`<div>${html}</div>`, 'text/html');
+    const root = doc.body.firstElementChild;
+    if (root === null)
+        return [];
+    const children = [...root.children];
+    if (children.length === 0)
+        return [normalizeText(root.textContent ?? '')];
+    // A transcript paragraph says when it is, and who spoke it: the model reads
+    // ¶3 [24:05] 嘉宾：… — so a discussion never puts a view in the wrong mouth.
+    return children.map(child => {
+        const time = timeOf(child);
+        const spk = child.getAttribute('data-spk');
+        const text = normalizeText(child.textContent ?? '');
+        const who = spk === null || speakerLabel === undefined ? '' : `${speakerLabel(Number(spk))}：`;
+        return time === undefined || text === '' ? text : `[${formatClock(time)}] ${who}${text}`;
+    });
+}
+/**
+ * Find a normalized string inside an element's text, as a DOM Range.
+ *
+ * The text is flattened with whitespace collapsed (the stored quote's form),
+ * keeping a map from each flattened character back to its node and offset.
+ *
+ * @param root - where to search.
+ * @param needle - the normalized text to find.
+ * @param skip - elements whose text does not count.
+ * @returns the range, or `null`.
+ */
+export function findText(root, needle, skip = () => false) {
+    if (needle.length === 0)
+        return null;
+    const doc = root.ownerDocument;
+    const walker = doc.createTreeWalker(root, 4 /* NodeFilter.SHOW_TEXT */);
+    let flat = '';
+    const points = [];
+    for (let node = walker.nextNode(); node !== null; node = walker.nextNode()) {
+        const parent = node.parentElement;
+        if (parent !== null && parent !== root && skipped(parent, root, skip))
+            continue;
+        const value = node.nodeValue ?? '';
+        for (let offset = 0; offset < value.length; offset++) {
+            const ch = value[offset];
+            if (/\s/.test(ch)) {
+                if (flat.length === 0 || flat.endsWith(' '))
+                    continue;
+                flat += ' ';
+            }
+            else {
+                flat += ch;
+            }
+            points.push({ node: node, offset });
+        }
+    }
+    const at = flat.indexOf(needle);
+    if (at < 0)
+        return null;
+    const first = points[at];
+    const last = points[at + needle.length - 1];
+    if (first === undefined || last === undefined)
+        return null;
+    const range = doc.createRange();
+    range.setStart(first.node, first.offset);
+    range.setEnd(last.node, last.offset + 1);
+    return range;
+}
+/** True when an element (or an ancestor below root) is skipped. */
+function skipped(element, root, skip) {
+    for (let current = element; current !== null && current !== root; current = current.parentElement) {
+        if (skip(current))
+            return true;
+    }
+    return false;
+}
+/** True when two texts share content: one holds the other, or one runs into the other. */
+export function overlaps(left, right, edge = 6) {
+    const a = normalizeText(left);
+    const b = normalizeText(right);
+    if (a.length === 0 || b.length === 0)
+        return false;
+    if (a.includes(b) || b.includes(a))
+        return true;
+    const max = Math.min(a.length, b.length);
+    for (let size = max; size >= edge; size--) {
+        if (a.endsWith(b.slice(0, size)) || b.endsWith(a.slice(0, size)))
+            return true;
+    }
+    return false;
+}
+/** The built block that renders one top-level block element. */
+function builtBlockFor(built, element) {
+    return built.blocks.filter(block => block.element === element || element.contains(block.element));
+}
+/** Ranges for one note inside one block element, in the view on screen. */
+function rangesInBlock(element, built, anchor) {
+    const translated = built !== null && built.view !== 'orig'
+        && built.blocks.some(block => block.segments.some(segment => segment.translated !== null));
+    if (!translated || built === null) {
+        const range = findText(element, anchor.quote, isReveal);
+        return range === null ? [] : [range];
+    }
+    const ranges = [];
+    for (const block of builtBlockFor(built, element)) {
+        // The translated sentences: highlighted whole (the sentence is the unit
+        // the translation is aligned on).
+        for (const segment of block.segments) {
+            if (segment.translated === null || !overlaps(segment.original, anchor.quote))
+                continue;
+            const range = element.ownerDocument.createRange();
+            range.selectNodeContents(segment.span);
+            ranges.push(range);
+        }
+        // The originals shown beside them (side-by-side view, or an opened sentence).
+        if (block.reveal !== null) {
+            const range = findText(block.reveal, anchor.quote);
+            if (range !== null)
+                ranges.push(range);
+        }
+    }
+    return ranges;
+}
+/**
+ * Where each note is on screen right now.
+ *
+ * The anchored block is tried first; when the excerpt is not there (the
+ * article was refetched and moved), every block is searched. A note found
+ * nowhere maps to an empty list — the notes view says so.
+ *
+ * @param article - the rendered article root.
+ * @param built - the translation segmentation, when there is one.
+ * @param notes - the article's notes.
+ */
+export function noteRanges(article, built, notes) {
+    const blocks = blockElements(article);
+    const found = new Map();
+    for (const note of notes) {
+        const hinted = blocks[note.anchor.block];
+        let ranges = hinted === undefined ? [] : rangesInBlock(hinted, built, note.anchor);
+        if (ranges.length === 0) {
+            for (const block of blocks) {
+                if (block === hinted)
+                    continue;
+                ranges = rangesInBlock(block, built, note.anchor);
+                if (ranges.length > 0)
+                    break;
+            }
+        }
+        found.set(note.id, ranges);
+    }
+    return found;
+}
+/** The highlight registry, when the browser has one. */
+function registry() {
+    const highlights = globalThis.CSS?.highlights;
+    const Highlight = globalThis.Highlight;
+    if (highlights === undefined || typeof Highlight !== 'function')
+        return undefined;
+    return highlights;
+}
+/**
+ * Paint (or clear) one named highlight.
+ *
+ * @param name - the registry name.
+ * @param ranges - the ranges to paint; empty clears it.
+ */
+export function paintHighlight(name, ranges) {
+    const highlights = registry();
+    if (highlights === undefined)
+        return;
+    if (ranges.length === 0) {
+        highlights.delete(name);
+        return;
+    }
+    const Highlight = globalThis.Highlight;
+    highlights.set(name, new Highlight(...ranges));
+}
+/**
+ * The discussion draft: the article, then each note as a quote with its comment.
+ *
+ * Notes carry their ¶ and id so the model can match them to `reader_read`'s
+ * output; the closing hint names the article id for the same reason.
+ *
+ * @param source - the article.
+ * @param notes - the notes to bring, in article order.
+ * @param words - the localized fragments.
+ */
+export function formatNotesDraft(source, notes, words) {
+    const lines = [words.heading(notes.length), ''];
+    for (const note of notes) {
+        lines.push(`> ${note.id} ¶${String(note.anchor.block + 1)}${note.anchor.time === undefined ? '' : ` [${formatClock(note.anchor.time)}]`}「${note.anchor.quote}」`);
+        if (note.anchor.translated !== undefined)
+            lines.push(`> （${note.anchor.translated}）`);
+        if (note.comment !== undefined) {
+            for (const [index, line] of note.comment.split('\n').entries()) {
+                lines.push(index === 0 ? `> ${words.comment}${line}` : `> ${line}`);
+            }
+        }
+        lines.push('');
+    }
+    const attribution = [`— 《${source.title}》`, source.source].filter(part => part.length > 0).join(' · ');
+    lines.push(attribution);
+    if (source.link !== undefined)
+        lines.push(source.link);
+    lines.push(words.hint(source.entryId));
+    return lines.join('\n');
+}
+const TARGETS = new Set();
+/** Register a pane as a note target; returns the disposer. */
+export function registerNoteTarget(target) {
+    TARGETS.add(target);
+    return () => { TARGETS.delete(target); };
+}
+/** The pane whose article holds the current selection, when one does. */
+export function noteTargetForSelection(selection = typeof window === 'undefined' ? null : window.getSelection()) {
+    if (selection === null || selection.rangeCount === 0 || selection.isCollapsed)
+        return undefined;
+    const node = selection.getRangeAt(0).commonAncestorContainer;
+    for (const target of TARGETS) {
+        if (target.owns(node))
+            return target;
+    }
+    return undefined;
+}

package/lib/types/client/parse-rss.js

@@ -15,6 +15,7 @@
  */
 import { stableEntryId, summarize, } from "../types.js";
 import { normalizeRichText } from "./extract-article.js";
+import { entryMedia } from "../media.js";
 /** Element local-names that may carry an entry's full body, best first. */
 const CONTENT_TAGS = ['encoded', 'content'];
 /** Element local-names that may carry a short description, best first. */
@@ -146,6 +147,7 @@ function readEntry(element, sourceId) {
     });
     const tags = readTags(element);
     const author = readAuthor(element);
+    const media = entryMedia({ ...(link === undefined ? {} : { link }), ...present('enclosure', readEnclosure(element)) });
     return {
         id,
         sourceId,
@@ -157,8 +159,46 @@ function readEntry(element, sourceId) {
         ...present('summary', summarize(summary, 320)),
         ...present('contentHtml', body),
         ...(summaryOnly ? { summaryOnly: true } : {}),
+        ...(media === undefined ? {} : { media }),
     };
 }
+/**
+ * A podcast / media enclosure: `<enclosure url type>`, with the iTunes
+ * duration and artwork, or YouTube's `<media:group>` thumbnail.
+ *
+ * @param element - the `<item>` / `<entry>`.
+ */
+function readEnclosure(element) {
+    // RSS `<enclosure url type>`, or Atom's `<link rel="enclosure" href type>`.
+    const enclosure = child(element, 'enclosure')
+        ?? [...element.children].find(node => node.localName === 'link' && node.getAttribute('rel') === 'enclosure') ?? null;
+    const url = enclosure?.getAttribute('url') ?? enclosure?.getAttribute('href') ?? undefined;
+    const image = [...element.getElementsByTagName('*')]
+        .map(node => node.localName === 'image' ? node.getAttribute('href') : node.localName === 'thumbnail' ? node.getAttribute('url') : null)
+        .find((value) => typeof value === 'string' && value !== '');
+    if (url === undefined || url === '') {
+        // No enclosure (a YouTube channel feed): the thumbnail alone still dresses
+        // the card when the link is a recognized video.
+        return image === undefined ? undefined : { url: '', image };
+    }
+    const type = enclosure?.getAttribute('type') ?? undefined;
+    return {
+        url,
+        ...(type === undefined || type === '' ? {} : { type }),
+        ...present('durationSec', parseDuration(elementText(child(element, 'duration')))),
+        ...(image === undefined ? {} : { image }),
+    };
+}
+/** `3725`, `62:05` or `1:02:05` → seconds. */
+function parseDuration(value) {
+    if (value === undefined)
+        return undefined;
+    const parts = value.trim().split(':').map(Number);
+    if (parts.length === 0 || parts.some(part => !Number.isFinite(part)))
+        return undefined;
+    const seconds = parts.reduce((total, part) => total * 60 + part, 0);
+    return seconds > 0 ? Math.round(seconds) : undefined;
+}
 /**
  * The best available body for the detail view.
  *

package/lib/types/client/preset-visibility.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The preset-composition visibility of the reader (灵感空间) right-Sidebar tab
+ * type — a copy of the canvas's (docs/plugin-visibility.md: keep per-package
+ * inline copies). The tab is the entry to a cross-session wall, but since the
+ * reader carries session-granted tools (`reader_read` / `reader_note`) its
+ * entry semantics are "can THIS session reach the reader tools" — the canvas
+ * dual check, over the `./tool` row:
+ *
+ * 1. **Profile-root mount** (the package's own patch, a standalone install):
+ *   an ENABLED `@khorsheed/dsh-reader/tool` row in `entries` → every session.
+ * 2. **Preset mount** (the learning / writing mode packs, 2026-10-19): shown
+ *   exactly when the CURRENT session's preset composition names that row.
+ *
+ * Every unreadable path fails OPEN (visible): no pluginInventory namespace, a
+ * pending/failed RPC, a missing or `broken` preset group, a session with no
+ * preset, and the no-session home state. Hidden means NOT registered.
+ * @module @khorsheed/dsh-reader/client/preset-visibility
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
+/** The criterion's row: the reader tools composition entry. */
+export declare const READER_TOOL_ROW_MODULE = "@khorsheed/dsh-reader/tool";
+/**
+ * Minimal structural mirror of the official pluginInventory snapshot — the
+ * entries slice (root grants) plus the agentPresets slice (preset grants),
+ * duck-typed and host-version tolerant.
+ */
+export interface ReaderPluginInventorySnapshot {
+    readonly entries?: readonly {
+        readonly moduleName: string;
+        readonly enabled?: boolean;
+    }[];
+    readonly agentPresets?: readonly {
+        readonly id: string;
+        readonly broken?: string;
+        readonly rows: readonly {
+            readonly moduleName: string;
+            readonly enabled?: boolean;
+        }[];
+    }[];
+}
+/**
+ * The tab's visibility controller: one inventory fetch per page (composition
+ * data changes only with preset files, which a reload re-reads anyway),
+ * re-evaluated by the toggle on every session switch.
+ */
+export declare class ReaderTabVisibility {
+    private readonly ctx;
+    /** The inventory answer; null while pending/failed and on namespace-less hosts. */
+    private composition;
+    private readonly listeners;
+    /**
+     * @param ctx - client root context.
+     * @param pluginInventory - the OFFICIAL namespace, probed through ctx.get
+     *   (never injected — declaring it would pend the whole client on a host
+     *   without it, and the criterion must fail open there).
+     */
+    constructor(ctx: Context, pluginInventory: {
+        list: () => Promise<RemoteResult<ReaderPluginInventorySnapshot>>;
+    } | undefined);
+    show(sessionId: SessionId | undefined): boolean;
+    /**
+     * Whether the session reaches any of `modules` by either grant path. Every
+     * unreadable path fails open, as above.
+     */
+    grantsAny(sessionId: SessionId | undefined, modules: readonly string[]): boolean;
+    /** Subscribe to criterion-input changes (session switches, the inventory answer). */
+    subscribe(listener: () => void): () => void;
+    private notify;
+}
+/**
+ * The tab type's registration toggle (the room template): registers exactly
+ * while the criterion passes for the current session and disposes otherwise.
+ * Unlike the keyed-slot consumers, the sidebarRightTabs registry is a direct
+ * inject — no slot-declaration wait, so the toggle is ready immediately.
+ */
+export declare class RegistrationToggle {
+    private readonly register;
+    private readonly show;
+    private dispose;
+    private ready;
+    /**
+     * @param register - mounts the entry and returns its disposer.
+     * @param show - the current decision (re-read on every sync).
+     */
+    constructor(register: () => () => void, show: () => boolean);
+    /** The registry is reachable — decisions may register now. */
+    setReady(ready: boolean): void;
+    /** Re-evaluate: register while shown and ready, dispose otherwise. */
+    sync(): void;
+}
+//# sourceMappingURL=preset-visibility.d.ts.map

package/lib/types/client/preset-visibility.js

@@ -0,0 +1,115 @@
+/** The criterion's row: the reader tools composition entry. */
+export const READER_TOOL_ROW_MODULE = '@khorsheed/dsh-reader/tool';
+/** The current session's agent preset, the dual read per host line. */
+function presetOf(row) {
+    const value = row
+        ?.projectionValues?.agentPreset
+        ?? row?.agentPreset;
+    return typeof value === 'string' ? value : undefined;
+}
+/**
+ * The tab's visibility controller: one inventory fetch per page (composition
+ * data changes only with preset files, which a reload re-reads anyway),
+ * re-evaluated by the toggle on every session switch.
+ */
+export class ReaderTabVisibility {
+    ctx;
+    /** The inventory answer; null while pending/failed and on namespace-less hosts. */
+    composition = null;
+    listeners = new Set();
+    /**
+     * @param ctx - client root context.
+     * @param pluginInventory - the OFFICIAL namespace, probed through ctx.get
+     *   (never injected — declaring it would pend the whole client on a host
+     *   without it, and the criterion must fail open there).
+     */
+    constructor(ctx, pluginInventory) {
+        this.ctx = ctx;
+        if (pluginInventory !== undefined) {
+            void pluginInventory.list().then(result => {
+                if (!result.ok)
+                    return;
+                this.composition = result.value ?? null;
+                this.notify();
+            }).catch(() => { });
+        }
+        // Session switches re-decide the tab type's registration (the guide
+        // enumerates registrations, not components).
+        ctx.effect(() => ctx.sessions.list.subscribe(() => { this.notify(); }), 'reader: tab visibility session follower');
+    }
+    show(sessionId) {
+        return this.grantsAny(sessionId, [READER_TOOL_ROW_MODULE]);
+    }
+    /**
+     * Whether the session reaches any of `modules` by either grant path. Every
+     * unreadable path fails open, as above.
+     */
+    grantsAny(sessionId, modules) {
+        if (this.composition === null)
+            return true;
+        // Path 1: a root-mounted tool row grants the tools to every session —
+        // a deployment-level constant, checked before any per-session question.
+        if (this.composition.entries?.some(row => modules.includes(row.moduleName) && row.enabled === true) === true)
+            return true;
+        if (sessionId === undefined)
+            return true;
+        const preset = presetOf(this.ctx.sessions.list.getSnapshot().byId[sessionId]);
+        if (preset === undefined)
+            return true;
+        const group = this.composition.agentPresets?.find(candidate => candidate.id === preset);
+        if (group === undefined || group.broken !== undefined)
+            return true;
+        // Path 2: the preset-mounted row grants this session.
+        return group.rows.some(row => modules.includes(row.moduleName) && row.enabled !== false);
+    }
+    /** Subscribe to criterion-input changes (session switches, the inventory answer). */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    }
+    notify() {
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+/**
+ * The tab type's registration toggle (the room template): registers exactly
+ * while the criterion passes for the current session and disposes otherwise.
+ * Unlike the keyed-slot consumers, the sidebarRightTabs registry is a direct
+ * inject — no slot-declaration wait, so the toggle is ready immediately.
+ */
+export class RegistrationToggle {
+    register;
+    show;
+    dispose;
+    ready = false;
+    /**
+     * @param register - mounts the entry and returns its disposer.
+     * @param show - the current decision (re-read on every sync).
+     */
+    constructor(register, show) {
+        this.register = register;
+        this.show = show;
+    }
+    /** The registry is reachable — decisions may register now. */
+    setReady(ready) {
+        this.ready = ready;
+        if (!ready && this.dispose !== undefined) {
+            this.dispose();
+            this.dispose = undefined;
+        }
+        this.sync();
+    }
+    /** Re-evaluate: register while shown and ready, dispose otherwise. */
+    sync() {
+        if (!this.ready)
+            return;
+        if (this.show()) {
+            this.dispose ??= this.register();
+        }
+        else if (this.dispose !== undefined) {
+            this.dispose();
+            this.dispose = undefined;
+        }
+    }
+}

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

@@ -11,6 +11,11 @@
 import type { ReaderEntry } from './parse-rss.ts';
 import type { ReaderFilter, ReaderSort } from './store.ts';
 import { type ReaderEntryFetchState, type ReaderSourceKind } from '../types.ts';
+/** The queries that select video / audio entries (source ids never collide: they are `<kind>-<hash>`). */
+export declare const MEDIA_QUERIES: {
+    readonly video: "#video";
+    readonly audio: "#audio";
+};
 /** How many entries the pane will show before it stops rendering cards. */
 export declare const LIST_RENDER_LIMIT = 300;
 /** One entry plus the source it came from, which is what a card needs. */

package/lib/types/client/selectors.js

@@ -1,4 +1,6 @@
 import { kindQuery, READER_SOURCE_KINDS } from "../types.js";
+/** The queries that select video / audio entries (source ids never collide: they are `<kind>-<hash>`). */
+export const MEDIA_QUERIES = { video: '#video', audio: '#audio' };
 /** How many entries the pane will show before it stops rendering cards. */
 export const LIST_RENDER_LIMIT = 300;
 /** Every parsed entry, flattened in source order. */
@@ -156,6 +158,9 @@ function relevance(title, query) {
 }
 /** Whether an entry matches the query, across the fields a reader searches by. */
 function matches(entry, source, query, tags) {
+    // The media kinds (an entry's own kind, decided per item — media.ts).
+    if (query === MEDIA_QUERIES.video || query === MEDIA_QUERIES.audio)
+        return entry.media?.kind === query.slice(1);
     if (query.startsWith('#')) {
         const selector = query.slice(1);
         // A kind selector first: source ids are always `<kind>-<hash>`, so

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

@@ -31,7 +31,8 @@
  *
  * @module @khorsheed/dsh-reader/client/session
  */
-import type { ReaderFilter, ReaderSort, ReaderView } from './store.ts';
+import type { ReaderSourceSummary } from '../types.ts';
+import type { ReaderFilter, ReaderParsedSource, ReaderSort, ReaderView } from './store.ts';
 import type { TranslationView, TranslatorSessionLike } from './translate.ts';
 /** One session's worth of "where the reader was". */
 export interface ReaderSessionSnapshot {
@@ -115,6 +116,25 @@ export declare function readSession(): Patch;
  * @param patch - the fields to replace.
  */
 export declare function patchSession(patch: Patch): void;
+/**
+ * The parsed wall, for as long as the page is: switching to another sidebar
+ * tab unmounts the pane, and re-parsing every feed on the way back made the
+ * whole wall flash 「加载中」 and rebuild (2026-10-20). A remount shows this at
+ * once and re-reads only the sources whose fetch changed (`stamp`). Memory
+ * only — feed content never goes to storage.
+ */
+export interface WallCache {
+    readonly sources: readonly ReaderSourceSummary[];
+    readonly parsed: ReadonlyMap<string, {
+        readonly stamp: string;
+        readonly parsed: ReaderParsedSource;
+        readonly label?: string;
+    }>;
+}
+/** What makes a source's parsed entries stale: its fetch, its body, its kind. */
+export declare function sourceStamp(source: ReaderSourceSummary): string;
+export declare function readWallCache(): WallCache | undefined;
+export declare function writeWallCache(cache: WallCache): void;
 /** Drop the snapshot, here and in storage (the specs call this between cases). */
 export declare function forgetSession(): void;
 /**