@itookit/dsht 0.5.1 → 0.5.2

package/dist/cost/controller.js

@@ -30,10 +30,11 @@ export class CostController {
         this.timer = setInterval(() => { if (this.host.online())
             void this.refresh().catch(() => undefined); }, REFRESH_INTERVAL_MS);
     }
-    /** Stop the timer and wait for an in-flight scan; the ledger keeps its folded totals. */
+    /** Cancel the timer and active scan, then wait for cleanup; keep already folded totals. */
     async stop() {
         clearInterval(this.timer);
         this.timer = undefined;
+        this.abort?.abort();
         await this.task;
     }
     /** Refresh after the host reports a turn complete. */
@@ -45,8 +46,11 @@ export class CostController {
      * @param signal - Optional cancellation for an explicit `/cost` refresh.
      */
     async refresh(signal = this.host.signal()) {
+        signal.throwIfAborted();
+        this.host.signal().throwIfAborted();
         if (this.task) {
-            const cancel = () => this.abort?.abort();
+            const scanAbort = this.abort;
+            const cancel = () => scanAbort?.abort();
             signal.addEventListener('abort', cancel, { once: true });
             try {
                 await this.task;
@@ -64,9 +68,9 @@ export class CostController {
         const ledger = this.ledger;
         ledger.scanning = true;
         ledger.error = '';
-        this.host.publish();
-        const task = (async () => {
+        const task = Promise.resolve().then(async () => {
             try {
+                combined.throwIfAborted();
                 const sessions = array(object(await client.call('session/list', { _request: {} }, combined)).items).map(object);
                 combined.throwIfAborted();
                 const failures = [];
@@ -82,6 +86,7 @@ export class CostController {
                         scanned++;
                         events += history.events.length;
                         await ledger.replace(sessionId, history.cursor, history.events);
+                        combined.throwIfAborted();
                         if (!session.running && typeof session.updatedAt === 'number')
                             this.updates.set(sessionId, session.updatedAt);
                         this.host.publish();
@@ -103,8 +108,10 @@ export class CostController {
                 ledger.scanning = false;
                 this.host.publish();
             }
-        })();
+        });
         this.task = task;
+        // Publish only after reserving the scan: an observer may synchronously join or cancel it.
+        this.host.publish();
         try {
             await task;
         }

package/dist/cost/scanner.js

@@ -45,6 +45,7 @@ export async function sessionCostHistory(client, session, signal, onPage, onReco
 }
 /** Page one addressed session's history into the billing events the ledger folds. */
 async function readCostHistory(client, address, signal, onPage, onRecords) {
+    signal.throwIfAborted();
     onPage?.();
     const snapshot = await new Promise((resolve, reject) => {
         let sub;

package/dist/session/controller.d.ts

@@ -1,6 +1,6 @@
 import type { HostAccess } from '../transport/host.ts';
 import { type Json, type ObjectValue } from '../transport/wire.ts';
-import type { ControllerStore, State } from '../state.ts';
+import type { SessionStore } from './state.ts';
 import { type SessionRender } from './history.ts';
 import type { HistoryLimits } from './memory.ts';
 import { type FileReference } from './references.ts';
@@ -19,16 +19,18 @@ export declare class SessionController {
     private readonly connection;
     private readonly historyLimits;
     private follow;
-    private interactions;
+    private readonly history;
+    private readonly interactions;
+    private readonly navigation;
     /** Reading protection: reclamation pauses while the reader is away from the live end. */
     private historyPinned;
     /** Host runtime mirrors for every session this connection has seen. */
     private readonly runtime;
     /** Cancels the background prompt backfill of the previous selection. */
-    private promptBackfill?;
+    private readonly promptBackfill;
     /** Prompts of sessions this process has already read, so re-opening one costs no page request. */
     private readonly promptCache;
-    /** Prompt index, composer and reading view of the selected session; the instance `State.session` exposes. */
+    /** Prompt index, record, history window and interaction state of the selected session. */
     private get info();
     private get prompts();
     private stoppingSession?;
@@ -36,13 +38,13 @@ export declare class SessionController {
     private admission;
     /** Admission order of this session's writes, so two concurrent decisions cannot interleave. */
     private readonly mutations;
-    constructor(store: ControllerStore, host: HostAccess, connection: ConnectionView, historyLimits: HistoryLimits, report?: (admission: MutationAdmission) => void);
+    constructor(store: SessionStore, host: HostAccess, connection: ConnectionView, historyLimits: HistoryLimits, report?: (admission: MutationAdmission) => void);
     /** Host running state covers model generation, tools, and waits between assistant attempts. */
     get running(): boolean;
     /** Current title projection, falling back to the list title and then the session ID. */
     get sessionName(): string | undefined;
     /** Current agent-preset name, matching the web header's built-in labels and custom metadata. */
-    get sessionMode(): string | undefined;
+    sessionMode(presets?: readonly ObjectValue[]): string | undefined;
     /** Epoch start from the retained turn log, or when this client first observed the run. */
     get workingSince(): number | undefined;
     /** Present only sessions explicitly accounted to the selected workspace. */
@@ -76,15 +78,15 @@ export declare class SessionController {
     beginGeneration(): void;
     /** Invalidate in-flight work and drop transient interactions when a generation ends. */
     endGeneration(): void;
-    /** Wait for an in-flight cancellation so shutdown leaves nothing running. */
+    /** Wait for cancellation and foreground history tasks before releasing their records. */
     settle(): Promise<void>;
     /** Release the selected transcript and its layout caches. */
     release(): void;
     /** Pending interactions for the selected chat session, derived independently of frame order.
-     * @param state - State being published.
+     * @param sessionId - Session whose pending interactions are being published.
      * @returns Retained question and approval frames for that session.
      */
-    pendingFor(state: State): PendingInteraction[];
+    pendingFor(sessionId: string | undefined): PendingInteraction[];
     /** Unanswered interactions by session, so a list can show who is waiting without opening them.
      *
      * The host delivers approval and question waterfalls for every session on one stream, and this
@@ -127,7 +129,9 @@ export declare class SessionController {
     /** Refresh both lists from the host, then show the requested picker.
      * @param screen - Picker to display after the refresh.
      */
-    showPicker(screen: 'workspaces' | 'sessions'): Promise<void>;
+    showPicker(screen: 'workspaces' | 'sessions', signal?: AbortSignal): Promise<void>;
+    /** Refresh navigation data without taking the reader to another screen. */
+    refreshLists(): Promise<void>;
     /** Return to the selected conversation without re-selecting it.
      *
      * A picker opened over a conversation is a detour: leaving it must not re-subscribe, reload the
@@ -152,11 +156,11 @@ export declare class SessionController {
     /** Open a workspace picker, or resolve a workspace by ID, exact title/path, or unique ID prefix.
      * @param query - Workspace target, if any.
      */
-    switchWorkspace(query?: string): Promise<void>;
+    switchWorkspace(query?: string, signal?: AbortSignal): Promise<void>;
     /** Guide workspace selection, list all sessions with `all`, or resolve an exact session target.
      * @param query - Session target, `all`, or nothing for the guided picker.
      */
-    switchSession(query?: string): Promise<void>;
+    switchSession(query?: string, signal?: AbortSignal): Promise<void>;
     /** Prompt for a host path without starting a local agent. */
     enterPath(): void;
     /** Adopt the workspace whose registered path contains the directory this client runs in.
@@ -171,9 +175,9 @@ export declare class SessionController {
     /** Register a host directory and move to its session picker.
      * @param path - Absolute directory path on the host.
      */
-    createWorkspace(path: string): Promise<void>;
+    createWorkspace(path: string, signal?: AbortSignal): Promise<void>;
     /** Create a session only after the user explicitly selects New session. */
-    createSession(): Promise<void>;
+    createSession(signal?: AbortSignal): Promise<void>;
     /** Create a session for another purpose without selecting it, named so a reader can tell it apart.
      *
      * A verifier runs in its own session while the reviewed session stays selected, so this never
@@ -193,6 +197,9 @@ export declare class SessionController {
      * @param sessionId - Session to follow.
      */
     selectSession(sessionId: string): Promise<void>;
+    /** Reattach the selected conversation after reconnect, keeping the current navigation context. */
+    restoreSelectedSession(): void;
+    private followSession;
     /** Wait for the selected follow snapshot, failing on disconnect or cancellation.
      * @param signal - Cancels waiting without closing the session.
      */
@@ -311,11 +318,6 @@ export declare class SessionController {
      * @returns Whether any older prompt was recovered.
      */
     refillRecall(): boolean;
-    /** Seed recall from a complete cached entry, so an open that follows a scan costs no request.
-     * @param sessionId - Session being opened.
-     * @returns Whether the cache covered this session.
-     */
-    private adoptCachedPrompts;
     /** Fold one history page the cost scan already read into the prompt cache.
      *
      * The scan reads every session's whole history on connect, so this is where two readers stop
@@ -328,29 +330,17 @@ export declare class SessionController {
      * @param sessionId - Session the scan finished.
      */
     rememberScanDone(sessionId: string): void;
-    /** Fold every prompt the host still holds into the recall index, in the background.
-     *
-     * Session start delivers only the newest window, so without this the arrows could reach older
-     * prompts but not show them without paging first. Each page is parsed into a temporary transcript
-     * and only its prompts are kept, so the live record, its memory window and the row cache never
-     * grow. The walk is bounded and the next selection cancels it; anything past the bound is still
-     * reachable through the lazy backward step.
-     * @param sessionId - Session being opened.
-     * @param selection - Selector generation that must still be current.
-     */
-    private backfillPrompts;
     /** Search one page at a time, preserving only the first 200 matches and releasing temporary content.
      * @param query - Literal, case-insensitive text including folded reasoning.
      * @param signal - Cancels HTTP and processing without cancelling the agent.
      * @returns Newest-first bounded summaries and an explicit truncation flag.
      */
     searchHistory(query: string, signal: AbortSignal): Promise<HistorySearch>;
-    /** Load a separate small window ending at a search target; the live transcript keeps following.
+    /** Select a readable window by sequence; temporary records never escape to the UI.
      * @param target - Durable message sequence to display.
      * @param signal - Cancels the target-page request.
-     * @returns A caller-owned historical window that must be disposed when closed.
      */
-    historyAt(target: number, signal: AbortSignal): Promise<Transcript>;
+    openHistory(target: number, signal: AbortSignal): Promise<void>;
     /** Load the prefix required for an explicit history jump; never loop on an unadvancing page.
      * @param target - Visible record sequence, or first for the oldest available history.
      * @param signal - Cancels local paging without interrupting the remote agent.
@@ -364,6 +354,4 @@ export declare class SessionController {
     private releaseTranscript;
     /** @returns The selected session identity, or a `Select a session first` failure. */
     private get sessionId();
-    /** Answer one retained waterfall through the connection's event-result endpoint. */
-    private reply;
 }