dsh-zen-remote 1.1.16 → 2.0.0

package/lib/types/merge-streams.d.ts

@@ -0,0 +1,393 @@
+/**
+ * Pure mergers for the three GLOBAL calls (T23b-2): `workspace/follow` and
+ * `session/control` are STREAMS whose frames carry no session-locating
+ * argument, and `session/list` is an unscoped invoke — the sidebar reads all
+ * three to render its tree, so a sub-client must see the server's shared
+ * sessions merged INTO the local answer instead of in place of it.
+ *
+ * Frame and result shapes are the generated 0.2.0 codecs, field by field:
+ * `workspace_follow_result` (baseline / upsert / remove / order / archived /
+ * pinned), `session_control_result` (exactly two frame types: `baseline`
+ * nesting `value.projections`, and one-key `projection` updates), and
+ * `session_list_result` (`{ items }` — no cursor field). The same shapes the
+ * server filters by (relay-filter.ts); remote frames arriving here have
+ * ALREADY been narrowed to the shared sessions and carry ORIGINAL ids.
+ *
+ * The rules, mirroring tasks/T23b2.md as corrected by tasks/T23b2-fix.md:
+ * - local frames pass through, except that `baseline` / `order` get the
+ *   remote workspaces APPENDED to their order (remote groups sort after
+ *   local) and the `archived` / `pinned` lists merge local + remote;
+ * - a remote baseline NEVER travels as a second baseline — it would wipe the
+ *   local data. It becomes one virtualized `upsert` per remote workspace,
+ *   then the merged `order` / `archived` / `pinned`;
+ * - remote frames that arrive before the local baseline are CACHED as state
+ *   only — the UI has seen nothing yet, so emitting them would order
+ *   workspaces the local baseline would immediately erase;
+ * - a remote stream that died (or a merely offline relay) emits NOTHING and
+ *   keeps the shown state ({@link WorkspaceMerger.onRemoteDown}): the UI's
+ *   `ClientWorkspaceModel.remove()` records ids in a never-cleared blacklist
+ *   and both `upsert` and baseline replacement drop blacklisted ids, so one
+ *   `remove` for a virtual id would make that group un-revivable on
+ *   reconnect — while the UI itself keeps the last complete projection
+ *   visible across carrier loss (its `handleCarrierFailure`);
+ * - a NEW remote baseline on the same server is DIFFED against the shown
+ *   set: still present → fresh `upsert` (content from the new baseline),
+ *   absent (deleted server-side / no longer shared) → `remove`, then the
+ *   merged `order` / `archived` / `pinned`;
+ * - a server RENAME (same serverId) re-upserts the shown groups under the
+ *   new title — no removals ({@link WorkspaceMerger.onServerRenamed});
+ * - only a serverId CHANGE removes the whole group
+ *   ({@link WorkspaceMerger.onRemoteGone}): the new prefix is fresh, so it
+ *   can never collide with the UI's blacklist. The relay entering
+ *   `unpaired` / `revoked` is NOT this case (T23b2-fix3): the server
+ *   persists its serverId (relay-server.ts loadServerId), so a re-pair to
+ *   the same server reuses the prefix and is handled as a remote death
+ *   ({@link WorkspaceMerger.onRemoteDown}) — the reconnect diff revives
+ *   the group;
+ * - a relay status that is not serving normally (T34: offline, unpaired,
+ *   revoked, interface mismatch) only ANNOTATES TITLES: setStatus +
+ *   onStatusChanged re-upsert the shown groups under the annotated titles,
+ *   and the reconnecting baseline (which always upserts) restores them.
+ * - a session the SERVER stopped serving (remote closed / idle-slept / its
+ *   fork parent closed → the filtered workspace upsert drops it from
+ *   `sessionIds`) keeps a TOMBSTONE in the group it was last seen in (CP4,
+ *   reworked by CP4-client-fix2): the merger remembers the workspace each
+ *   session id was last carried by, and the forwarded record for THAT
+ *   workspace still lists the id (appended at the end of `sessionIds`). The
+ *   UI's session store keeps the merged projection/list entry and nothing
+ *   ever removes it, so without this the sidebar would park the session in
+ *   「未分组」 forever — and hiding it in the merged `archived` frame instead
+ *   (what CP4-client first did) makes the RT navigation guard
+ *   `clearArchivedCurrent` (dsh-client-ui-workspace `watchNavigation`) kick
+ *   the OPEN session page back to the home page before its 「远程已关闭」
+ *   banner can show. A re-share (the id back in some workspace's
+ *   `sessionIds`) renders it live again and clears the tombstone; the
+ *   tombstone dies with its workspace (a remove) and with the identity
+ *   (onRemoteGone).
+ * - T58 reworks the tombstone's VISIBILITY, reshaped by T65: a closed-remote
+ *   session is HIDDEN — moved into the merged `archived` set (the host's
+ *   `sessionVisible` hides archived ids under the default filter) — while
+ *   STAYING in its group's forwarded `sessionIds`: under「显示已归档」it
+ *   renders in place, and it can never resurface as a 「未分组」 stray. The
+ *   one exception is the session the user currently has OPEN: it is not
+ *   hidden at all (the page must keep its 「远程已关闭」 banner), and once
+ *   the caller reports a different current session
+ *   ({@link WorkspaceMerger.setCurrentSession}) it moves into `archived`
+ *   too. `archived` is exactly what the host's navigation guard
+ *   `clearArchivedCurrent` acts on, so the CURRENT session may never enter
+ *   it — and an unreadable current-session signal falls back to the
+ *   conservative tombstone behavior (nothing is hidden). Because the
+ *   browser's report can lag the user's switch by up to a poll interval, a
+ *   JUST-created tombstone is not hidden for a short grace (T65, injectable
+ *   clock): the 1s poll re-judges with the fresh report afterwards — the
+ *   session the user really switched to keeps its tombstone, anything else
+ *   hides. Re-sharing the session takes it back out of `archived`
+ *   (live-carried ids never count as hidden). Since hiding moves only the
+ *   archived set, hide/reveal updates are exactly one merged archived frame
+ *   — no group content changes, no ordering dance; the current session
+ *   never enters the set by construction. The hidden ids are sticky: they
+ *   survive even the death of their home workspace until a re-share or the
+ *   identity ends.
+ * - a workspace with NOTHING to show is not shown at all (T56): the server
+ *   keeps every workspace and only narrows `sessionIds` (relay-filter.ts),
+ *   so a workspace where nothing is shared would arrive as an empty group
+ *   and render as a bare 「服务端名 · 工作区名」 heading. A workspace the UI
+ *   has never seen is therefore held back — no baseline item, no upsert, no
+ *   order entry — until its forwarded `sessionIds` (live sessions or
+ *   tombstones it must carry) first gains content. From that first forward
+ *   on it counts as SHOWN and stays shown even when the sessions leave
+ *   again: a `remove` would blacklist the id in the UI's ClientWorkspaceModel
+ *   and make the group un-revivable, so an emptied group keeps its (empty)
+ *   display until the page reload rebuilds the model and this rule hides it
+ *   again. Every removal path — the reconnecting baseline diff, an explicit
+ *   server remove, {@link WorkspaceMerger.onRemoteGone} — emits a `remove`
+ *   only for shown workspaces; never-shown ones leave the state silently.
+ *
+ * Two KNOWN LIMITATIONS, both rooted in the UI's `removedIds` blacklist
+ * never clearing during a page's life (a reload rebuilds the model from
+ * scratch, which is why a reload fixes both):
+ * - switch to a DIFFERENT server and later back to the SAME old one: the
+ *   switch-away removed the old prefix, so the returning group's upserts
+ *   are dropped by the blacklist and it stays invisible until the page is
+ *   reloaded;
+ * - the server deletes a workspace and later shares a NEW workspace under
+ *   the SAME id: the deletion's remove blacklists the id, and the new
+ *   workspace's upserts are dropped the same way.
+ *
+ * Everything here is a pure state machine: no DSH imports, no network, no
+ * clocks — the virtual-id arithmetic is the one dependency (virtual-id.ts).
+ * Shapes are read defensively like relay-filter.ts does: a malformed frame is
+ * dropped (diagnosed through the optional hook), never forwarded.
+ *
+ * T52 adds two RESULT-side pure helpers on the same principles:
+ * {@link mergeModelCatalogs} folds the relay's `session/modelCatalog` answer
+ * into the local one (the catalog is the model-selection dropdown's data), and
+ * {@link virtualizeModelSelectionValue} rewrites a `modelSelection` projection
+ * value's provider ids to virtual group ids so the UI can find the current
+ * model's display name in the merged catalog.
+ *
+ * T52-fix2 made that rewrite CONDITIONAL on the server catalog listing the
+ * provider; T52-fix3 reverts it to UNCONDITIONAL, and the revert is final:
+ * the host's projection store is FIRST-WRITE-WINS per sequence number
+ * (dsh-api-session-controller lib/client.js:986-994 —
+ * `if (row?.kind === "sequenced" && seq <= row.seq) return`, and the
+ * seed / list blocks take the same road). A projection rewritten ORIGINAL
+ * while the catalog had not landed yet occupies its seq; when the catalog
+ * arrives, the same seq's VIRTUAL value is dropped as stale — the server
+ * group never gets its check mark, and resubmitting a reasoning effort
+ * echoes the ORIGINAL provider back, which `session/selectModel`'s routing
+ * refuses ("请选择「服务端 · …」分组里的模型"). The rewrite of ONE provider
+ * must therefore not depend on when the catalog happened to arrive. The
+ * accepted cost: a provider absent from the server's OWN catalog renders the
+ * `zr~<serverId>~provider/model` fallback string (the pre-fix2 display).
+ */
+/** The (serverId, serverName) pair a merger virtualizes with. A re-handshake
+ * with a different server retargets the SAME merger ({@link retarget}) so the
+ * locally observed baseline/order state survives the swap. */
+export interface MergerIdentity {
+    serverId: string;
+    serverName: string;
+}
+/**
+ * The status annotation (T34) appended to every shown remote group's title
+ * while the relay is not serving normally. The CALLER (intercept.ts) maps the
+ * relay state onto one annotation — `revoked` / `unpaired` outrank `offline`,
+ * which outranks `mismatch` — and the merger only renders the suffix it is
+ * told to. The suffixes are the CHINESE copy, deliberately hardcoded here:
+ * this module is background code with no access to the UI language (the
+ * English forms live in src/client/locales.ts, `remoteGroup*` keys).
+ */
+export type MergerAnnotation = 'none' | 'offline' | 'revoked' | 'unpaired' | 'mismatch';
+export interface WorkspaceMergerOptions extends MergerIdentity {
+    /** Diagnostics for frames this merger dropped (unknown type or malformed).
+     * Optional: without it the drop is silent. */
+    onDiagnostic?: (message: string) => void;
+    /** T65: the clock the tombstone hide-grace runs on. Default Date.now;
+     * tests advance an injectable fake to cross the grace. */
+    now?: () => number;
+}
+export interface WorkspaceMerger {
+    readonly serverId: string;
+    readonly serverName: string;
+    /** Feed one frame of the LOCAL workspace/follow stream; returns the frames
+     * the UI should see (usually exactly the input, order-merged when remote
+     * state exists). */
+    onLocal(frame: unknown): unknown[];
+    /** Feed one server-filtered frame of the REMOTE stream; returns the frames
+     * the UI should see (possibly none — state-only while the local baseline
+     * has not passed). A later baseline is DIFFED against what was shown. */
+    onRemote(frame: unknown): unknown[];
+    /** The remote stream died or the relay went offline (the same server is
+     * expected back): emits NOTHING and keeps the shown state — the UI keeps
+     * the last projection visible across carrier loss, and a `remove` here
+     * would blacklist the virtual ids against revival. */
+    onRemoteDown(): unknown[];
+    /** The remote side is gone FOR GOOD under THIS identity: a serverId
+     * change. (Since T23b2-fix3 an `unpaired` / `revoked` relay is NOT this
+     * case — the same serverId comes back on re-pair, so the caller uses
+     * {@link onRemoteDown} there.) Removes everything shown from the remote
+     * side, resets the remote state. Idempotent — a second call with no
+     * remote state returns []. */
+    onRemoteGone(): unknown[];
+    /** The server was renamed (same serverId — call after {@link retarget}):
+     * re-upserts every shown workspace under the new title, nothing else. */
+    onServerRenamed(): unknown[];
+    /** Record the status annotation (T34) future virtualized titles carry. No
+     * frames on its own — pair it with {@link onStatusChanged} to re-upsert the
+     * shown groups under the new annotation, or let the next natural upserts
+     * (a reconnecting baseline) carry it. */
+    setStatus(annotation: MergerAnnotation): void;
+    /** Re-upsert every SHOWN workspace under the CURRENT annotation: the whole
+     * update when the relay's serving status changed without any remote frame
+     * (offline, revoked, unpaired, version mismatch). [] while nothing is
+     * shown (no local baseline yet, or no remote state). */
+    onStatusChanged(): unknown[];
+    /** Record the session id the UI currently has OPEN (T58) — the raw id as
+     * the UI knows it (a virtual id for a remote session, a local id
+     * otherwise); `undefined` means a READABLE signal says no session is
+     * open. An UNREADABLE signal is expressed by not calling this at all —
+     * the merger then keeps every tombstone (the conservative fallback).
+     * Returns the frames that apply the resulting hide transitions ([] when
+     * nothing changed). */
+    setCurrentSession(sessionId: string | undefined): unknown[];
+    /** Whether some closed-remote session is being kept visible — it is the
+     * current session (waiting for the user to navigate away), or the current
+     * session was never readable (conservative fallback). While true the
+     * caller should keep polling {@link setCurrentSession} at ≥1s intervals. */
+    readonly hasPendingHide: boolean;
+    /** Point the merger at a (possibly different) server. Local state survives;
+     * for a serverId change the remote state must be gone first (onRemoteGone
+     * first); for a rename it may stay. */
+    retarget(identity: MergerIdentity): void;
+}
+/**
+ * The workspace/follow merger. Remote state is a Map keyed by the ORIGINAL
+ * workspace id whose INSERTION ORDER tracks the remote order (baseline sets
+ * it, upsert appends new keys, order frames reorder it) — that sequence is
+ * what gets appended to every local baseline/order that passes through.
+ */
+export declare function createWorkspaceMerger(options: WorkspaceMergerOptions): WorkspaceMerger;
+export interface ControlMergerOptions {
+    serverId: string;
+    serverName?: string;
+    onDiagnostic?: (message: string) => void;
+}
+export interface ControlMerger {
+    readonly serverId: string;
+    readonly serverName: string;
+    /** Local control frames pass through untouched; the local BASELINE also
+     * flushes anything the remote side buffered before it arrived. */
+    onLocal(frame: unknown): unknown[];
+    /** Remote baseline → per-session per-key `projection` frames; remote
+     * projection updates → virtualized. Unknown types are dropped. Frames
+     * arriving before the local baseline are buffered (the host's snapshot
+     * stream treats an update before the opening snapshot as a protocol
+     * violation and kills the stream). */
+    onRemote(frame: unknown): unknown[];
+    /** Always [] — a control stream has nothing to remove on a temporary
+     * remote end (the workspace merger owns the group). */
+    onRemoteDown(): unknown[];
+    /** Always [] — leftover projection state for vanished virtual sessions is
+     * harmless; the workspace merger removes the group. */
+    onRemoteGone(): unknown[];
+    /** Always [] — projection frames carry no display name. */
+    onServerRenamed(): unknown[];
+    /** Accepted and ignored: a status annotation is a TITLE concern, and
+     * control projections carry no titles. */
+    setStatus(annotation: MergerAnnotation): void;
+    /** Always [] — nothing shown here could carry an annotation. */
+    onStatusChanged(): unknown[];
+    /** Accepted and ignored; always answers []. */
+    setCurrentSession(sessionId: string | undefined): unknown[];
+    /** Always false — the control merger hides nothing. */
+    readonly hasPendingHide: boolean;
+    retarget(identity: MergerIdentity): void;
+}
+/**
+ * The session/control merger. The control stream is key-value projection
+ * traffic with no ordering constraints between sessions, so it needs no
+ * state beyond the pre-baseline buffer: local frames pass through, remote
+ * frames get their session id virtualized, and a remote baseline is EXPLODED
+ * into one `projection` frame per key (never a second baseline).
+ */
+export declare function createControlMerger(options: ControlMergerOptions): ControlMerger;
+/**
+ * Merge one `session/list` result pair (first page only — the caller skips
+ * paged requests). Local items keep their order and their pagination fields;
+ * the remote items are appended with virtualized session ids — `sessionId`
+ * AND `parentSessionId` (CP4): the fork link must point at the VIRTUAL parent
+ * id the UI knows, or the fork would sort beside a parent id that exists in
+ * no list the UI holds — and a T52-fix rewrite of the row's own projections
+ * block: a list row carries `{kind:'cached'|'sequenced', asOfSeq, values}`
+ * (RT dsh-api-session-controller lib/typert.remote-client.js:381-428) and the
+ * client face applies it PER SESSION (lib/client.js:2633 → applyListBlock
+ * :2842-2855) — a `sequenced` modelSelection lands under higher-seq-wins
+ * (lib/client.js:986-995, `seq <= row.seq` rejects), and the control stream's
+ * REWRITTEN frame rides that projection's OWN seq, so an original-provider
+ * value left in a row would poison the store forever: the remote session's
+ * dropdown would show the raw `provider/model` fallback with no check mark.
+ * The rewrite is UNCONDITIONAL (T52-fix3): first-write-wins per seq forbids
+ * a catalog gate — a row rewritten while the catalog was missing would
+ * occupy the seq forever. A missing or malformed remote result means "remote
+ * said nothing" — the local result passes back untouched.
+ */
+export declare function mergeSessionList(localResult: unknown, remoteResult: unknown, serverId: string): unknown;
+/**
+ * Fold the relay's `session/modelCatalog` answer into the local one (T52).
+ * The result shape is RT dsh-api-session-controller
+ * `session_modelCatalog_result$schema` (lib/typert.remote-client.js:489-518):
+ * `{default, routableProviders, groups, failures}` — provider group ids and
+ * display names only, no session data anywhere, so no output filter guards it
+ * server-side and nothing here needs narrowing.
+ *
+ * - server groups are APPENDED after the local ones (the dropdown sorts
+ *   `deepseek-account` / `deepseek-official` first and keeps the rest in
+ *   order, RT dsh-client-ui-model-selection lib/client.js:510 — appended
+ *   groups render last); each group id becomes the virtual group id
+ *   `zr~<serverId>~<original>` and its name is prefixed
+ *   `${serverName} · ${name}` — the same workspace title discipline the
+ *   merger uses;
+ * - `default` and `failures` stay LOCAL untouched: the default drives what a
+ *   blank LOCAL session would run (a remote session's current model comes
+ *   from its projection instead), and the UI renders every failure as a
+ *   prominent warning row whose Retry reloads the WHOLE catalog
+ *   (lib/client.js:816-827) — a server-side group failure is not retryable
+ *   from here and would put a permanent alarm on every dropdown, so it does
+ *   not travel (dsh-vision-router's settings read the same result and shows
+ *   an error state exactly when groups are empty AND failures exist,
+ *   lib/client.js:635-647 — dropping remote failures keeps that honest).
+ *   KNOWN BOUNDARY (pre-T52 behavior, unchanged): a NEW server session's
+ *   projection `next` is null until its first selection or turn, so the UI
+ *   shows `catalog.value.default` — the LOCAL default — as that session's
+ *   current model (RT dsh-client-ui-model-selection lib/client.js:316,
+ *   `projected?.next ?? catalog.value?.default`), which may differ from what
+ *   the server would actually run until its first selection lands.
+ * - `routableProviders` mirrors the group ids by construction host-side
+ *   (RT dsh-api-session-controller lib/index.js:544 — literally
+ *   `groups.map(g => g.id)`); no client UI reads it (the dropdown's
+ *   routable verdict comes from the groups themselves, lib/client.js:334),
+ *   so appending the virtual ids is a consistency move: the merged catalog
+ *   keeps the invariant the Host maintains, whatever reads it next.
+ *
+ * A malformed local or remote value means "one side said nothing" — the
+ * local result passes back untouched, like {@link mergeSessionList}.
+ */
+export declare function mergeModelCatalogs(localValue: unknown, remoteValue: unknown, identity: MergerIdentity): unknown;
+/**
+ * Virtualize the provider ids inside one `modelSelection` projection value —
+ * `{lastUsed: {provider, model, reasoningEffort?} | null, next: …}` (RT
+ * dsh-api-session-controller lib/types/model-selection-projection.js:12-15,
+ * wire shapes at lib/typert.remote-client.js:83-94). The UI resolves the
+ * current model's display name by matching `(provider, model)` against the
+ * catalog groups (dsh-client-ui-model-selection lib/client.js:334, 520); for
+ * a remote session the provider is a SERVER group id, so it must become the
+ * virtual group id to be found in the merged catalog — and while the relay
+ * serves, the merged catalog always carries it, so the composer trigger
+ * shows the model NAME instead of the raw `provider/model` fallback string
+ * (lib/client.js:700).
+ *
+ * UNCONDITIONAL by decision (T52-fix3, reverting T52-fix2's catalog gate):
+ * the host's projection store is first-write-wins per sequence number
+ * (lib/client.js:986-994), so whether a value is rewritten may not depend on
+ * WHEN the catalog happened to arrive — an original written pre-catalog
+ * occupies the seq and the later virtual value is dropped, leaving the
+ * server group unchecked and the next reasoning-effort submit refused.
+ * Accepted cost: a provider the server's own catalog does not list renders
+ * the `zr~<serverId>~provider/model` fallback string. Nulls and malformed
+ * entries pass through untouched; `model` and `reasoningEffort` are
+ * group-agnostic ids and stay as they are.
+ */
+export declare function virtualizeModelSelectionValue(value: unknown, serverId: string): unknown;
+/**
+ * T63: the virtual session ids a set of FORWARDED workspace frames carries —
+ * the `sessionIds` of `upsert` records and of baseline `value.items`. The
+ * workspace route feeds these to the summary sync, which announces list rows
+ * for ids the UI has no summary for yet (the sidebar drops a group member
+ * without one — RT dsh-client-ui-workspace orderByRecency / groupByWorkspace).
+ * Reading the FORWARDED output (not the merger's raw state) is the point:
+ * T56 already withheld empty groups and T58 already dropped hidden sessions,
+ * so a hidden closed-remote session never reaches here and is never
+ * announced. Only virtual ids count — local baseline content rides these
+ * frames verbatim and its rows already have summaries.
+ */
+export declare function virtualSessionIdsInWorkspaceFrames(frames: readonly unknown[]): string[];
+/**
+ * T63: the synthesized `api-session/added` emit frames for one relay
+ * `session/list` answer — one `{type:'emit', event:'api-session/added',
+ * args:[row]}` frame per row. This is the host's own mechanism for adding a
+ * list row without a re-pull (RT dsh-api-session-controller: the client face
+ * subscribes `api-session/added` → handleSessionAdded → mergeSummary →
+ * applyMutation's upsert, which ADDS an unknown row and fills an existing
+ * one — idempotent), and the emit frame shape is the client face's
+ * exact-keys `{type, event, args}` with args a JSON array
+ * (dsh-api-gateway lib/client.js parseRemoteEventFrame) — the same shape the
+ * T52 catalog-refresh frame uses. The rows are virtualized by
+ * {@link mergeSessionList} itself, so a synthesized row carries exactly what
+ * the merged `session/list` route would have answered: the session id AND
+ * the fork parent virtualized, and the projections' modelSelection providers
+ * rewritten (a row's `sequenced` block must not poison the projection store
+ * against the control stream's rewritten frames — T52-fix3). A malformed
+ * remote result means "the server said nothing" — no frames.
+ */
+export declare function sessionSummaryAddedFrames(remoteResult: unknown, serverId: string): unknown[];
+//# sourceMappingURL=merge-streams.d.ts.map

package/lib/types/merge-streams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-streams.d.ts","sourceRoot":"","sources":["../../src/merge-streams.ts"],"names":[],"mappings":"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"}