dsh-ssh-tui 0.5.7 → 0.5.9

package/lib/types/display-sock.d.ts

@@ -12,7 +12,40 @@ export declare const FRAME_RTT = 6;
 export declare function detachFromSshSession(): void;
 export declare const TUI_HOST_ENV = "DSH_TUI_HOST";
 export declare function isTuiHostProcess(env?: NodeJS.ProcessEnv): boolean;
-export declare function sessionSockPath(sessionId: string, dshHome?: string): string;
+/**
+ * Windows named-pipe namespace. Node's `net` passes the string straight to
+ * CreateNamedPipeW/CreateFileW, and those require this prefix — a drive-letter
+ * path fails with ENOENT/EACCES and the Host never listens.
+ */
+export declare const WINDOWS_PIPE_PREFIX = "\\\\.\\pipe\\";
+/** True for a Windows named-pipe address (`\\.\pipe\x`, `\\?\pipe\x`, `//./pipe/x`). */
+export declare function isPipePath(path: string): boolean;
+/**
+ * `DSH_HOME` the way dsh itself resolves it: a blank value counts as unset, and
+ * the result is absolute. Both matter here because the launcher and the
+ * detached Host compute channel names independently and the Host chdirs into
+ * the session's working directory first — a relative or empty home would give
+ * them two different sockets (or pipe names) and time the launch out.
+ */
+export declare function resolveDshHome(env?: NodeJS.ProcessEnv, home?: string): string;
+/** Directory holding per-session display runtime state (error logs). */
+export declare function sessionSockDir(dshHome?: string): string;
+/** Filesystem/pipe-safe form of a session id, as used for locks and channels. */
+export declare function safeSessionId(sessionId: string): string;
+/**
+ * Address of the per-session display channel: a filesystem path on POSIX, a
+ * named pipe on Windows. `platform` is injectable so the Windows shape stays
+ * testable from a POSIX test run.
+ */
+export declare function sessionSockPath(sessionId: string, dshHome?: string, platform?: NodeJS.Platform): string;
+/**
+ * Host stderr log for one session. POSIX keeps the historical `<sock>.err`
+ * next to the socket; a Windows pipe name is not a file path, so the log lives
+ * in the `tui-socks` state directory instead — under the same digested label,
+ * which also keeps long ids inside the Windows path limit and keeps reserved
+ * device names (`CON`, `NUL`, …) from becoming the file stem.
+ */
+export declare function sessionErrPath(sessionId: string, dshHome?: string, platform?: NodeJS.Platform): string;
 export declare function encodeFrame(type: number, payload?: Buffer): Buffer;
 export declare function encodeResize(columns: number, rows: number): Buffer;
 export declare function decodeResize(payload: Buffer): {
@@ -56,14 +89,38 @@ export declare class DisplayHost {
     sendGoodbye(): void;
     close(): Promise<void>;
 }
-export declare function waitForDisplaySock(path: string, timeoutMs?: number, pid?: number, errFile?: string): Promise<void>;
+/**
+ * True once a Host is actually accepting on the display channel.
+ *
+ * Always a real connect, never a filesystem check: a leftover `.sock` file
+ * (killed Host, or one that is mid-dispose) is a directory entry, not a peer,
+ * and `fs.access()` used to report it as ready — the launcher then wrote HELLO
+ * into a dead socket and the first reconnect after a drop died with
+ * `write EPIPE`. Windows pipes additionally cannot be seen by `fs.access` at
+ * all. The Host treats a connect without HELLO as a liveness probe and drops
+ * it without stealing the display.
+ */
+export declare function displaySockExists(path: string, timeoutMs?: number): Promise<boolean>;
+/** Watches a freshly spawned Host so a crash is reported immediately. */
+export interface HostExitWatch {
+    /** Resolves with the exit code (or null when killed) once the Host exits. */
+    readonly exited: Promise<number | null>;
+    /** Stop watching; call once the channel is confirmed up. */
+    dispose(): void;
+}
+export declare function waitForDisplaySock(path: string, timeoutMs?: number, pid?: number, errFile?: string, exitWatch?: HostExitWatch): Promise<void>;
 export declare function hostArgvForSession(sessionId: string, argv?: string[], execArgv?: string[]): string[];
-/** Spawn a detached Host copy of this `dsh` invocation and return its sock path. */
-export declare function spawnDetachedHost(sessionId: string): {
+export interface SpawnedHost {
     pid: number;
+    /** Channel address: a socket file on POSIX, a named pipe on Windows. */
     sock: string;
+    /** Host stderr log; present when it could be opened. */
     errFile?: string;
-};
+    /** Exit watch so a Host that dies before listening is reported at once. */
+    exitWatch: HostExitWatch;
+}
+/** Spawn a detached Host copy of this `dsh` invocation and return its sock path. */
+export declare function spawnDetachedHost(sessionId: string): SpawnedHost;
 export declare function probeDisplaySock(path: string, timeoutMs?: number): Promise<boolean>;
 export interface RelayResult {
     /** Host sent goodbye — user exited from the attached session. */

package/lib/types/dsh-compat.d.ts

@@ -37,6 +37,18 @@ export declare function sessionEvents(session: object): readonly SessionEvent[];
  * not materialize a second array of every chunk.
  */
 export declare function forEachSessionEvent(session: object, visit: (event: SessionEvent) => void): void;
+/** Events folded between event-loop turns while a long log is replayed. */
+export declare const REPLAY_YIELD_EVERY = 200;
+/**
+ * {@link forEachSessionEvent} for the resume replay. A synchronous walk of a
+ * large log blocks the loop for its whole duration, which freezes the TUI on
+ * the pre-replay frame: the relay's RTT frame and the render timer cannot run,
+ * so the footer keeps painting `SSH ○○○○` and the transcript never fills in
+ * until the walk ends. Yielding every few hundred events keeps both flowing.
+ *
+ * @param halt - stop early when the TUI was disposed mid-replay.
+ */
+export declare function forEachSessionEventAsync(session: object, visit: (event: SessionEvent) => void, yieldEvery?: number, halt?: () => boolean): Promise<void>;
 /** Header fields the picker and resume path actually read. */
 export interface SessionHeaderLike {
     id: string;
@@ -76,17 +88,63 @@ export declare function commandAcceptsAttachments(input: unknown): boolean;
 export interface StreamChunkLike {
     type: string;
     text?: string;
+    /** `tool-call-delta` argument fragment. */
+    argumentsDelta?: string;
+    /** `tool-call-delta` tool name, present on the first fragment. */
+    name?: string;
     usage?: {
         inputTokens?: number;
         outputTokens?: number;
     };
 }
-/** Durable `assistant/chunk` payload, or a live stream frame's inner chunk. */
-export declare function streamChunkOf(eventOrFrame: unknown): {
+/**
+ * Whether one chunk carries the model's first output token, matching the host's
+ * own `isTokenDelta`: a non-empty text/reasoning fragment, or a tool-call
+ * fragment (name-bearing deltas included). Thinking-first models therefore
+ * start the latency clock on their first reasoning token, not on the first
+ * visible answer token.
+ */
+export declare function isTokenDeltaChunk(chunk: unknown): boolean;
+/**
+ * Turn/step of a live `agent/assistant-stream` `start` frame. The chunk frames
+ * this opens carry no turn/step at all, so callers must remember them or every
+ * live chunk is attributed to step 0 (which silently disabled TTFT, decode
+ * speed, and usage de-duplication).
+ */
+export declare function streamFrameOwner(frame: unknown): {
+    attemptId: unknown;
+    turn: number;
+    step: number;
+} | undefined;
+/** Attempt id of a live chunk/end frame, used to match it to its `start`. */
+export declare function streamFrameAttemptId(frame: unknown): unknown;
+/**
+ * First token time inside a durable compact assistant stream
+ * (`assistant/message.stream`). Mirrors the host's
+ * `assistantStreamFirstTokenTime`: packed delta runs place member `i` at
+ * `time0 + dt[0..i-1]`, raw chunk records carry their own time.
+ */
+export declare function streamFirstTokenTime(stream: unknown): number | undefined;
+/**
+ * Durable `assistant/chunk` payload, or a live stream frame's inner chunk.
+ *
+ * `fallback` supplies the turn/step for live chunk frames, which do not carry
+ * them (see {@link streamFrameOwner}).
+ */
+export declare function streamChunkOf(eventOrFrame: unknown, fallback?: {
+    turn: number;
+    step: number;
+}): {
     chunk: StreamChunkLike;
     turn: number;
     step: number;
     time: number;
+    /**
+     * False when neither the source nor a fallback carried a real turn/step.
+     * Usage folded under such a chunk would be filed under a bogus key (0:0)
+     * that `step/end` never clears, inflating the session totals forever.
+     */
+    stepKnown: boolean;
 } | undefined;
 /** Durable event type as a plain string so 0.1.5 hosts can omit `assistant/chunk`. */
 export declare function sessionEventType(event: unknown): string;

package/lib/types/footer.d.ts

@@ -94,7 +94,10 @@ export interface FooterStatusInput {
     provider: string;
     parentModel: string;
     subModel: string;
-    subDiffers: boolean;
+    /** Explicit `/submodel` provider override; undefined means "inherit parent". */
+    subProvider?: string;
+    /** Explicit `/subeffort` override for subagent children. */
+    subEffort?: string;
     quotaCode?: string;
     quotaPercent?: number;
     contextChip?: string;
@@ -115,6 +118,13 @@ export declare function footerActivity(input: FooterStatusInput): {
 };
 /** Short remaining-quota bar: 8 pips, filled from the left. */
 export declare function formatQuotaBar(remainingPercent: number, width?: number): string;
+/**
+ * `sub:<model>` chip for the identity row, mirroring the pre-0.3.6 footer:
+ * an explicit `/submodel` provider is prefixed (`sub:xai/grok-4.5`) and an
+ * explicit `/subeffort` is appended in parentheses (`sub:grok-4.5(xhigh)`).
+ * An inherited provider stays implicit — it is the parent's route.
+ */
+export declare function subagentRouteLabel(model: string, provider?: string, effort?: string): string;
 export declare function footerIdentityParts(input: FooterStatusInput): string[];
 /** `SuperGrok ███████░ 82%`, or just the bar + percent when `code` is omitted. */
 export declare function formatFooterQuota(percent: number, code?: string): string;

package/lib/types/index.d.ts

@@ -5,6 +5,10 @@
  * subagents, sandbox approvals) is the same one the web surface uses.
  */
 import type { Context } from '@deepseek-ai/cordis';
+/** A relay that dies this soon after connecting reached a Host that was leaving. */
+export declare const ATTACH_RECOVERY_WINDOW_MS = 5000;
+/** True when a relay error means the peer vanished rather than a real fault. */
+export declare function attachPeerVanished(error: unknown, elapsedMs: number): boolean;
 export declare const name = "ssh-tui";
 /** Core services required before the terminal channel can drive an agent. */
 export declare const inject: string[];

package/lib/types/paint.d.ts

@@ -68,6 +68,19 @@ export declare function parseCursorPositionReply(text: string): {
     row: number;
     column: number;
 } | undefined;
+/**
+ * Find a cursor reply inside a noisy buffer.
+ *
+ * The anchored parse above only works when the CPR is the whole chunk. Real
+ * terminals interleave it with focus events, mouse reports, bracketed-paste
+ * marks or keystrokes that raced the probe, and an anchored match then fails
+ * until the probe times out — which is how the footer's link chip ends up
+ * stuck on four hollow circles (`SSH ○○○○`) for a whole session.
+ */
+export declare function findCursorPositionReply(text: string): {
+    row: number;
+    column: number;
+} | undefined;
 /**
  * Round-trip to the attached terminal via CSI 6n. Returns undefined when the
  * reply never arrives (dumb pipe, blocked DSR). Does not interpret the

package/lib/types/picker.d.ts

@@ -8,7 +8,7 @@
  * typing filters by title / id / cwd, and Enter confirms the focused row.
  */
 import type { Context } from '@deepseek-ai/cordis';
-import { type ResumableSession } from './session-list.js';
+import { listResumableSessionsProgressive, type ResumableSession } from './session-list.js';
 /** What the launch picker decided. */
 export type SessionPickerResult = {
     kind: 'resume';
@@ -119,4 +119,10 @@ export declare function feedPicker(state: SessionPickerState, text: string, wind
  * @param signal - optional abort signal (fiber dispose) to cancel the picker.
  * @returns the selection, or null when cancelled.
  */
-export declare function showSessionPicker(ctx: Context, color: boolean, signal?: AbortSignal): Promise<SessionPickerResult>;
+/** Injection seams for tests; production uses the TTY and the session index. */
+export interface SessionPickerOptions {
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+    listSessions?: typeof listResumableSessionsProgressive;
+}
+export declare function showSessionPicker(ctx: Context, color: boolean, signal?: AbortSignal, options?: SessionPickerOptions): Promise<SessionPickerResult>;

package/lib/types/session-lock.d.ts

@@ -24,6 +24,38 @@ export declare function sessionLockPath(sessionId: string, dshHome?: string): st
 export declare function parseSessionLock(raw: string): SessionLockInfo | undefined;
 /** True when `pid` still exists on this machine (best-effort). */
 export declare function processIsAlive(pid: number): boolean;
+/** Slice of a Windows process identity needed to rule out pid reuse. */
+export interface WindowsProcessIdentity {
+    /** Executable name without `.exe`, lowercased (`node`). */
+    name: string;
+    /** Process creation time in epoch milliseconds, when readable. */
+    startedAt?: number;
+}
+/** Clock/resolution slack when comparing a creation time with the lock write. */
+export declare const PID_REUSE_SLACK_MS = 5000;
+/**
+ * Parse the probe's stdout. Everything after the last non-empty line is
+ * ignored (a stray warning banner must not masquerade as the image name), and
+ * an unexpected shape is reported as "unverifiable" rather than as a
+ * mismatch: mistaking noise for a foreign process would steal a live lock.
+ */
+export declare function parseWindowsProcessIdentity(stdout: string): WindowsProcessIdentity | undefined;
+/** Image name this Host runs as (`node` / `dsh`), without `.exe`. */
+export declare function hostImageName(execPath?: string): string;
+/**
+ * Decide whether a live Windows pid can still be the lock's Host.
+ *
+ * Windows recycles pids aggressively, and without procfs an unrelated process
+ * inheriting the recorded pid used to look like a permanent live-but-silent
+ * Host ("zombie"), which blocked `--resume` until the lock was deleted by
+ * hand. Two facts rule reuse out:
+ *  - the Host always runs this same executable, so a different image name is
+ *    someone else's process;
+ *  - the Host existed before it wrote the lock, so a process created after the
+ *    lock was written cannot be its owner.
+ * An unverifiable process keeps the legacy best-effort answer (alive).
+ */
+export declare function windowsProcessMatchesLock(lock: SessionLockInfo, identity: WindowsProcessIdentity | undefined, expectedName?: string, slackMs?: number): boolean;
 /**
  * True when `pid` is genuinely the Host process that wrote `lock`.
  *
@@ -38,10 +70,17 @@ export declare function processIsAlive(pid: number): boolean;
  *    boot, so a recycled or cross-namespace pid fails the check;
  *  - older locks fall back to `/proc/<pid>/cmdline`: the detached Host is
  *    always launched with `--resume=<sessionId>` in argv, so any other
- *    process (kernel threads have an empty cmdline) is proven stale.
- * On platforms without procfs the legacy kill(pid, 0) behavior is kept.
+ *    process (kernel threads have an empty cmdline) is proven stale;
+ *  - Windows has neither: a `Get-Process` probe supplies the image name and
+ *    creation time instead (see {@link windowsProcessMatchesLock}).
+ * On platforms where none of this is available the legacy kill(pid, 0)
+ * behavior is kept.
+ *
+ * Async because the Windows probe spawns PowerShell, and this runs on the
+ * render path (`/resume` inspects every lock); a synchronous spawn would
+ * freeze painting and keystrokes for the duration of the probe.
  */
-export declare function lockOwnerIsAlive(lock: SessionLockInfo): boolean;
+export declare function lockOwnerIsAlive(lock: SessionLockInfo): Promise<boolean>;
 export declare function formatLockHeldMessage(lock: SessionLockInfo): string;
 export declare function sessionLockDisabled(env?: NodeJS.ProcessEnv): boolean;
 export declare function readSessionLock(sessionId: string, dshHome?: string): Promise<{

package/lib/types/tui.d.ts

@@ -27,10 +27,10 @@ import type { CollapsibleBlock, DisconnectPolicyName } from './transcript-types.
 import { paintedLinkHits } from './term-text.js';
 export type { CollapsibleBlock, DisplayKind, DisconnectPolicyName, PlanTodoItem, Row, SubagentLogEntry, ToolDiffHunk, } from './transcript-types.js';
 export { clipAnsiToWidth, cursorVisualPosition, displayWidth, foldInputView, hrefAtColumn, osc52Clipboard, osc8Enabled, paintedLinkHits, fmtElapsedCompact, padAnsiToWidth, padToWidth, renderMarkdownLines, repeatToWidth, shimmerText, truncateToWidth, visibleWidth, waitCardCopy, waitSummaryFromReasoning, wrapWaitDetails, } from './term-text.js';
-export { captureHangupSignals, composePaintOutput, detectSshSession, formatLinkQualityChip, ignoreFurtherHangupSignals, isEscapePrefix, isHangupErrno, linkQualityOf, linkSignalPips, paintIntervalForRtt, paintLinkLabel, parseCursorPositionReply, pickerWindowStart, probeTerminalRttMs, releaseHangupSignals, resolvePaintIntervalMs, waitUntilIdleOrTimeout, writeBootSplash, type LinkQuality, type PaintLinkKind, } from './paint.js';
-export { CONTEXT_IDLE_COMPACT_RATIO, CONTEXT_PRESSURE_DANGER_RATIO, CONTEXT_PRESSURE_WARN_RATIO, CONTEXT_RING_EMPTY, CONTEXT_RING_SEGMENTS, contextPressureAlertText, contextPressureRingColor, contextPressureUsedTokens, contextPressureView, describeProviderRoute, dropFooterQuotaPlanName, fitFooterStatsLine, fitFooterStatusLine, footerActivity, footerIdentityParts, footerStatsGroups, formatContextPressureChip, formatContextPressureRing, formatContextPressureStatusLine, formatDuration, formatFooterQuota, formatQuotaBar, formatStatusReport, formatTokens, formatTokensPerSecond, parseContextPressure, promptPressureTokens, providerShortCode, providerUsesLocalOAuth, shouldIdleAutoCompact, type ContextPressureSample, type ContextPressureView, type FooterActivityKind, type FooterStatsInput, type FooterStatusInput, type StatusReportInput, } from './footer.js';
+export { captureHangupSignals, composePaintOutput, detectSshSession, formatLinkQualityChip, ignoreFurtherHangupSignals, isEscapePrefix, findCursorPositionReply, isHangupErrno, linkQualityOf, linkSignalPips, paintIntervalForRtt, paintLinkLabel, parseCursorPositionReply, pickerWindowStart, probeTerminalRttMs, releaseHangupSignals, resolvePaintIntervalMs, waitUntilIdleOrTimeout, writeBootSplash, type LinkQuality, type PaintLinkKind, } from './paint.js';
+export { CONTEXT_IDLE_COMPACT_RATIO, CONTEXT_PRESSURE_DANGER_RATIO, CONTEXT_PRESSURE_WARN_RATIO, CONTEXT_RING_EMPTY, CONTEXT_RING_SEGMENTS, contextPressureAlertText, contextPressureRingColor, contextPressureUsedTokens, contextPressureView, describeProviderRoute, dropFooterQuotaPlanName, fitFooterStatsLine, fitFooterStatusLine, footerActivity, footerIdentityParts, footerStatsGroups, formatContextPressureChip, formatContextPressureRing, formatContextPressureStatusLine, formatDuration, formatFooterQuota, formatQuotaBar, formatStatusReport, formatTokens, formatTokensPerSecond, parseContextPressure, promptPressureTokens, providerShortCode, providerUsesLocalOAuth, shouldIdleAutoCompact, subagentRouteLabel, type ContextPressureSample, type ContextPressureView, type FooterActivityKind, type FooterStatsInput, type FooterStatusInput, type StatusReportInput, } from './footer.js';
 export { crossedQuotaThresholds, formatAccountBalance, formatFooterBalance, formatOpenCodeGoUsage, formatQuotaSnapshot, formatQuotaStatusLine, joinUrl, openCodeSourceFor, parseDeepSeekBalance, parseOpenAiCompatibleBalance, parseOpenCodeGoQuota, parseSuperGrokBilling, quotaAlertText, quotaRefreshEverySteps, quotaRefreshEveryTurns, remainingPercentFromUsed, tightestQuotaWindow, type AccountBalanceLine, type AccountBalanceSnapshot, type OpenCodeFlavor, type OpenCodeSource, type QuotaPeriod, type QuotaSnapshot, type QuotaWindow, } from './quota.js';
-export { commandAcceptsAttachments, forEachSessionEvent, isAssistantStreamEvent, listPersistenceHeaders, inspectPersistenceSession, sessionEventType, sessionEvents, settingsNamespace, streamChunkOf, } from './dsh-compat.js';
+export { commandAcceptsAttachments, forEachSessionEvent, isAssistantStreamEvent, isTokenDeltaChunk, listPersistenceHeaders, inspectPersistenceSession, sessionEventType, sessionEvents, settingsNamespace, streamChunkOf, streamFirstTokenTime, streamFrameAttemptId, streamFrameOwner, } from './dsh-compat.js';
 export { applyTurnEndToPlan, askSummary, cardCategoryOf, compactionHeaderText, formatCompactCommandError, isPromptInjectionMessage, matchTranscriptRows, parseFindQuery, parsePlanTodos, planCloseNudgeText, planDockNote, planIsLive, planTitleFromMarkdown, planTurnLeftOpen, promptInjectionSources, promptInjectionTitle, subagentHeaderText, todoProgressLabel, todoSummary, type CardCategory, } from './plan.js';
 export { buildToolHeader, canMergeToolCall, compactEditPath, compactToolBursts, compactToolGroups, countDiffAddDel, countDiffLines, countOutputLines, diffMetaDiffs, diffStatToken, friendlyJsonLines, parseExitStatus, presentToolCall, READ_TOOL_NAMES, renderToolDiff, toolBodyFitsWorkspace, toolBodyLines, toolStateColor, toolStateLabel, wrappedToolBodyLineCount, } from './tool-present.js';
 /** Presentation configuration for the terminal channel. */
@@ -181,6 +181,12 @@ export declare class SshTui {
     private toolCallNames;
     private readonly stats;
     private openStepStats;
+    /** Attempt whose live `start` frame opened the current token stream. */
+    private liveStreamOwner;
+    /** Live events parked while the (yielding) history replay holds the floor. */
+    private replayQueue;
+    /** A relay claimed the display while a hangup was still cancelling/flushing. */
+    private reattachedDuringHangup;
     private readonly pendingToolTimes;
     private readonly usageByStep;
     private lastStatsTurn;
@@ -257,8 +263,13 @@ export declare class SshTui {
     private paintCompactSummary;
     private startRenderTimer;
     private calibratePaintInterval;
-    /** Replay the durable session log so a resumed session renders its history. */
-    replayHistory(): void;
+    /**
+     * Replay the durable session log so a resumed session renders its history.
+     * Chunked on purpose: a synchronous walk of a long log froze the TUI on the
+     * pre-replay frame, so the relay's RTT frame could not be applied and the
+     * footer sat on `SSH ○○○○` for the whole load.
+     */
+    replayHistory(): Promise<void>;
     /** Show the first-launch provider/API-key onboarding when nothing is configured. */
     private maybeRunOnboarding;
     /** Run the provider/API-key onboarding wizard. Resolves true when saved. */
@@ -409,6 +420,7 @@ export declare class SshTui {
     readonly handleSessionEvent: (session: {
         id: SessionId;
     }, event: SessionEvent) => void;
+    private applySessionEvent;
     private readonly handleStatus;
     private readonly handleError;
     private readonly handleInboxClaimed;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ssh-tui",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "SSH-friendly interactive terminal TUI plugin for DeepSeek Harness",
   "keywords": [
     "deepseek-harness",
@@ -72,8 +72,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "npm run build && node --test tests/*.test.mjs",
-    "clean": "rm -rf lib",
+    "test": "npm run build && node --test \"tests/*.test.mjs\"",
+    "clean": "node -e \"require('node:fs').rmSync('lib', { recursive: true, force: true })\"",
     "prepare": "npm run build",
     "prepack": "npm run build",
     "prepublishOnly": "npm run typecheck",