@khorsheed/dsh-reader 0.3.1 → 0.3.2

package/lib/index.js

@@ -1240,6 +1240,104 @@ function arxivHtmlUrl(url) {
 	if (link === void 0 || link.kind === "html") return void 0;
 	return `https://arxiv.org/html/${link.id}`;
 }
+//#endregion
+//#region lib/types/document-fetch.js
+/**
+* The document fetcher: the reader's own instance of the official HTTP fetch
+* provider, so feeds and article pages arrive as the origin served them.
+*
+* Why not `ctx.web.fetch` alone: the seam runs whichever provider the host
+* selects, and from 0.2.1-rc.2 the web-search settings switch for the DeepSeek
+* Search/Fetch API moves `web.fetchProvider` too. That provider answers
+* Markdown (`body.kind: 'text'`), a constant 200, and the request URL as the
+* final URL — so `classifyPayload` reads every feed as a page, the extractor
+* gets no HTML, and the cross-origin redirect handling never fires. The
+* request carries only a URL; no caller can ask for the HTTP provider (seam
+* registry S22).
+*
+* So when the mounted `web` is the official service (it carries
+* `registerFetchProvider`), the reader fetches through its own
+* `HttpFetchProvider` — the same class the default `http` row registers, with
+* that row's default limits, so the policy (public addresses only, connection
+* pinned, same-origin redirects, charset decoding) and the errors
+* (`WEB_REDIRECT_BLOCKED` naming the target origin) are exactly today's.
+* `ctx.web` stays the permission: without it nothing is fetched. A host
+* without the provider package (or any other `web` shape, such as a test's
+* plain `{ fetch }`) is fetched through as before.
+*
+* Retire when the seam lets one request name its provider (S22).
+*
+* @module @khorsheed/dsh-reader/document-fetch
+*/
+/**
+* The reader's own fetch limits: the `http` row's defaults
+* (`@deepseek-ai/dsh-web-fetch-http` Config, 0.1.5 through 0.2.1-rc.3) except
+* `maxBodyChars`. The row's 100 000 is sized for a page handed to a model; the
+* reader extracts the article itself from the raw HTML, and a modern page
+* carries several hundred KB of inline script before its last paragraph
+* (measured: claude.com's articles, 620 KB, cut mid-sentence at 100 000). 2 000 000
+* is what deployments ran the row at while the reader still fetched through
+* it, and the per-source storage budget (`MAX_BODY_CHARS_PER_SOURCE`) is
+* sized to match. A deployment changes these with the reader's own
+* `fetchLimits`: the row's config does not reach this instance.
+*/
+const DOCUMENT_FETCH_DEFAULTS = {
+	maxResponseBytes: 5e6,
+	maxBodyChars: 2e6,
+	timeoutMs: 3e4,
+	maxRedirects: 5
+};
+/** Whether a mounted `web` is the official service rather than some other shape. */
+function isOfficialWebService(web) {
+	return typeof web?.registerFetchProvider === "function";
+}
+const loadOfficialProvider = () => import("@deepseek-ai/dsh-web-fetch-http").then((module) => module, () => void 0);
+/**
+* Pick the fetcher for raw documents.
+*
+* Built once per service: the first fetch on an official web service loads
+* the provider package and keeps the instance; a failed load is remembered
+* too, and every later fetch goes through the seam.
+*/
+var DocumentFetch = class {
+	web;
+	limits;
+	load;
+	provider;
+	/**
+	* @param web - the probed web seam, read on every call (it may come and go).
+	* @param limits - the reader's configured fetch limits, over the defaults.
+	* @param load - the provider package loader (tests inject one).
+	*/
+	constructor(web, limits = {}, load = loadOfficialProvider) {
+		this.web = web;
+		this.limits = limits;
+		this.load = load;
+	}
+	/**
+	* The fetcher for this call, or undefined when no web capability is mounted.
+	* @returns the reader's own provider on an official web service, else the seam itself.
+	*/
+	async current() {
+		const web = this.web();
+		if (web === void 0 || web === null) return void 0;
+		const seam = web;
+		if (!isOfficialWebService(web)) return seam;
+		this.provider ??= this.load().then((module) => {
+			if (module === void 0 || typeof module.HttpFetchProvider !== "function") return void 0;
+			try {
+				return new module.HttpFetchProvider({
+					...DOCUMENT_FETCH_DEFAULTS,
+					...this.limits,
+					userAgent: module.DEFAULT_USER_AGENT ?? "deepseek-harness/0.0.1 (+https://github.com/deepseek-ai)"
+				});
+			} catch {
+				return;
+			}
+		});
+		return await this.provider ?? seam;
+	}
+};
 /** An honest agent line — bot walls are reported, never impersonated around. */
 const IMAGE_FETCH_USER_AGENT = "dsh-reader image rescue (+https://github.com/Khorsheed/dsh-plugins)";
 /**
@@ -3457,12 +3555,15 @@ var ReaderService = class {
 	memoryDoc;
 	/** Rescued images, by URL — a pane remount re-fails every blocked image, and this is what keeps that a memory read. */
 	imageCache = new ImageFetchCache();
+	/** Feeds and pages, as the origin served them (see `document-fetch.ts`). */
+	documents;
 	/**
 	* @param ctx - owning context.
 	* @param config - optional state-root override.
 	*/
 	constructor(ctx, config = {}) {
 		this.ctx = ctx;
+		this.documents = new DocumentFetch(() => this.ctx.get("web"), config.fetchLimits);
 		this.store = new ReaderStore(config);
 		const stateRoot = resolveReaderStateRoot(config.stateRoot);
 		this.media = new ReaderMediaHost(stateRoot, config.ytdlpPath);
@@ -4732,7 +4833,7 @@ var ReaderService = class {
 	* known-unreadable verdict) still answers.
 	*/
 	async resolvePaper(url) {
-		const web = this.web();
+		const web = await this.documents.current();
 		const fetch = async (target) => {
 			if (web === void 0) throw new UnsupportedContent("no web capability is mounted");
 			const result = await web.fetch({ url: target });
@@ -4747,10 +4848,6 @@ var ReaderService = class {
 			return null;
 		}
 	}
-	/** The probed web seam (no host import, no boot-time dependency). */
-	web() {
-		return this.ctx.get("web");
-	}
 	/** The probed side-chat service. */
 	sideChat() {
 		return this.ctx.get("sideChat");
@@ -4801,7 +4898,7 @@ var ReaderService = class {
 	* @returns the final URL and its decoded payload.
 	*/
 	async fetchFollowing(url) {
-		const web = this.web();
+		const web = await this.documents.current();
 		if (web === void 0) throw new UnsupportedContent("no web capability is mounted");
 		let current = url;
 		for (let hop = 0; hop <= MAX_REDIRECT_HOPS; hop++) try {

package/lib/types/client/extract-article.js

@@ -73,6 +73,31 @@ const DROP_TAGS = new Set([
 ]);
 /** The strip selector's exact-case members (SVG camelCase names in an HTML document). */
 const DROP_STRIP_EXTRA = [];
+/**
+ * Page furniture that sits beside an article in the same container and that
+ * no tag or score tells apart from it. Named by id, per site, only where the
+ * id is the platform's own and stable.
+ *
+ * WeChat (mp.weixin.qq.com): `#content_bottom_area` holds the 腾讯公益
+ * donation card (一起捐, the donors' avatars), the like/share bar and the
+ * album modal; `#js_tags_preview_toast` is 「预览时标签不可点」. A rendered
+ * fetch runs the page's scripts, which fill both in, and the winning container
+ * (`.rich_media_area_primary_inner`) holds them next to `#js_content`.
+ */
+const NOISE_SELECTORS = ['#content_bottom_area', '#js_tags_preview_toast'];
+/**
+ * Article roots a platform names itself, taken as the body without scoring.
+ *
+ * WeChat's `#js_content` is exactly the article: the title, byline and the
+ * 「在小说阅读器读本章」 card sit beside it in `#img-content`, and a rendered
+ * fetch fills the page with modal layers (the font-size panel, the complaint
+ * dialog, the comment-identity popover, the a11y labels) that the scorer
+ * measured as one more container of text and let win. The pane renders the
+ * title itself, and the document `<title>` is the article's.
+ */
+const ARTICLE_ROOTS = ['#js_content'];
+/** Below this much text a named root is not trusted (a lazy page not yet filled in). */
+const ARTICLE_ROOT_MIN_TEXT = 120;
 /** Inline elements that survive an inline-only pass. */
 const INLINE_TAGS = new Set(['strong', 'em', 'b', 'i', 'u', 's', 'code', 'a', 'sub', 'sup', 'br']);
 /**
@@ -186,12 +211,15 @@ export function extractArticle(pageHtml, baseUrl) {
     const docTitle = doc.title ?? '';
     // Strip the noise subtrees BEFORE scoring, so every candidate is measured on
     // the same terms (a sidebar full of links otherwise wins on raw text mass).
-    for (const node of Array.from(doc.querySelectorAll([...DROP_TAGS, ...DROP_STRIP_EXTRA].join(',')))) {
+    for (const node of Array.from(doc.querySelectorAll([...DROP_TAGS, ...DROP_STRIP_EXTRA, ...NOISE_SELECTORS].join(',')))) {
         node.remove();
     }
     settleMathJaxTwins(doc.body);
     settleListLabels(doc.body);
-    const scored = scoreCandidates(doc);
+    const named = ARTICLE_ROOTS
+        .map(selector => doc.querySelector(selector))
+        .find((element) => element !== null && textLengthOf(element) >= ARTICLE_ROOT_MIN_TEXT);
+    const scored = named === undefined ? scoreCandidates(doc) : { element: named, score: 0 };
     if (scored === undefined) {
         return { ok: false, error: 'no text-bearing block found' };
     }
@@ -649,7 +677,8 @@ function normalizeNode(node, baseUrl, inFigure = false) {
         const src = imageSrc(element, baseUrl);
         if (src === undefined)
             return '';
-        return emitImg(src, element.getAttribute('alt'));
+        const width = displayWidth(element);
+        return emitImg(src, element.getAttribute('alt'), width === undefined ? {} : { width });
     }
     // LaTeXML embeds vector figures as image-typed objects: an image in every
     // sense that matters here. Any other object (a PDF, a movie) keeps the old
@@ -826,6 +855,29 @@ function emitImg(src, alt, dimensions = {}) {
     const height = dimensions.height === undefined ? '' : ` height="${dimensions.height}"`;
     return `<img src="${escapeAttribute(src)}"${alt === null ? '' : ` alt="${escapeAttribute(alt)}"`}${width}${height} referrerpolicy="no-referrer">`;
 }
+/**
+ * The width the page shows an image at: its inline `width: Npx`.
+ *
+ * Without it every image renders at its natural size up to the column. A
+ * logo row is where that shows: claude.com ships a 132×128 PNG with
+ * `style="width:48.89px"`, and the reader drew it three times too large. Only
+ * a pixel width counts (`100%`, `auto` and `max-width` say nothing about the
+ * picture), and the column's `max-width: 100%` still caps it. The `width`
+ * attribute is not carried: it is usually the file's own size, which is what
+ * the image renders at anyway.
+ *
+ * @param element - the `<img>`.
+ * @returns the width as an integer string, or `undefined`.
+ */
+function displayWidth(element) {
+    const styled = /(?:^|;)\s*width\s*:\s*(\d+(?:\.\d+)?)px/i.exec(element.getAttribute('style') ?? '');
+    if (styled !== null) {
+        const px = Math.round(Number(styled[1]));
+        if (px >= 1 && px <= 99_999)
+            return String(px);
+    }
+    return undefined;
+}
 /** An integer dimension worth carrying onto the emitted image (nothing else is trusted). */
 function dimensionAttr(value) {
     if (value === null)
@@ -1346,18 +1398,21 @@ function bestSrcset(value, baseUrl) {
 function pictureImg(element, baseUrl) {
     const fallback = Array.from(element.children).find(child => child.localName === 'img');
     const alt = fallback?.getAttribute('alt') ?? null;
+    // The picture's size is its <img>'s (claude.com's testimonial logos).
+    const width = fallback === undefined ? undefined : displayWidth(fallback);
+    const dimensions = width === undefined ? {} : { width };
     for (const source of Array.from(element.children)) {
         if (source.localName !== 'source')
             continue;
         const url = bestSrcset(source.getAttribute('srcset'), baseUrl)
             ?? bestSrcset(source.getAttribute('data-srcset'), baseUrl);
         if (url !== undefined)
-            return emitImg(url, alt);
+            return emitImg(url, alt, dimensions);
     }
     if (fallback !== undefined) {
         const url = imageSrc(fallback, baseUrl);
         if (url !== undefined)
-            return emitImg(url, alt);
+            return emitImg(url, alt, dimensions);
     }
     return '';
 }

package/lib/types/document-fetch.d.ts

@@ -0,0 +1,106 @@
+/**
+ * The document fetcher: the reader's own instance of the official HTTP fetch
+ * provider, so feeds and article pages arrive as the origin served them.
+ *
+ * Why not `ctx.web.fetch` alone: the seam runs whichever provider the host
+ * selects, and from 0.2.1-rc.2 the web-search settings switch for the DeepSeek
+ * Search/Fetch API moves `web.fetchProvider` too. That provider answers
+ * Markdown (`body.kind: 'text'`), a constant 200, and the request URL as the
+ * final URL — so `classifyPayload` reads every feed as a page, the extractor
+ * gets no HTML, and the cross-origin redirect handling never fires. The
+ * request carries only a URL; no caller can ask for the HTTP provider (seam
+ * registry S22).
+ *
+ * So when the mounted `web` is the official service (it carries
+ * `registerFetchProvider`), the reader fetches through its own
+ * `HttpFetchProvider` — the same class the default `http` row registers, with
+ * that row's default limits, so the policy (public addresses only, connection
+ * pinned, same-origin redirects, charset decoding) and the errors
+ * (`WEB_REDIRECT_BLOCKED` naming the target origin) are exactly today's.
+ * `ctx.web` stays the permission: without it nothing is fetched. A host
+ * without the provider package (or any other `web` shape, such as a test's
+ * plain `{ fetch }`) is fetched through as before.
+ *
+ * Retire when the seam lets one request name its provider (S22).
+ *
+ * @module @khorsheed/dsh-reader/document-fetch
+ */
+/** The shape of one fetch result, declared structurally (no host import). */
+export interface DocumentFetchResult {
+    readonly url: string;
+    readonly statusCode: number;
+    readonly body: {
+        readonly kind: 'html' | 'text';
+        readonly content: string;
+    };
+    readonly truncated: boolean;
+}
+/** Anything that fetches one URL: the web seam or a provider. */
+export interface DocumentFetcher {
+    fetch(request: {
+        readonly url: string;
+    }, signal?: AbortSignal): Promise<DocumentFetchResult>;
+}
+/** The limits the official provider takes (the `http` row's resolved config). */
+interface HttpFetchLimits {
+    readonly maxResponseBytes: number;
+    readonly maxBodyChars: number;
+    readonly timeoutMs: number;
+    readonly maxRedirects: number;
+    readonly userAgent: string;
+}
+/** The provider package's runtime face, structurally. */
+interface HttpProviderModule {
+    readonly HttpFetchProvider: new (limits: HttpFetchLimits) => DocumentFetcher;
+    readonly DEFAULT_USER_AGENT?: string;
+}
+/**
+ * The reader's own fetch limits: the `http` row's defaults
+ * (`@deepseek-ai/dsh-web-fetch-http` Config, 0.1.5 through 0.2.1-rc.3) except
+ * `maxBodyChars`. The row's 100 000 is sized for a page handed to a model; the
+ * reader extracts the article itself from the raw HTML, and a modern page
+ * carries several hundred KB of inline script before its last paragraph
+ * (measured: claude.com's articles, 620 KB, cut mid-sentence at 100 000). 2 000 000
+ * is what deployments ran the row at while the reader still fetched through
+ * it, and the per-source storage budget (`MAX_BODY_CHARS_PER_SOURCE`) is
+ * sized to match. A deployment changes these with the reader's own
+ * `fetchLimits`: the row's config does not reach this instance.
+ */
+export declare const DOCUMENT_FETCH_DEFAULTS: {
+    readonly maxResponseBytes: 5000000;
+    readonly maxBodyChars: 2000000;
+    readonly timeoutMs: 30000;
+    readonly maxRedirects: 5;
+};
+/** The limits a deployment may override (the user agent stays the provider's). */
+export type DocumentFetchLimits = Partial<Pick<HttpFetchLimits, 'maxResponseBytes' | 'maxBodyChars' | 'timeoutMs' | 'maxRedirects'>>;
+/** Whether a mounted `web` is the official service rather than some other shape. */
+export declare function isOfficialWebService(web: unknown): boolean;
+/** Loads the provider package; injectable so tests never need the real one. */
+export type HttpProviderLoader = () => Promise<HttpProviderModule | undefined>;
+/**
+ * Pick the fetcher for raw documents.
+ *
+ * Built once per service: the first fetch on an official web service loads
+ * the provider package and keeps the instance; a failed load is remembered
+ * too, and every later fetch goes through the seam.
+ */
+export declare class DocumentFetch {
+    private readonly web;
+    private readonly limits;
+    private readonly load;
+    private provider;
+    /**
+     * @param web - the probed web seam, read on every call (it may come and go).
+     * @param limits - the reader's configured fetch limits, over the defaults.
+     * @param load - the provider package loader (tests inject one).
+     */
+    constructor(web: () => unknown, limits?: DocumentFetchLimits, load?: HttpProviderLoader);
+    /**
+     * The fetcher for this call, or undefined when no web capability is mounted.
+     * @returns the reader's own provider on an official web service, else the seam itself.
+     */
+    current(): Promise<DocumentFetcher | undefined>;
+}
+export {};
+//# sourceMappingURL=document-fetch.d.ts.map

package/lib/types/document-fetch.js

@@ -0,0 +1,100 @@
+/**
+ * The document fetcher: the reader's own instance of the official HTTP fetch
+ * provider, so feeds and article pages arrive as the origin served them.
+ *
+ * Why not `ctx.web.fetch` alone: the seam runs whichever provider the host
+ * selects, and from 0.2.1-rc.2 the web-search settings switch for the DeepSeek
+ * Search/Fetch API moves `web.fetchProvider` too. That provider answers
+ * Markdown (`body.kind: 'text'`), a constant 200, and the request URL as the
+ * final URL — so `classifyPayload` reads every feed as a page, the extractor
+ * gets no HTML, and the cross-origin redirect handling never fires. The
+ * request carries only a URL; no caller can ask for the HTTP provider (seam
+ * registry S22).
+ *
+ * So when the mounted `web` is the official service (it carries
+ * `registerFetchProvider`), the reader fetches through its own
+ * `HttpFetchProvider` — the same class the default `http` row registers, with
+ * that row's default limits, so the policy (public addresses only, connection
+ * pinned, same-origin redirects, charset decoding) and the errors
+ * (`WEB_REDIRECT_BLOCKED` naming the target origin) are exactly today's.
+ * `ctx.web` stays the permission: without it nothing is fetched. A host
+ * without the provider package (or any other `web` shape, such as a test's
+ * plain `{ fetch }`) is fetched through as before.
+ *
+ * Retire when the seam lets one request name its provider (S22).
+ *
+ * @module @khorsheed/dsh-reader/document-fetch
+ */
+/**
+ * The reader's own fetch limits: the `http` row's defaults
+ * (`@deepseek-ai/dsh-web-fetch-http` Config, 0.1.5 through 0.2.1-rc.3) except
+ * `maxBodyChars`. The row's 100 000 is sized for a page handed to a model; the
+ * reader extracts the article itself from the raw HTML, and a modern page
+ * carries several hundred KB of inline script before its last paragraph
+ * (measured: claude.com's articles, 620 KB, cut mid-sentence at 100 000). 2 000 000
+ * is what deployments ran the row at while the reader still fetched through
+ * it, and the per-source storage budget (`MAX_BODY_CHARS_PER_SOURCE`) is
+ * sized to match. A deployment changes these with the reader's own
+ * `fetchLimits`: the row's config does not reach this instance.
+ */
+export const DOCUMENT_FETCH_DEFAULTS = {
+    maxResponseBytes: 5_000_000,
+    maxBodyChars: 2_000_000,
+    timeoutMs: 30_000,
+    maxRedirects: 5,
+};
+/** Whether a mounted `web` is the official service rather than some other shape. */
+export function isOfficialWebService(web) {
+    return typeof web?.registerFetchProvider === 'function';
+}
+const loadOfficialProvider = () => import('@deepseek-ai/dsh-web-fetch-http').then(module => module, () => undefined);
+/**
+ * Pick the fetcher for raw documents.
+ *
+ * Built once per service: the first fetch on an official web service loads
+ * the provider package and keeps the instance; a failed load is remembered
+ * too, and every later fetch goes through the seam.
+ */
+export class DocumentFetch {
+    web;
+    limits;
+    load;
+    provider;
+    /**
+     * @param web - the probed web seam, read on every call (it may come and go).
+     * @param limits - the reader's configured fetch limits, over the defaults.
+     * @param load - the provider package loader (tests inject one).
+     */
+    constructor(web, limits = {}, load = loadOfficialProvider) {
+        this.web = web;
+        this.limits = limits;
+        this.load = load;
+    }
+    /**
+     * The fetcher for this call, or undefined when no web capability is mounted.
+     * @returns the reader's own provider on an official web service, else the seam itself.
+     */
+    async current() {
+        const web = this.web();
+        if (web === undefined || web === null)
+            return undefined;
+        const seam = web;
+        if (!isOfficialWebService(web))
+            return seam;
+        this.provider ??= this.load().then(module => {
+            if (module === undefined || typeof module.HttpFetchProvider !== 'function')
+                return undefined;
+            try {
+                return new module.HttpFetchProvider({
+                    ...DOCUMENT_FETCH_DEFAULTS,
+                    ...this.limits,
+                    userAgent: module.DEFAULT_USER_AGENT ?? 'deepseek-harness/0.0.1 (+https://github.com/deepseek-ai)',
+                });
+            }
+            catch {
+                return undefined;
+            }
+        });
+        return (await this.provider) ?? seam;
+    }
+}

package/lib/types/index.d.ts

@@ -12,6 +12,7 @@
  * @module @khorsheed/dsh-reader
  */
 import type { Context } from '@deepseek-ai/cordis';
+import type { DocumentFetchLimits } from './document-fetch.ts';
 import { ReaderService } from './service.ts';
 import { ReaderNotesStore } from './notes.ts';
 export { ReaderService, classifyPayload, normalizeUrl } from './service.ts';
@@ -38,6 +39,14 @@ export interface ReaderConfig {
     readonly stateRoot?: string;
     /** A yt-dlp binary to use instead of the reader's managed copy (video metadata and captions). */
     readonly ytdlpPath?: string;
+    /**
+     * Fetch limits for feeds and pages: `maxResponseBytes` (default 5 000 000),
+     * `maxBodyChars` (2 000 000 — whole pages, not the row's model-sized 100 000),
+     * `timeoutMs` (30 000), `maxRedirects` (5). The reader fetches through its own
+     * instance of the official `http` provider, so limits raised on that row do
+     * not reach it; set them here.
+     */
+    readonly fetchLimits?: DocumentFetchLimits;
 }
 /**
  * Plugin body: provide the service core, then mount the Remote data face.

package/lib/types/service.d.ts

@@ -5,9 +5,12 @@
  *
  * Two seams shape the whole module:
  *
- * - **Fetch goes through `ctx.web.fetch`** — the host's sanctioned outbound
- *   HTTP face, which brings public-address resolution, connection pinning, a
- *   byte cap and a timeout. Its provider caps the decoded body at 100 000
+ * - **Fetch rides the official HTTP provider** — `ctx.web` is the permission
+ *   (nothing is fetched without it), and its default `http` provider brings
+ *   public-address resolution, connection pinning, a byte cap and a timeout.
+ *   On the official web service the reader runs its own instance of that
+ *   provider (`document-fetch.ts`), because the host's selected provider may
+ *   answer Markdown instead of the document (seam registry S22). Its provider caps the decoded body at 100 000
  *   characters by default, so a payload that comes back `truncated` is stored
  *   as-is and FLAGGED; nothing here pretends it is a whole document. A
  *   truncated feed cannot be parsed and a truncated page yields half an
@@ -36,6 +39,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import { type ReaderAddFailure, type ReaderAddOutcome, type ReaderAddRefusal, type ReaderAnnotationOutcome, type ReaderBackfillCandidate, type ReaderEntryBodyView, type ReaderBody, type ReaderCapabilities, type ReaderMutationOutcome, type ReaderEntryFetchState, type ReaderEntryTranslationView, type ReaderPreviewFailure, type ReaderPreviewFailureCode, type ReaderImageResult, type ReaderRecentEntry, type ReaderRefreshResult, type ReaderSentenceLearn, type ReaderSourceSummary, type ReaderStorageStats, type ReaderTag, type MediaCardStates } from './types.ts';
+import { type DocumentFetchLimits } from './document-fetch.ts';
 import { LocalTranscriber } from './local-transcribe.ts';
 import { ReaderMediaHost } from './media-host.ts';
 /**
@@ -95,6 +99,8 @@ export declare class ReaderService {
     private memoryDoc;
     /** Rescued images, by URL — a pane remount re-fails every blocked image, and this is what keeps that a memory read. */
     private readonly imageCache;
+    /** Feeds and pages, as the origin served them (see `document-fetch.ts`). */
+    private readonly documents;
     /**
      * @param ctx - owning context.
      * @param config - optional state-root override.
@@ -102,6 +108,7 @@ export declare class ReaderService {
     constructor(ctx: Context, config?: {
         stateRoot?: string;
         ytdlpPath?: string;
+        fetchLimits?: DocumentFetchLimits;
     });
     /** Capabilities the browser may rely on. */
     capabilities(): Promise<ReaderCapabilities>;
@@ -576,8 +583,6 @@ export declare class ReaderService {
      * known-unreadable verdict) still answers.
      */
     private resolvePaper;
-    /** The probed web seam (no host import, no boot-time dependency). */
-    private web;
     /** The probed side-chat service. */
     private sideChat;
     /**

package/lib/types/service.js

@@ -2,6 +2,7 @@ import { MAX_RECENT_ENTRIES, ReaderStore, ReaderStoreError, boundTranslations, e
 import { defaultSourceLabel, errorMessage, isRetryablePreviewFailure, linkEntryId, DEFAULT_CACHE_POLICY, DEFAULT_TRANSLATION_BUDGET_CHARS, INLINE_BODY_MAX_CHARS, TRANSLATION_STORAGE_VERSION, isCookieHandshake, } from "./types.js";
 import { delayUntilNext, isCatchUpDue } from "./schedule.js";
 import { arxivHtmlUrl } from "./arxiv.js";
+import { DocumentFetch } from "./document-fetch.js";
 import { fetchImageBytes, ImageFetchCache } from "./image-fetch.js";
 import { resolveLink } from "./link-resolvers.js";
 import { join } from 'node:path';
@@ -102,12 +103,15 @@ export class ReaderService {
     memoryDoc;
     /** Rescued images, by URL — a pane remount re-fails every blocked image, and this is what keeps that a memory read. */
     imageCache = new ImageFetchCache();
+    /** Feeds and pages, as the origin served them (see `document-fetch.ts`). */
+    documents;
     /**
      * @param ctx - owning context.
      * @param config - optional state-root override.
      */
     constructor(ctx, config = {}) {
         this.ctx = ctx;
+        this.documents = new DocumentFetch(() => this.ctx.get('web'), config.fetchLimits);
         this.store = new ReaderStore(config);
         const stateRoot = resolveReaderStateRoot(config.stateRoot);
         this.media = new ReaderMediaHost(stateRoot, config.ytdlpPath);
@@ -1390,7 +1394,7 @@ export class ReaderService {
      * known-unreadable verdict) still answers.
      */
     async resolvePaper(url) {
-        const web = this.web();
+        const web = await this.documents.current();
         const fetch = async (target) => {
             if (web === undefined)
                 throw new UnsupportedContent('no web capability is mounted');
@@ -1404,10 +1408,6 @@ export class ReaderService {
             return null;
         }
     }
-    /** The probed web seam (no host import, no boot-time dependency). */
-    web() {
-        return this.ctx.get('web');
-    }
     /** The probed side-chat service. */
     sideChat() {
         return this.ctx.get('sideChat');
@@ -1463,7 +1463,7 @@ export class ReaderService {
      * @returns the final URL and its decoded payload.
      */
     async fetchFollowing(url) {
-        const web = this.web();
+        const web = await this.documents.current();
         if (web === undefined)
             throw new UnsupportedContent('no web capability is mounted');
         let current = url;

package/lib/types/types.d.ts

@@ -97,8 +97,9 @@ export interface ReaderSource {
     /** Human-readable failure of the last attempt, when `status` is `error`. */
     readonly error?: string;
     /**
-     * True when the host's fetch seam cut the payload at its size limit
-     * (`maxBodyChars`, 100 000 by default). A truncated XML document cannot be
+     * True when the fetch cut the payload at its size limit (`maxBodyChars`:
+     * the reader's own 2 000 000, or the seam's limit where the reader fetches
+     * through it). A truncated XML document cannot be
      * parsed and a truncated HTML page yields a partial article, so every
      * consumer treats this as "incomplete" and says so rather than guessing.
      */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@khorsheed/dsh-reader",
   "description": "Link reader tab: RSS/Atom subscriptions plus pasted article links, a card feed with a readable detail view, host-side fetch and daily refresh over a Typert Remote data face",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -64,6 +64,7 @@
     "@deepseek-ai/dsh-session": "^0.1.0-rc.6 || ^0.2.0-rc.1 || ^0.2.1-rc.1",
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.6 || ^0.2.0-rc.1 || ^0.2.1-rc.1",
     "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.6 || ^0.2.0-rc.1 || ^0.2.1-rc.1",
+    "@deepseek-ai/dsh-web-fetch-http": "^0.1.0-rc.6 || ^0.2.0-rc.1 || ^0.2.1-rc.1",
     "react": "^18.2.0"
   },
   "peerDependenciesMeta": {
@@ -94,6 +95,9 @@
     "@deepseek-ai/dsh-tools": {
       "optional": true
     },
+    "@deepseek-ai/dsh-web-fetch-http": {
+      "optional": true
+    },
     "react": {
       "optional": true
     }
@@ -126,8 +130,8 @@
     },
     "compat": {
       "minHost": "0.1.5-rc.1",
-      "notes": "A page-type right-Sidebar tab (minted kind `reader`) over a Typert Remote data face. Fetching runs on the HOST through the sanctioned `ctx.web` seam; state is written with plain `node:fs` (atomic temp+rename) under `$DSH_HOME/state/dsh-reader`, NOT through `ctx.fs` — that service is the session-fenced sandboxed filesystem, so a workspace-write session refuses a write to the state root (observed on the acceptance instance). Every optional capability is probed at apply time and degrades (no `web` → domain refusals; no `sideChat` → the side-chat gesture hides; no `quote` → selection quoting is unavailable while the entry-level quote button still works). KNOWN LIMIT: the host fetch seam caps a decoded body at 100,000 chars and truncates silently, so articles larger than that cannot be extracted — the detail view falls back to a 「受限篇幅，内容未完整呈现」 notice with a 「阅读原文」 button (measured: Anthropic research pages, theverge.com, newyorker.com). On-device translation (0.2.0) runs the page's own Translator API (Chrome 138+/Edge 148+, desktop): the model never leaves the device and no model quota is spent, while the derived sentence pairs persist on the host (a global memory file plus per-entry segment maps under the state root, one shared budget, no TTL) so a reload re-paints instead of re-translating. Where that API is absent or the pair is unavailable, the globe is simply not rendered — the pane keeps working exactly as before — except that a browser without the API (iOS, Safari, Firefox) still offers the globe on a body whose stored per-entry map matches its hash, to VIEW that stored translation (no model, no retranslate). Source bodies that are already Chinese are not offered translation at all. On host 0.1.6-alpha.2+ the spots that want a real browser (the script-figure notice, a bot-wall card's action) open the in-app Sidebar Browser tab, probed through the `browser` tab kind; on older hosts they are the ordinary external link. Pages that inline real figures as base64 data URIs are now kept whole (substantive payloads over a 512-char threshold; 1px placeholders still yield to lazy-loading attributes), so a figure-heavy paper on a cap-raised deployment becomes a multi-MB cached body by design — bodies are bounded by entry count + TTL, not by a char budget. Notes (unreleased): the body highlight uses the CSS Custom Highlight API (no highlight without it, notes still work); the quote-menu 「记笔记」 row needs quote applied first, otherwise the detail foot button is the way in; 「回到会话」 needs ui-workspace's openSession; the ./tool row's reader_read / reader_note need the host tools registry and its reader skill the skills registry. The right-Sidebar tab self-hides on the ./tool row (2026-10-19, the canvas's dual check through the official pluginInventory Remote, probed): a root-mounted reader-tool row shows it everywhere, otherwise only sessions whose preset grants it (the learning and writing mode packs); every unreadable path fails open. Video and audio (unreleased): captions and channel listings run the plugin's own standalone yt-dlp on the host (fetched with curl on first use into the state root's bin/, self-updated after two weeks; ytdlpPath overrides); the YouTube embed is a frame of the plugin's own (allow-scripts allow-same-origin allow-presentation) driven over postMessage; Bilibili's player reports no time (seek = reload with t); Bilibili uploader spaces and most captions need a login. Local transcription of caption-less videos and audio probes the optional `transcribe` service (@khorsheed/dsh-transcribe) per start and states its absence; the audio is fetched through yt-dlp or curl into the state root's tmp/ and deleted once transcribed.",
-      "verifiedHost": "0.2.1-rc.1"
+      "notes": "A page-type right-Sidebar tab (minted kind `reader`) over a Typert Remote data face. Fetching runs on the HOST, gated on the `ctx.web` seam: on the official web service feeds and pages go through the reader's own instance of the official HTTP fetch provider (`@deepseek-ai/dsh-web-fetch-http`, optional peer), because from 0.2.1-rc.2 the web-search settings switch can move `ctx.web` fetching to the DeepSeek Fetch API, which answers Markdown instead of the document (seam registry S22); without that package fetches go through `ctx.web.fetch`; state is written with plain `node:fs` (atomic temp+rename) under `$DSH_HOME/state/dsh-reader`, NOT through `ctx.fs` — that service is the session-fenced sandboxed filesystem, so a workspace-write session refuses a write to the state root (observed on the acceptance instance). Every optional capability is probed at apply time and degrades (no `web` → domain refusals; no `sideChat` → the side-chat gesture hides; no `quote` → selection quoting is unavailable while the entry-level quote button still works). KNOWN LIMIT: the fetch caps a decoded body at 2,000,000 chars by default (100,000 before 2026-10-27; the reader row's `fetchLimits` changes it; limits on the `web-fetch-http` row no longer reach the reader) and truncates silently, so articles larger than that cannot be extracted — the detail view falls back to a 「受限篇幅，内容未完整呈现」 notice with a 「阅读原文」 button (measured: Anthropic research pages, theverge.com, newyorker.com). On-device translation (0.2.0) runs the page's own Translator API (Chrome 138+/Edge 148+, desktop): the model never leaves the device and no model quota is spent, while the derived sentence pairs persist on the host (a global memory file plus per-entry segment maps under the state root, one shared budget, no TTL) so a reload re-paints instead of re-translating. Where that API is absent or the pair is unavailable, the globe is simply not rendered — the pane keeps working exactly as before — except that a browser without the API (iOS, Safari, Firefox) still offers the globe on a body whose stored per-entry map matches its hash, to VIEW that stored translation (no model, no retranslate). Source bodies that are already Chinese are not offered translation at all. On host 0.1.6-alpha.2+ the spots that want a real browser (the script-figure notice, a bot-wall card's action) open the in-app Sidebar Browser tab, probed through the `browser` tab kind; on older hosts they are the ordinary external link. Pages that inline real figures as base64 data URIs are now kept whole (substantive payloads over a 512-char threshold; 1px placeholders still yield to lazy-loading attributes), so a figure-heavy paper on a cap-raised deployment becomes a multi-MB cached body by design — bodies are bounded by entry count + TTL, not by a char budget. Notes (unreleased): the body highlight uses the CSS Custom Highlight API (no highlight without it, notes still work); the quote-menu 「记笔记」 row needs quote applied first, otherwise the detail foot button is the way in; 「回到会话」 needs ui-workspace's openSession; the ./tool row's reader_read / reader_note need the host tools registry and its reader skill the skills registry. The right-Sidebar tab self-hides on the ./tool row (2026-10-19, the canvas's dual check through the official pluginInventory Remote, probed): a root-mounted reader-tool row shows it everywhere, otherwise only sessions whose preset grants it (the learning and writing mode packs); every unreadable path fails open. Video and audio (unreleased): captions and channel listings run the plugin's own standalone yt-dlp on the host (fetched with curl on first use into the state root's bin/, self-updated after two weeks; ytdlpPath overrides); the YouTube embed is a frame of the plugin's own (allow-scripts allow-same-origin allow-presentation) driven over postMessage; Bilibili's player reports no time (seek = reload with t); Bilibili uploader spaces and most captions need a login. Local transcription of caption-less videos and audio probes the optional `transcribe` service (@khorsheed/dsh-transcribe) per start and states its absence; the audio is fetched through yt-dlp or curl into the state root's tmp/ and deleted once transcribed.",
+      "verifiedHost": "0.2.1-rc.3"
     },
     "references": [
       "@khorsheed/dsh-quote",