@qwen-code/web-shell 0.24.4 → 0.24.5-nightly.20260924.ffea2d024e

package/dist/types/navigation.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { type ReactNode } from 'react';
+import type { DaemonProductSessionContext } from '@qwen-code/web-shell/daemon-react-sdk';
+import type { WebShellProps } from './App';
+import { type WebShellPage, type WebShellRoute } from './utils/navigationUrl';
+export type { WebShellPage } from './utils/navigationUrl';
+export interface WebShellUrlNavigationOptions {
+    /** URL pathname containing the shell, e.g. /agentic-code. Defaults to root. */
+    basePath?: string;
+}
+export interface NavigationSessionProps {
+    sessionId?: string;
+    workspaceId?: string;
+    workspaceCwd?: string;
+    sessionContext?: DaemonProductSessionContext;
+}
+interface NavigationController {
+    route: WebShellRoute;
+    revision: number;
+    openPage: (page: WebShellPage) => void;
+    returnToChat: () => void;
+    reconcilePage: (page: WebShellPage | undefined) => void;
+    beginSessionNavigation: (sessionId?: string, workspaceId?: string, sessionContext?: DaemonProductSessionContext) => void;
+    cancelSessionNavigation: () => void;
+    finishNewChat: (context?: DaemonProductSessionContext) => void;
+}
+export declare const useWebShellNavigation: () => NavigationController | undefined;
+export declare function WebShellNavigationBoundary({ options, externalTarget, onSessionIdChange, children, }: {
+    options?: WebShellUrlNavigationOptions;
+    externalTarget: NavigationSessionProps;
+    onSessionIdChange?: WebShellProps['onSessionIdChange'];
+    children: (target: NavigationSessionProps, onChange: NonNullable<WebShellProps['onSessionIdChange']>) => ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,67 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { Trajectory, TrajectoryRow } from './types';
+/** 0 main-session requests · 1 tool calls · 2 subagent requests. */
+export type TimelineLane = 0 | 1 | 2;
+export interface TimelineSpan {
+    /** The table row this span draws; selecting a span selects this row. */
+    rowKey: string;
+    row: TrajectoryRow;
+    lane: TimelineLane;
+    /** Offset into the compressed domain, ms. */
+    start: number;
+    end: number;
+    /** Requests with a recorded TTFT only: where the first token landed. */
+    ttftEnd?: number;
+    error: boolean;
+}
+/**
+ * How the axis treats time in which nothing ran. `active` cuts it out, so the
+ * strip answers where the running time went; `clock` keeps it, so the strip
+ * answers when things ran and how long the run waited between them.
+ */
+export type TimelineMode = 'active' | 'clock';
+export interface TimelineTurnMark {
+    turnIndex: number;
+    at: number;
+}
+export interface TimelineModel {
+    /** Ascending by start, then lane, then row key. */
+    spans: TimelineSpan[];
+    turnMarks: TimelineTurnMark[];
+    mode: TimelineMode;
+    /**
+     * Length of the domain. In `active` mode idle gaps are cut out, so this is
+     * the time during which at least one request or tool was running. In
+     * `clock` mode it runs from the first drawn span's start to the last one's
+     * end — which is the loaded window's span, not the session's age.
+     */
+    total: number;
+    /**
+     * Time during which at least one drawn span was running. Equal to `total` in
+     * `active` mode.
+     */
+    activeMs: number;
+    /** Epoch ms of domain 0: the earliest recorded start among drawn spans. */
+    originMs: number;
+    /**
+     * Rows with a recorded duration but no recorded start — tool calls from a
+     * session written before tools recorded one. Not drawn, never estimated.
+     */
+    droppedRows: number;
+}
+/**
+ * Project the rows that recorded both a start and a duration onto one time
+ * axis — with the idle stretches between them cut out (`active`, the default)
+ * or left in (`clock`).
+ *
+ * Only measured values are drawn. A row without a start is left off rather
+ * than placed next to its neighbours: a bar in the wrong place reads as a fact.
+ * Returns `undefined` when nothing in the window can be drawn.
+ */
+export declare function buildTimeline(trajectory: Trajectory, options?: {
+    mode?: TimelineMode;
+}): TimelineModel | undefined;

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

@@ -0,0 +1,27 @@
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { TimelineModel } from './buildTimeline';
+/**
+ * A stretch of the overview's domain, in the same compressed milliseconds as
+ * the spans. Always ordered: `start <= end`.
+ */
+export interface TimelineRange {
+    start: number;
+    end: number;
+}
+/**
+ * Rows whose span was running at any point in the range, ends included.
+ *
+ * With idle time cut out of the domain, spans cover it end to end, so any
+ * range finds at least one row. In `clock` mode the gaps stay on the axis, and
+ * a range that falls inside one finds nothing — an ordinary answer the panel
+ * says in words rather than an edge case.
+ *
+ * Closed on both sides so a zero-length span sitting on an edge — a tool that
+ * reported 0 ms, or a range made by a drag that stopped exactly on a bar's
+ * end — still counts as inside rather than vanishing from both sides.
+ */
+export declare function rowKeysInRange(model: TimelineModel, range: TimelineRange): Set<string>;

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

@@ -12,6 +12,7 @@ export interface TrajectoryTranscriptClient {
     getSessionTranscriptPage(sessionId: string, opts: {
         direction?: 'backward';
         limit?: number;
+        cursor?: string;
     }): Promise<TrajectoryPageResult>;
 }
 /**
@@ -20,8 +21,9 @@ export interface TrajectoryTranscriptClient {
  * Identity matters: the loader is the window hook's effect dependency, so a
  * fresh function on every render would refetch the newest page on every render.
  *
- * Reads ask for the newest page, which is the one the reader wants — the newest
- * turn is the one they just watched run. It deliberately goes through the raw
+ * Reads walk backward from the newest page, which is the one the reader wants —
+ * the newest turn is the one they just watched run — following the cursor each
+ * page hands back. It deliberately goes through the raw
  * client rather than
  * `DaemonSessionClient.getTranscriptPage`, which hydrates attachments and would
  * fetch image bytes this table never shows, and it never asks for the

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

@@ -42,9 +42,9 @@ export type TrajectoryEntry = {
 export interface TrajectoryTiming {
     durationMs: number;
     /**
-     * Requests only. Tool calls are logged in one loop after their whole batch
-     * settles, so the recorded timestamp is the batch's end for every tool in it
-     * and no honest per-tool start can be derived.
+     * Epoch ms. Requests have one whenever their end was recorded; tool calls
+     * only when the session recorded the call's start, which older sessions did
+     * not.
      */
     startedAt?: number;
     /** Requests only: dispatch to first user-visible content. */

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.20260924.ffea2d024e",
   "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": [