@astralform/js 9.5.0 → 9.7.0

package/dist/index.d.cts

@@ -2334,6 +2334,31 @@ declare class ChatSession {
      * pages, and a doubled prompt is more visible than a missing one.
      */
     prependMessages(older: Message[]): void;
+    /**
+     * Re-fetch the NEWEST page of the conversation list and merge it in.
+     *
+     * The list the sidebar renders is seeded once at `connect()` and then only
+     * changed by this client's own actions (create, delete, rename) — so a row's
+     * `activeJobId` is as fresh as that seed, and a job started in ANOTHER tab or
+     * on another device never appears, while one that ended elsewhere stays lit
+     * forever. A caller that refreshes on a trigger (the tab becoming visible, or
+     * a bounded interval while any job is live) keeps the rows honest without a
+     * socket per conversation.
+     *
+     * Merge rules, and why each is what it is:
+     *
+     *  - the server's ORDER wins for the rows it returns: an updated conversation
+     *    moves to its new place, which is the whole point of the call;
+     *  - rows paged in EARLIER (`loadMoreConversations`) are kept — this reads page
+     *    1 only, and dropping the tail would make a refresh silently truncate a
+     *    list the reader has already scrolled;
+     *  - a row the caller MINTED locally and the server does not know yet is kept
+     *    too (it has no server row to be refreshed by);
+     *  - `conversationsGeneration` is bumped, for the same reason `connect()`
+     *    bumps it: a page request already in flight was cut against the old head
+     *    and its offset no longer means what it did.
+     */
+    refreshConversations(): Promise<Conversation[]>;
     loadMoreConversations(): Promise<Conversation[]>;
     /**
      * Rename a conversation, server first.
@@ -2688,6 +2713,18 @@ declare class StreamManager {
         have?: ReadonlyArray<{
             jobId: string;
             lastSeq: number;
+            /**
+             * The prompt this job's turn drew, when the caller knows it.
+             *
+             * The caller's cache holds the PROMPT too (it renders the turn), and a
+             * prompt is a message-table row rather than a stream event — so the
+             * plan's empty-walk rescue has to be told which prompts are already on
+             * screen. Marks are matched against the page of jobs this restore walks,
+             * so a mark for an OLDER turn is not otherwise visible to that rescue,
+             * and a cache deeper than one turn page would re-emit those prompts as
+             * steer bubbles.
+             */
+            messageId?: string | null;
         }>;
     }): Promise<void>;
     /**

package/dist/index.d.ts

@@ -2334,6 +2334,31 @@ declare class ChatSession {
      * pages, and a doubled prompt is more visible than a missing one.
      */
     prependMessages(older: Message[]): void;
+    /**
+     * Re-fetch the NEWEST page of the conversation list and merge it in.
+     *
+     * The list the sidebar renders is seeded once at `connect()` and then only
+     * changed by this client's own actions (create, delete, rename) — so a row's
+     * `activeJobId` is as fresh as that seed, and a job started in ANOTHER tab or
+     * on another device never appears, while one that ended elsewhere stays lit
+     * forever. A caller that refreshes on a trigger (the tab becoming visible, or
+     * a bounded interval while any job is live) keeps the rows honest without a
+     * socket per conversation.
+     *
+     * Merge rules, and why each is what it is:
+     *
+     *  - the server's ORDER wins for the rows it returns: an updated conversation
+     *    moves to its new place, which is the whole point of the call;
+     *  - rows paged in EARLIER (`loadMoreConversations`) are kept — this reads page
+     *    1 only, and dropping the tail would make a refresh silently truncate a
+     *    list the reader has already scrolled;
+     *  - a row the caller MINTED locally and the server does not know yet is kept
+     *    too (it has no server row to be refreshed by);
+     *  - `conversationsGeneration` is bumped, for the same reason `connect()`
+     *    bumps it: a page request already in flight was cut against the old head
+     *    and its offset no longer means what it did.
+     */
+    refreshConversations(): Promise<Conversation[]>;
     loadMoreConversations(): Promise<Conversation[]>;
     /**
      * Rename a conversation, server first.
@@ -2688,6 +2713,18 @@ declare class StreamManager {
         have?: ReadonlyArray<{
             jobId: string;
             lastSeq: number;
+            /**
+             * The prompt this job's turn drew, when the caller knows it.
+             *
+             * The caller's cache holds the PROMPT too (it renders the turn), and a
+             * prompt is a message-table row rather than a stream event — so the
+             * plan's empty-walk rescue has to be told which prompts are already on
+             * screen. Marks are matched against the page of jobs this restore walks,
+             * so a mark for an OLDER turn is not otherwise visible to that rescue,
+             * and a cache deeper than one turn page would re-emit those prompts as
+             * steer bubbles.
+             */
+            messageId?: string | null;
         }>;
     }): Promise<void>;
     /**

package/dist/index.js

@@ -2772,6 +2772,48 @@ var ChatSession = class {
     if (!fresh.length) return;
     this.setMessages([...fresh, ...this.messages]);
   }
+  /**
+   * Re-fetch the NEWEST page of the conversation list and merge it in.
+   *
+   * The list the sidebar renders is seeded once at `connect()` and then only
+   * changed by this client's own actions (create, delete, rename) — so a row's
+   * `activeJobId` is as fresh as that seed, and a job started in ANOTHER tab or
+   * on another device never appears, while one that ended elsewhere stays lit
+   * forever. A caller that refreshes on a trigger (the tab becoming visible, or
+   * a bounded interval while any job is live) keeps the rows honest without a
+   * socket per conversation.
+   *
+   * Merge rules, and why each is what it is:
+   *
+   *  - the server's ORDER wins for the rows it returns: an updated conversation
+   *    moves to its new place, which is the whole point of the call;
+   *  - rows paged in EARLIER (`loadMoreConversations`) are kept — this reads page
+   *    1 only, and dropping the tail would make a refresh silently truncate a
+   *    list the reader has already scrolled;
+   *  - a row the caller MINTED locally and the server does not know yet is kept
+   *    too (it has no server row to be refreshed by);
+   *  - `conversationsGeneration` is bumped, for the same reason `connect()`
+   *    bumps it: a page request already in flight was cut against the old head
+   *    and its offset no longer means what it did.
+   */
+  async refreshConversations() {
+    const page = await this.client.getConversations(CONVERSATION_PAGE_SIZE, 0);
+    const pageIds = new Set(page.map((c) => c.id));
+    const known = new Set(this.conversations.map((c) => c.id));
+    this.conversationsGeneration++;
+    this.conversations = [
+      ...page,
+      // Everything the page did not mention: older pages, and rows that exist
+      // only on this client (a minted conversation the server has not been told
+      // about yet).
+      ...this.conversations.filter((c) => !pageIds.has(c.id))
+    ];
+    for (const c of page) {
+      this.serverConversationIds.add(c.id);
+      known.delete(c.id);
+    }
+    return page;
+  }
   async loadMoreConversations() {
     if (this.isLoadingConversations || !this.hasMoreConversations) return [];
     this.isLoadingConversations = true;
@@ -3367,6 +3409,7 @@ var StreamManager = class _StreamManager {
     const haveByJobId = new Map(
       (have ?? []).map((h) => [h.jobId, h.lastSeq])
     );
+    const heldFromMarks = (have ?? []).map((h) => h.messageId).filter((id) => typeof id === "string" && id.length > 0);
     const superseded = () => gen !== this.generation;
     if (superseded()) return;
     const turn = this.turnCounter;
@@ -3394,7 +3437,8 @@ var StreamManager = class _StreamManager {
       activeJobId,
       turn,
       jobsRequest,
-      haveByJobId
+      haveByJobId,
+      heldFromMarks
     ))
       return;
     if (activeJobId) {
@@ -3591,7 +3635,7 @@ var StreamManager = class _StreamManager {
       session.isLoadingEarlierTurns = false;
     }
   }
-  async replayHistory(conversationId, gen, activeJobId, turn, jobsRequest, haveByJobId) {
+  async replayHistory(conversationId, gen, activeJobId, turn, jobsRequest, haveByJobId, heldFromMarks) {
     const stopReplay = () => gen !== this.generation || this.viewTakenOverByLiveTurn() || this.turnStarted(turn);
     let complete = false;
     try {
@@ -3638,7 +3682,10 @@ var StreamManager = class _StreamManager {
         // primary cache scenario, a SETTLED conversation whose turns are all
         // held — and the empty-walk rescue would otherwise re-emit every one of
         // them as a steer bubble.
-        heldMessageIds: jobs.filter((j) => haveByJobId.has(j.job_id)).map((j) => j.message_id),
+        heldMessageIds: [
+          ...jobs.filter((j) => haveByJobId.has(j.job_id)).map((j) => j.message_id),
+          ...heldFromMarks
+        ],
         userMessages: userMessages.map((m) => ({
           id: m.id,
           content: m.content
@@ -3672,8 +3719,11 @@ var StreamManager = class _StreamManager {
           step.messageId
         );
       }
-      this.session.hasMoreTurns = page.hasMore;
-      this.session.oldestTurnCursor = page.nextBefore;
+      const drewNothing = plan.length === 0;
+      const holdsTurns = haveByJobId.size > 0;
+      const noDrawableTurns = drewNothing && holdsTurns;
+      this.session.hasMoreTurns = noDrawableTurns ? false : page.hasMore;
+      this.session.oldestTurnCursor = noDrawableTurns ? null : page.nextBefore;
       this.oldestDrawnMessageId = plan[0]?.messageId ?? null;
       complete = true;
       if (stopReplay()) return false;