@dsh-workbench/shared 0.3.5 → 0.3.7

package/dist/host/long-task.js

@@ -3,11 +3,18 @@ const LIVE = new Set(['running', 'needs-login']);
 const RECENT_MS = 10 * 60 * 1000;
 export function createLongTaskRegistry(deps) {
     const runs = new Map();
+    const controls = new Map();
     const now = deps.now ?? (() => new Date().toISOString());
     let counter = 0;
     const nextId = deps.nextId ?? (() => `run-${Date.now()}-${(counter += 1)}`);
     const recentMs = deps.recentMs ?? RECENT_MS;
     const listeners = new Set();
+    const live = (id) => {
+        const current = runs.get(id);
+        if (current === undefined || !LIVE.has(current.status))
+            return null;
+        return current;
+    };
     const notify = (change) => {
         for (const listener of [...listeners]) {
             try {
@@ -46,7 +53,10 @@ export function createLongTaskRegistry(deps) {
             return [...newest.values()]
                 .filter((snapshot) => LIVE.has(snapshot.status) || Date.parse(snapshot.at) >= floor)
                 .reverse()
-                .map((snapshot) => deps.view(snapshot));
+                .map((snapshot) => ({ ...deps.view(snapshot), id: snapshot.id }));
+        },
+        live() {
+            return [...runs.values()].filter((snapshot) => LIVE.has(snapshot.status));
         },
         start(options) {
             const running = this.active(options.workspace, options.target);
@@ -63,11 +73,12 @@ export function createLongTaskRegistry(deps) {
                 steps: [],
                 startedAt,
                 at: startedAt,
+                ...(options.session === undefined ? {} : { session: options.session }),
             });
             notify({ kind: 'start', snapshot: runs.get(id) });
             const onStep = (step) => {
-                const current = runs.get(id);
-                if (current === undefined)
+                const current = live(id);
+                if (current === null)
                     return;
                 const steps = [...current.steps, `${step.kind === 'fail' ? '✗ ' : ''}${step.text}`].slice(-20);
                 const extra = deps.step?.(step, current) ?? {};
@@ -83,13 +94,21 @@ export function createLongTaskRegistry(deps) {
                     ...(current.status === 'needs-login' ? { loginUrl: undefined } : {}),
                 }, { kind: 'step', step });
             };
+            const control = new AbortController();
+            controls.set(id, control);
             void deps
-                .run({ payload: options.payload, onStep })
+                .run({ payload: options.payload, onStep, signal: control.signal })
                 .then((result) => {
-                const current = runs.get(id);
+                const current = live(id);
+                if (current === null)
+                    return;
+                controls.delete(id);
                 patch(id, { status: 'ok', ...(deps.outcome?.(result, current) ?? {}), loginUrl: undefined }, { kind: 'settle' });
             })
                 .catch((error) => {
+                if (live(id) === null)
+                    return;
+                controls.delete(id);
                 patch(id, {
                     status: 'failed',
                     why: error instanceof Error ? error.message : String(error),
@@ -98,6 +117,15 @@ export function createLongTaskRegistry(deps) {
             });
             return runs.get(id);
         },
+        stop(id, by) {
+            const current = live(id);
+            if (current === null)
+                return false;
+            controls.get(id)?.abort();
+            controls.delete(id);
+            patch(id, { ...(deps.stopped?.(current) ?? {}), status: 'stopped', loginUrl: undefined }, { kind: 'settle', by });
+            return true;
+        },
         snapshot(id) {
             return runs.get(id) ?? null;
         },
@@ -136,6 +164,7 @@ export function createLongTaskHost(options) {
                 offs.push(registry.onChange((change) => {
                     const named = [runsRouteOf(options.unit), ...(facts?.(change) ?? [])];
                     options.bump([...new Set(named)]);
+                    options.notify?.(change);
                 }));
                 return registry;
             },

package/dist/host/mount-units.d.ts

@@ -0,0 +1,52 @@
+import type { DshHostContext } from '@dsh-workbench/shared';
+import type { UnitManifest } from '@dsh-workbench/shared';
+import { type RouteTable } from './http';
+import type { ContextRenderer, UnitHostFace, UnitMountDeps, UnitMountResult, UnitCall } from './unit-face';
+import { type UnitReadiness } from './unit-readiness';
+export interface MountedUnit {
+    readonly face: UnitHostFace;
+    readonly result: UnitMountResult;
+    readonly readiness: UnitReadiness;
+}
+export interface UnitsPlan {
+    readonly mounted: readonly MountedUnit[];
+    readonly routes: RouteTable;
+    readonly gate: UnitMountResult['gate'];
+    readonly prefs: ReadonlyArray<{
+        readonly resource: string;
+        readonly unit: string;
+        handle(payload: unknown): unknown;
+    }>;
+    readonly actions: ReadonlyArray<{
+        readonly resource: string;
+        readonly unit: string;
+        handle(payload: unknown): unknown;
+    }>;
+    readonly provision: UnitMountResult['provision'];
+    readonly contextRenderers: ReadonlyMap<string, ContextRenderer>;
+    readonly owners: ReadonlyMap<string, string>;
+    readonly routesOfUnit: ReadonlyMap<string, readonly string[]>;
+    readonly factsOf: ReadonlyMap<string, (call: UnitCall) => readonly string[] | undefined>;
+    readonly skipped: ReadonlyArray<{
+        readonly id: string;
+        readonly missing: readonly string[];
+    }>;
+    readonly warmReads: () => readonly (readonly string[])[];
+    readonly disposeLongTasks: () => void;
+}
+export declare function mountUnits(faces: readonly UnitHostFace[], deps: {
+    ctx: DshHostContext;
+    logger?: {
+        info?(m: string): void;
+        warn?(m: string): void;
+    } | undefined;
+    manifests: () => readonly UnitManifest[];
+    opencliCommand?: string;
+    probe?: UnitMountDeps['probe'];
+    store?: UnitMountDeps['store'];
+    values?: UnitMountDeps['values'];
+    longTasks?: {
+        readonly scope: string;
+        readonly bump: (facts: readonly string[]) => void;
+    } | undefined;
+}): UnitsPlan;

package/dist/host/mount-units.js

@@ -0,0 +1,186 @@
+import { runsRouteOf } from '@dsh-workbench/shared';
+import { param } from './http';
+import { createLongTaskHost } from './long-task';
+import { unitReadiness } from './unit-readiness';
+import { createWorkspaceStore } from './workspace-store';
+function withRunsRoute(result, unit) {
+    const runs = result.longTasks;
+    if (runs === undefined)
+        return result;
+    return {
+        ...result,
+        routes: {
+            ...result.routes,
+            [runsRouteOf(unit)]: (search) => {
+                const path = (param(search, 'path') ?? '').trim();
+                return { ok: true, runs: path === '' ? [] : runs.current(path) };
+            },
+        },
+    };
+}
+function collectRoutes(mounted) {
+    const routes = {};
+    const owner = new Map();
+    const routesOfUnit = new Map();
+    for (const item of mounted) {
+        const unit = item.face.manifest.id;
+        for (const [key, handler] of Object.entries(item.result.routes)) {
+            if (key !== unit && !key.startsWith(`${unit}/`)) {
+                throw new Error(`路由名要住在自己那一格的命名空间里（${unit} 或 ${unit}/…）：${key} 不属于 ${unit} —— ` +
+                    `装 / 升 / 卸时点名不到它，那个模块的数据会停在旧值`);
+            }
+            const previous = owner.get(key);
+            if (previous !== undefined) {
+                throw new Error(`路由名冲突：${key} 由套件 ${previous} 与 ${unit} 同时声明`);
+            }
+            owner.set(key, unit);
+            routes[key] = handler;
+            const own = routesOfUnit.get(unit);
+            if (own === undefined)
+                routesOfUnit.set(unit, [key]);
+            else
+                own.push(key);
+        }
+    }
+    return { routes, owners: owner, routesOfUnit };
+}
+function pickGate(mounted) {
+    const providers = mounted.filter((item) => item.result.gate !== undefined);
+    if (providers.length > 1) {
+        throw new Error(`启停闸门只能有一个提供者，现在是：${providers.map((item) => item.face.manifest.id).join('、')}`);
+    }
+    return providers[0]?.result.gate;
+}
+function pickProvision(mounted) {
+    const providers = mounted.filter((item) => item.result.provision !== undefined);
+    if (providers.length > 1) {
+        throw new Error(`机器供给只能有一个提供者，现在是：${providers.map((item) => item.face.manifest.id).join('、')}`);
+    }
+    return providers[0]?.result.provision;
+}
+function collectPrefs(mounted) {
+    const owner = new Map();
+    const prefs = [];
+    for (const item of mounted) {
+        const entry = item.result.prefs;
+        if (entry === undefined)
+            continue;
+        const previous = owner.get(entry.resource);
+        if (previous !== undefined) {
+            throw new Error(`偏好资源名冲突：${entry.resource} 由套件 ${previous} 与 ${item.face.manifest.id} 同时声明`);
+        }
+        owner.set(entry.resource, item.face.manifest.id);
+        prefs.push({ ...entry, unit: item.face.manifest.id });
+    }
+    return prefs;
+}
+function collectActions(mounted) {
+    const owner = new Map();
+    const actions = [];
+    for (const item of mounted) {
+        for (const entry of item.result.actions ?? []) {
+            const previous = owner.get(entry.resource);
+            if (previous !== undefined) {
+                throw new Error(`动作资源名冲突：${entry.resource} 由套件 ${previous} 与 ${item.face.manifest.id} 同时声明`);
+            }
+            owner.set(entry.resource, item.face.manifest.id);
+            actions.push({ ...entry, unit: item.face.manifest.id });
+        }
+    }
+    return actions;
+}
+function collectWarmReads(mounted) {
+    const declarations = mounted
+        .map((item) => item.result.warmReads)
+        .filter((declare) => declare !== undefined);
+    return () => {
+        const seen = new Set();
+        const reads = [];
+        for (const read of declarations.flatMap((declare) => declare())) {
+            const key = read.join(' ');
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            reads.push(read);
+        }
+        return reads;
+    };
+}
+function collectContextRenderers(mounted) {
+    const table = new Map();
+    const owner = new Map();
+    for (const item of mounted) {
+        const context = item.result.context;
+        if (context === undefined)
+            continue;
+        for (const kind of context.kinds) {
+            const previous = owner.get(kind);
+            if (previous !== undefined) {
+                throw new Error(`对话引用的 kind 冲突：${kind} 由套件 ${previous} 与 ${item.face.manifest.id} 同时认领`);
+            }
+            owner.set(kind, item.face.manifest.id);
+            table.set(kind, (ref) => context.render(ref));
+        }
+    }
+    return table;
+}
+export function mountUnits(faces, deps) {
+    const store = deps.store ?? createWorkspaceStore({ root: null });
+    const mounted = [];
+    const skipped = [];
+    const longTaskDisposers = [];
+    for (const face of faces) {
+        const readiness = unitReadiness(face.manifest, (dep) => deps.ctx.get(dep));
+        if (!readiness.canMount) {
+            skipped.push({ id: face.manifest.id, missing: readiness.missingHard });
+            continue;
+        }
+        const unit = face.manifest.id;
+        const longTasks = deps.longTasks === undefined
+            ? undefined
+            : createLongTaskHost({ scope: deps.longTasks.scope, unit, bump: deps.longTasks.bump });
+        if (longTasks !== undefined)
+            longTaskDisposers.push(longTasks.dispose);
+        const result = face.mount({
+            ctx: deps.ctx,
+            logger: deps.logger,
+            manifests: deps.manifests,
+            ...(deps.opencliCommand === undefined ? {} : { opencliCommand: deps.opencliCommand }),
+            ...(deps.probe === undefined ? {} : { probe: deps.probe }),
+            ...(deps.values === undefined ? {} : { values: deps.values }),
+            ...(longTasks === undefined ? {} : { longTasks: longTasks.host }),
+            store,
+        });
+        mounted.push({ face, readiness, result: withRunsRoute(result, unit) });
+    }
+    const collected = collectRoutes(mounted);
+    const prefs = collectPrefs(mounted);
+    const actions = collectActions(mounted);
+    const owners = new Map(collected.owners);
+    for (const entry of [...prefs, ...actions])
+        owners.set(entry.resource, entry.unit);
+    const factsOf = new Map();
+    for (const item of mounted) {
+        const declare = item.result.factsOf;
+        if (declare !== undefined)
+            factsOf.set(item.face.manifest.id, declare);
+    }
+    return {
+        mounted,
+        routes: collected.routes,
+        owners,
+        routesOfUnit: collected.routesOfUnit,
+        factsOf,
+        gate: pickGate(mounted),
+        prefs,
+        actions,
+        provision: pickProvision(mounted),
+        contextRenderers: collectContextRenderers(mounted),
+        skipped,
+        warmReads: collectWarmReads(mounted),
+        disposeLongTasks: () => {
+            for (const dispose of longTaskDisposers.splice(0))
+                dispose();
+        },
+    };
+}

package/dist/host/opencli-runtime.js

@@ -1,5 +1,5 @@
 import { OPENCLI_PIN } from '../config/constants.js';
-import { quoteShellArg } from '../lib/text.js';
+import { quoteShellArg } from './shell-text.js';
 import { dshHome } from './data-root.js';
 export { dshHome };
 export function isolatedRoot() {

package/dist/host/opencli-window.js

@@ -1,4 +1,4 @@
-import { quoteShellArg } from '../lib/text.js';
+import { quoteShellArg } from './shell-text.js';
 const OPENCLI_WINDOW_ENV = 'OPENCLI_WINDOW=background';
 export function backgroundPrefix() {
     return [quoteShellArg('env'), quoteShellArg(OPENCLI_WINDOW_ENV)];

package/dist/host/opencli.js

@@ -1,5 +1,6 @@
 import { OPENCLI_MAX_CONCURRENT, OPENCLI_TIMEOUT_MS } from '../config/constants.js';
-import { parseJsonLoose, quoteShellArg, tailLines } from '../lib/text.js';
+import { parseJsonLoose } from '../lib/text.js';
+import { quoteShellArg, tailLines } from './shell-text.js';
 import { helpUrlOf, parseCliErrorEnvelope } from './cli-error.js';
 import { backgroundPrefix } from './opencli-window.js';
 import { runShell } from './shell.js';

package/dist/host/panel-state.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 一张面板卡片取数走到哪一步：`idle` 还没取、`loading` 取着、`ready` 拿到了、`error` 失败了。
+ */
+export type PanelCardPhase = 'idle' | 'loading' | 'ready' | 'error';
+/**
+ * 一次取数失败：机器码 + 给人看的一句话。
+ */
+export interface PanelCardError {
+    readonly code: string;
+    readonly message: string;
+}
+/**
+ * 一张卡片最近一次取数的读数：哪个单元、哪条路由、什么相位、什么时候、失败原因。
+ */
+export interface PanelCardRead {
+    readonly unit: string;
+    readonly route: string;
+    readonly phase: PanelCardPhase;
+    readonly at: number;
+    readonly error?: PanelCardError;
+}
+/**
+ * 一张卡片崩了的读数：单元、原因、时间，以及同一原因连着崩了几次（窗口见 `PANEL_STATE_CRASH_WINDOW_MS`）。
+ */
+export interface PanelCardCrash {
+    readonly unit: string;
+    readonly reason: string;
+    readonly at: number;
+    readonly count: number;
+}
+/**
+ * 一个单元此刻的读数：它的卡片、最近一次读成的时间（`okAt`，没成过给 `null`），以及崩了的那一条。
+ */
+export interface PanelUnitReport {
+    readonly unit: string;
+    readonly at: number;
+    readonly okAt: number | null;
+    readonly cards: readonly PanelCardRead[];
+    readonly crash?: PanelCardCrash;
+}
+/**
+ * 一个工作区此刻的全量读数（面板按工作区存）：所有单元的读数 + 整块最近动过的时间。
+ */
+export interface PanelWorkspaceReport {
+    readonly workspace: string | null;
+    readonly at: number;
+    readonly units: readonly PanelUnitReport[];
+}
+/**
+ * 客户端往上报的一批卡片读数（`POST` 请求体的形状）。
+ */
+export interface PanelCardsReport {
+    readonly workspace: string;
+    readonly cards: readonly PanelCardRead[];
+}
+/**
+ * 客户端往上报的一次卡片崩溃（`POST` 请求体的形状）。
+ */
+export interface PanelCrashReport {
+    readonly workspace: string;
+    readonly unit: string;
+    readonly reason: string;
+    readonly at: number;
+}
+/**
+ * 面板运行态的留存口（宿主持有一份）：收卡片读数与崩溃，按工作区取快照。
+ */
+export interface PanelStateStore {
+    cards(report: PanelCardsReport): void;
+    crash(report: PanelCrashReport): void;
+    snapshot(workspace: string | null): PanelWorkspaceReport;
+}
+/**
+ * 留存的工作区上限（LRU，满 64 个丢最旧的）。
+ */
+export declare const PANEL_STATE_MAX_UNITS = 64;
+/**
+ * 每个单元留存的卡片上限（按路由 LRU，满 12 张丢最旧的）。
+ */
+export declare const PANEL_STATE_MAX_CARDS = 12;
+/**
+ * 一次上报最多读入的卡片条数（32 条之后的丢掉）。
+ */
+export declare const PANEL_STATE_MAX_REPORTS = 32;
+/**
+ * 同一原因的连续崩溃算进同一次计数的窗口（10 分钟，毫秒）。
+ */
+export declare const PANEL_STATE_CRASH_WINDOW_MS = 600000;
+/**
+ * 上报文本字段的截断长度（2000 字符；workspace / reason / message 共用）。
+ */
+export declare const PANEL_STATE_MAX_TEXT = 2000;
+/**
+ * 上报解析的结果：`ok: true` 带收好的值，`ok: false` 带一句中文原因（直接回给上报方）。
+ */
+export type PanelParse<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/**
+ * 收一批卡片读数上报。
+ * @param payload - `POST` 的请求体。
+ * @returns 至少收到一条能认的卡片才 `ok: true`；请求体不是对象、`workspace` 为空、`cards` 不是数组，
+ *   或一条都认不出（`unit` / `route` / `phase` / `at` 缺一）时 `ok: false` + 中文原因；认不出的单条静默跳过。
+ */
+export declare function parseCardsReport(payload: unknown): PanelParse<PanelCardsReport>;
+/**
+ * 收一次卡片崩溃上报。
+ * @param payload - `POST` 的请求体。
+ * @returns `workspace` / `unit` / `reason` 都不能空，缺一给 `ok: false` + 中文原因；`at` 缺省或不合法时取当前时间。
+ */
+export declare function parseCrashReport(payload: unknown): PanelParse<PanelCrashReport>;
+/**
+ * 造一份面板运行态的留存（进程内存、按工作区分桶，带上面那几条上限的 LRU）。
+ * @returns 留存口：`cards` / `crash` 收上报，`snapshot(workspace)` 取全量；没存过的工作区（含 `null`）给一份空的。
+ */
+export declare function createPanelStateStore(): PanelStateStore;

package/dist/host/panel-state.js

@@ -0,0 +1,176 @@
+/**
+ * 留存的工作区上限（LRU，满 64 个丢最旧的）。
+ */
+export const PANEL_STATE_MAX_UNITS = 64;
+/**
+ * 每个单元留存的卡片上限（按路由 LRU，满 12 张丢最旧的）。
+ */
+export const PANEL_STATE_MAX_CARDS = 12;
+/**
+ * 一次上报最多读入的卡片条数（32 条之后的丢掉）。
+ */
+export const PANEL_STATE_MAX_REPORTS = 32;
+/**
+ * 同一原因的连续崩溃算进同一次计数的窗口（10 分钟，毫秒）。
+ */
+export const PANEL_STATE_CRASH_WINDOW_MS = 600000;
+/**
+ * 上报文本字段的截断长度（2000 字符；workspace / reason / message 共用）。
+ */
+export const PANEL_STATE_MAX_TEXT = 2000;
+const PHASES = ['idle', 'loading', 'ready', 'error'];
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function textOf(value, max) {
+    if (typeof value !== 'string')
+        return '';
+    const trimmed = value.trim();
+    return trimmed.length > max ? trimmed.slice(0, max) : trimmed;
+}
+function atOf(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return null;
+    if (value < 0)
+        return null;
+    return Math.trunc(value);
+}
+function errorOf(raw) {
+    const record = asRecord(raw);
+    if (record === undefined)
+        return undefined;
+    const code = textOf(record['code'], 120);
+    const message = textOf(record['message'], PANEL_STATE_MAX_TEXT);
+    if (code === '' && message === '')
+        return undefined;
+    return { code: code === '' ? 'unknown' : code, message };
+}
+/**
+ * 收一批卡片读数上报。
+ * @param payload - `POST` 的请求体。
+ * @returns 至少收到一条能认的卡片才 `ok: true`；请求体不是对象、`workspace` 为空、`cards` 不是数组，
+ *   或一条都认不出（`unit` / `route` / `phase` / `at` 缺一）时 `ok: false` + 中文原因；认不出的单条静默跳过。
+ */
+export function parseCardsReport(payload) {
+    const record = asRecord(payload);
+    if (record === undefined)
+        return { ok: false, message: '请求体要是一个对象' };
+    const workspace = textOf(record['workspace'], PANEL_STATE_MAX_TEXT);
+    if (workspace === '')
+        return { ok: false, message: 'workspace 不能是空的 —— 面板按工作区存' };
+    const raw = record['cards'];
+    if (!Array.isArray(raw))
+        return { ok: false, message: 'cards 要是一个数组' };
+    const cards = [];
+    for (const item of raw.slice(0, PANEL_STATE_MAX_REPORTS)) {
+        const card = asRecord(item);
+        if (card === undefined)
+            continue;
+        const unit = textOf(card['unit'], 200);
+        const route = textOf(card['route'], 400);
+        const phase = textOf(card['phase'], 20);
+        const at = atOf(card['at']);
+        if (unit === '' || route === '' || at === null || !PHASES.includes(phase))
+            continue;
+        const error = errorOf(card['error']);
+        cards.push({ unit, route, phase, at, ...(error === undefined ? {} : { error }) });
+    }
+    if (cards.length === 0)
+        return { ok: false, message: 'cards 里没有一条能认的（unit / route / phase / at 都要有）' };
+    return { ok: true, value: { workspace, cards } };
+}
+/**
+ * 收一次卡片崩溃上报。
+ * @param payload - `POST` 的请求体。
+ * @returns `workspace` / `unit` / `reason` 都不能空，缺一给 `ok: false` + 中文原因；`at` 缺省或不合法时取当前时间。
+ */
+export function parseCrashReport(payload) {
+    const record = asRecord(payload);
+    if (record === undefined)
+        return { ok: false, message: '请求体要是一个对象' };
+    const workspace = textOf(record['workspace'], PANEL_STATE_MAX_TEXT);
+    const unit = textOf(record['unit'], 200);
+    const reason = textOf(record['reason'], PANEL_STATE_MAX_TEXT);
+    if (workspace === '')
+        return { ok: false, message: 'workspace 不能是空的' };
+    if (unit === '')
+        return { ok: false, message: 'unit 不能是空的' };
+    if (reason === '')
+        return { ok: false, message: 'reason 不能是空的（没有原因的崩溃没法查）' };
+    return { ok: true, value: { workspace, unit, reason, at: atOf(record['at']) ?? Date.now() } };
+}
+/**
+ * 造一份面板运行态的留存（进程内存、按工作区分桶，带上面那几条上限的 LRU）。
+ * @returns 留存口：`cards` / `crash` 收上报，`snapshot(workspace)` 取全量；没存过的工作区（含 `null`）给一份空的。
+ */
+export function createPanelStateStore() {
+    const workspaces = new Map();
+    function trim(entry, max) {
+        while (entry.size > max) {
+            const oldest = entry.keys().next();
+            if (oldest.done === true)
+                return;
+            entry.delete(oldest.value);
+        }
+    }
+    function workspaceEntryOf(workspace) {
+        const existing = workspaces.get(workspace);
+        if (existing !== undefined)
+            return existing;
+        const created = { at: 0, units: new Map() };
+        workspaces.set(workspace, created);
+        trim(workspaces, PANEL_STATE_MAX_UNITS);
+        return created;
+    }
+    function unitEntryOf(entry, unit) {
+        const existing = entry.units.get(unit);
+        if (existing !== undefined)
+            return existing;
+        const created = { at: 0, cards: new Map() };
+        entry.units.set(unit, created);
+        return created;
+    }
+    return {
+        cards(report) {
+            const entry = workspaceEntryOf(report.workspace);
+            for (const card of report.cards) {
+                const unit = unitEntryOf(entry, card.unit);
+                unit.cards.delete(card.route);
+                unit.cards.set(card.route, card);
+                trim(unit.cards, PANEL_STATE_MAX_CARDS);
+                if (card.at > unit.at)
+                    unit.at = card.at;
+                if (card.at > entry.at)
+                    entry.at = card.at;
+            }
+        },
+        crash(report) {
+            const entry = workspaceEntryOf(report.workspace);
+            const unit = unitEntryOf(entry, report.unit);
+            const previous = unit.crash;
+            const counted = previous !== undefined &&
+                previous.reason === report.reason &&
+                report.at >= previous.at &&
+                report.at - previous.at <= PANEL_STATE_CRASH_WINDOW_MS;
+            unit.crash = { unit: report.unit, reason: report.reason, at: report.at, count: counted ? previous.count + 1 : 1 };
+            if (report.at > unit.at)
+                unit.at = report.at;
+            if (report.at > entry.at)
+                entry.at = report.at;
+        },
+        snapshot(workspace) {
+            if (workspace === null)
+                return { workspace: null, at: 0, units: [] };
+            const entry = workspaces.get(workspace);
+            if (entry === undefined)
+                return { workspace, at: 0, units: [] };
+            const units = [...entry.units.entries()].map(([unit, one]) => {
+                const cards = [...one.cards.values()].sort((a, b) => a.route.localeCompare(b.route));
+                const okAt = cards.reduce((best, card) => (card.phase === 'ready' && (best === null || card.at > best) ? card.at : best), null);
+                return { unit, at: one.at, okAt, cards, ...(one.crash === undefined ? {} : { crash: one.crash }) };
+            });
+            units.sort((a, b) => b.at - a.at || a.unit.localeCompare(b.unit));
+            return { workspace, at: entry.at, units };
+        },
+    };
+}

package/dist/host/plugin-source.js

@@ -1,4 +1,4 @@
-import { quoteShellArg } from '../lib/text.js';
+import { quoteShellArg } from './shell-text.js';
 import { npmCacheDir, toolchainOpencliDir, vendorPeerLink, vendorPrefix } from '../host/opencli-runtime.js';
 function mergeLines(commands) {
     return commands