@qwen-code/web-shell 0.24.4 → 0.24.5-nightly.20260925.c3a4058a0c

package/dist/types/trajectory/useTrajectoryWindow.d.ts

@@ -11,6 +11,18 @@ import type { Trajectory } from './types';
  * shorter than this — `truncated` is what says so, never the count.
  */
 export declare const TRAJECTORY_PAGE_SIZE = 250;
+/**
+ * Pages read, newest first, before the window is drawn. The window is
+ * re-projected whole on every change and each page is a full replay of its
+ * records, so this is what bounds the retained bytes and the per-change work —
+ * and holding four pages where the table held one raises both by four, to 1000
+ * records nominally. The true worst case is nearer 3000: a backward page can
+ * exceed the limit it was asked for, because the daemon extends it to keep
+ * turns and tool pairs whole, up to `3 * limit` records and its own 4 MB
+ * ceiling. Four is where that ceiling stays defensible while still reaching a
+ * useful way back.
+ */
+export declare const TRAJECTORY_MAX_PAGES = 4;
 /**
  * The fields of a transcript page this view reads. Narrower than the daemon's
  * own page type on purpose: the client's page satisfies it structurally, and a
@@ -19,11 +31,14 @@ export declare const TRAJECTORY_PAGE_SIZE = 250;
 export interface TrajectoryPageResult {
     events: readonly DaemonEvent[];
     hasMore: boolean;
+    /** Where the next older page starts; absent when there is none to ask for. */
+    nextCursor?: string;
     partial?: true;
     replayError?: string;
 }
 /**
- * Fetches the newest page of the session's transcript.
+ * Fetches one page of the session's transcript: the newest without a cursor,
+ * the one older than a previous page with that page's `nextCursor`.
  *
  * Supplied by the host rather than called here so the panel never reaches for
  * a daemon client of its own. There is no cancellation: the daemon client
@@ -32,11 +47,12 @@ export interface TrajectoryPageResult {
  */
 export type TrajectoryPageLoader = (opts: {
     limit: number;
+    cursor?: string;
 }) => Promise<TrajectoryPageResult>;
 /**
- * Why the last read failed. `partial` is not a message — the daemon reports it
- * as a flag — so it is carried as a kind for the view to name, rather than as
- * a word that would end up quoted at the reader.
+ * Why a read failed. `partial` is not a message — the daemon reports it as a
+ * flag — so it is carried as a kind for the view to name, rather than as a
+ * word that would end up quoted at the reader.
  */
 export type TrajectoryWindowFailure = {
     kind: 'partial';
@@ -47,29 +63,51 @@ export type TrajectoryWindowFailure = {
 export interface TrajectoryWindow {
     trajectory: Trajectory | undefined;
     status: 'idle' | 'loading' | 'ready' | 'error';
+    /**
+     * The newest page could not be read. The window already on screen, if any,
+     * is kept.
+     */
     error?: TrajectoryWindowFailure;
     /**
-     * The session has history older than what this page carries. Nothing here
-     * can reach it yet, so the view says so rather than offering an action.
+     * Pages read so far by the load under way, or held by the window once it
+     * is ready. What the placeholder counts while the walk back is running.
+     */
+    loadedPages: number;
+    /**
+     * The session has history older than the window: the walk stopped at the
+     * page cap, at a page the daemon gave no cursor for, or at an older page it
+     * could not read.
      */
     truncated: boolean;
-    /** Re-read the newest page. Also how a failed read is retried. */
+    /**
+     * An older page could not be read, so the window stops just after it. The
+     * newer pages are drawn; `refresh` is the retry.
+     */
+    olderFailure?: TrajectoryWindowFailure;
+    /** Read the window again from the newest page. Also every retry. */
     refresh: () => void;
 }
 /**
- * Hold the newest page of one session's transcript and fold it into a
- * trajectory.
+ * Hold a window of one session's transcript and fold it into a trajectory.
+ *
+ * The pages are this view's own: paged replay is the only path that emits
+ * timing frames, and the chat store is fed by the live stream and by bulk
+ * replay, neither of which carries them. Reading here also keeps the window
+ * contiguous by construction, which is what lets the projection pair a frame
+ * with what it measured.
  *
- * The page is this view's own: paged replay is the only path that emits timing
- * frames, and the chat store is fed by the live stream and by bulk replay,
- * neither of which carries them. Reading here also keeps the window contiguous
- * by construction, which is what lets the projection pair a frame with what it
- * measured.
+ * A load walks back from the newest page by cursor, up to the page cap, and
+ * the window lands once, whole, when the walk ends. Nothing is ever put in
+ * front of rows already drawn: a list that grew upwards under the reader would
+ * have to move its scroll offset, its keys, its selection and its focus in
+ * step, and no part of that is observable outside a real browser.
  *
- * `refresh` replaces the page rather than splicing into it: page boundaries
- * are chosen per request, so a fresh page and the held one overlap by an
- * unknown amount and cannot be joined without dropping or repeating records.
+ * `refresh` rebuilds the window from the newest page rather than splicing into
+ * it: page boundaries are chosen per request, so a fresh page and the held
+ * ones overlap by an unknown amount and cannot be joined without dropping or
+ * repeating records.
  */
 export declare function useTrajectoryWindow(loadPage: TrajectoryPageLoader | undefined, options?: {
     pageSize?: number;
+    maxPages?: number;
 }): TrajectoryWindow;

package/dist/types/turnCallsContext.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+/**
+ * Opens the right-panel list of tool calls belonging to one turn. `turnId` is
+ * the id of the turn's leading user message.
+ */
+export type OpenTurnCalls = (turnId: string, recordId?: string, promptId?: string, promptLabel?: string) => void;
+export declare function isTurnCallsPrompt(source: unknown, text: string): boolean;
+export declare function TurnCallsProvider({ onOpen, children, }: {
+    onOpen: OpenTurnCalls | undefined;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useOpenTurnCalls(): OpenTurnCalls | undefined;

package/dist/types/utils/navigationUrl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const WEB_SHELL_PAGES: readonly ["plugins", "channels", "scheduled-tasks", "goals", "settings"];
+export type WebShellPage = (typeof WEB_SHELL_PAGES)[number];
+export interface SessionUrlTarget {
+    sessionId?: string;
+    workspaceId?: string;
+    context?: 'standalone' | 'live';
+}
+export type WebShellRoute = {
+    page: WebShellPage;
+} | ({
+    page: 'chat';
+} & SessionUrlTarget);
+export declare function normalizeNavigationBasePath(basePath?: string): string;
+export declare function isWebShellPage(value: string): value is WebShellPage;
+export declare function readNavigationUrl(url: URL, basePath?: string): WebShellRoute | undefined;
+export declare function buildNavigationUrl(current: URL, route: WebShellRoute, basePath?: string): URL;

package/dist/types/utils/popoverRoom.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The top clearance a host declares for upward-opening popovers through
+ * `--web-shell-popover-safe-top`, or `undefined` when it declares none. A
+ * declared `0px` stays 0 instead of falling back to a default.
+ */
+export declare function readPopoverSafeTop(element: Element): number | undefined;
+export declare const POPOVER_MIN_HEIGHT = 96;
+/**
+ * The highest viewport y at which a popover positioned inside `anchor` is still
+ * painted: below the top edge of every ancestor that clips its overflow, and
+ * below the host's declared safe top.
+ *
+ * With no declared safe top the bound starts at 0, because an in-flow popover
+ * is already bounded by the clipping ancestors this walk measures. A popover
+ * portaled out of that chain has no clipping ancestor to measure and needs a
+ * numeric allowance instead — see AtMentionPanel's
+ * `readPopoverSafeTop(anchor) ?? 48`. Keep the two defaults distinct: folding
+ * the 48 in here would steal room from in-flow popovers, and folding the 0
+ * into AtMentionPanel would let it rise under a host header that declares
+ * nothing.
+ */
+export declare function popoverTopEdge(anchor: Element): number;

package/dist/types/utils/sessionPath.d.ts

@@ -3,6 +3,7 @@
  * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+export declare function inferStandaloneBasePath(pathname: string): string;
 /**
  * Build the pathname for a standalone session URL while preserving any base
  * path the app is deployed under (e.g. `/app/session/<id>` stays under

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwen-code/web-shell",
-  "version": "0.24.4",
+  "version": "0.24.5-nightly.20260925.c3a4058a0c",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/QwenLM/qwen-code.git",
@@ -22,6 +22,10 @@
     "./transcript": {
       "types": "./dist/types/transcript.d.ts",
       "import": "./dist/transcript.js"
+    },
+    "./code-highlighter": {
+      "types": "./dist/types/code-highlighter.d.ts",
+      "import": "./dist/code-highlighter.js"
     }
   },
   "files": [