@dsh-workbench/core 0.3.11 → 1.0.0-beta.0

package/dist/types/shared/api/host/long-tasks.d.ts

@@ -1,10 +1,3 @@
 import type { LongTaskBase, LongTaskRegistry } from '@dsh-workbench/shared/host';
-import type { ShellLongTaskRow } from '../long-tasks';
-/**
- * 把「单元 → 它那把长任务注册表」收成一条条**还在跑**的行（`live()` 已经只给活着的那几趟，
- * 收尾的是面板那一行的事）；注册表是上一版、没有 `live()` 就跳过这个单元 —— 与停止那条动作
- * 同一个理由：那一版里没有这份读口，不是这一版坏了。
- * @param runs 当前挂着的单元各自那把长任务注册表（外壳进程里就这一份）。
- * @returns 正在跑的长任务（含 `needs-login` 那种），每条带上是哪个单元起的。
- */
+import type { ShellLongTaskRow } from '../../../kernel/contract/long-tasks';
 export declare function liveLongTaskRows(runs: ReadonlyMap<string, LongTaskRegistry<LongTaskBase>>): ShellLongTaskRow[];

package/dist/types/shared/api/host/market-doc.d.ts

@@ -0,0 +1,21 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import type { DiscoverDoc, DiscoverDocKind, MarketIndexSource, MarketSourceConfig } from '@dsh-workbench/shared/contract/protocol/market-index';
+export interface MarketDocTarget {
+    readonly name: string;
+    readonly version: string;
+    readonly source: MarketIndexSource;
+}
+export interface MarketDocReader {
+    read(source: MarketSourceConfig, target: MarketDocTarget, kind: DiscoverDocKind): Promise<DiscoverDoc>;
+}
+export interface MarketDocReaderOptions {
+    readonly root: string;
+    readonly shell?: DshShell | undefined;
+    readonly fetchImpl?: ((url: string, init: RequestInit) => Promise<Response>) | undefined;
+    readonly timeoutMs?: number | undefined;
+    readonly maxBytes?: number | undefined;
+    readonly logger?: {
+        warn?(message: string): void;
+    } | undefined;
+}
+export declare function createMarketDocReader(options: MarketDocReaderOptions): MarketDocReader;

package/dist/types/shared/api/host/market-index-fetch.d.ts

@@ -0,0 +1,37 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import type { DiscoverProblem, IndexSourceSpec, MarketIndex, MarketSourceConfig } from '@dsh-workbench/shared/contract/protocol/market-index';
+export interface CachedIndex {
+    readonly index: MarketIndex;
+    readonly fetchedAt: number;
+    readonly commit?: string;
+}
+export type IndexRead = {
+    readonly ok: true;
+    readonly index: MarketIndex;
+    readonly fetchedAt: number;
+    readonly commit?: string;
+} | {
+    readonly ok: false;
+    readonly problem: DiscoverProblem;
+    readonly cached?: CachedIndex;
+};
+export interface MarketIndexReader {
+    read(source: MarketSourceConfig, options?: {
+        readonly force?: boolean;
+    }): Promise<IndexRead>;
+    cached(source: IndexSourceSpec): CachedIndex | undefined;
+    pathOf(source: IndexSourceSpec): string;
+}
+export interface MarketIndexReaderOptions {
+    readonly root: string;
+    readonly shell?: DshShell | undefined;
+    readonly fetchImpl?: ((url: string, init: RequestInit) => Promise<Response>) | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly ttlMs?: number | undefined;
+    readonly timeoutMs?: number | undefined;
+    readonly maxBytes?: number | undefined;
+    readonly logger?: {
+        warn?(message: string): void;
+    } | undefined;
+}
+export declare function createMarketIndexReader(options: MarketIndexReaderOptions): MarketIndexReader;

package/dist/types/shared/api/host/market-source-init.d.ts

@@ -0,0 +1,22 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import type { MarketSourceConfig } from '@dsh-workbench/shared/contract/protocol/market-index';
+import type { MarketSourcesStore } from './market-sources-store';
+export interface MarketSourceInitRequest {
+    readonly id: string;
+    readonly ref?: string;
+}
+export interface MarketSourceInitResult {
+    readonly source: MarketSourceConfig;
+    readonly branch: string;
+    readonly commit: string;
+    readonly created: readonly string[];
+    readonly changed: boolean;
+}
+export type MarketSourceInitializer = (request: MarketSourceInitRequest) => Promise<MarketSourceInitResult>;
+export interface MarketSourceInitOptions {
+    readonly root: string;
+    readonly store: MarketSourcesStore;
+    readonly shell?: DshShell | undefined;
+    readonly timeoutMs?: number | undefined;
+}
+export declare function createMarketSourceInitializer(options: MarketSourceInitOptions): MarketSourceInitializer;

package/dist/types/shared/api/host/market-sources-store.d.ts

@@ -0,0 +1,15 @@
+import type { MarketSourcesAction, MarketSourcesPayload } from '@dsh-workbench/shared/contract/protocol/market-index';
+export type MarketSourcesWrite = Exclude<MarketSourcesAction, {
+    readonly action: 'init';
+}>;
+export interface MarketSourcesStore {
+    read(): MarketSourcesPayload;
+    apply(action: MarketSourcesWrite): Promise<MarketSourcesPayload>;
+}
+export interface MarketSourcesStoreOptions {
+    readonly root: string;
+    readonly logger?: {
+        warn?(message: string): void;
+    } | undefined;
+}
+export declare function createMarketSourcesStore(options: MarketSourcesStoreOptions): MarketSourcesStore;

package/dist/types/shared/api/host/permission-mode.d.ts

@@ -1,9 +1,4 @@
 import type { DshHostContext } from '@dsh-workbench/shared';
-/**
- * 这个会话是不是「完全权限」：审批策略 `never` 且文件边界 `danger-full-access`。
- * 两件都成立时，工作台自己那层写审批不再返回 `ask` —— dsh 在 `never` 下会把 `ask` 直接拒掉。
- * 缺服务、读不到会话或读的时候抛了，一律当成不是：照旧问、照旧被拒，不偷偷放行。
- */
 export declare function fullPermissionOf(ctx: DshHostContext, agent: {
     readonly session?: unknown;
 } | undefined): boolean;

package/dist/types/shared/api/host/post-channels.d.ts

@@ -1,6 +1,6 @@
 import type { DshHostContext } from '@dsh-workbench/shared';
 import type { PostResource, PostWrite } from '@dsh-workbench/shared/host';
-import { type UnitsPlan } from './mount-units.js';
+import { type UnitsPlan } from '../../../kernel/host/mount-units.js';
 export interface PostChannelDeps {
     readonly ctx: DshHostContext;
     readonly mounted: ReadonlyMap<string, {

package/dist/types/shared/api/host/sidebar-edition.d.ts

@@ -1,46 +1,14 @@
 import type { PostResource, RouteHandler } from '@dsh-workbench/shared/host';
-import type { SidebarEdition, SidebarEditionApplied } from '../sidebar-edition.js';
-/**
- * 左栏档位读写要的宿主现场：当前 profile 目录（拿不到就是 `null`）。
- */
+import type { SidebarEdition, SidebarEditionApplied } from '../../../kernel/contract/sidebar-edition';
 export interface SidebarEditionDeps {
     readonly profileDir: string | null;
     readonly reconcile?: (() => Promise<void>) | undefined;
 }
-/**
- * 从 profile patch 的文本判当前左栏是哪一档：有一行 `- id: ui-sidebar` 且
- * `disabled: true` 就是自定义，否则官方。
- * @param text profile 的 cordis.patch.yml 全文。
- * @returns 左栏档位。
- */
 export declare function editionOfPatch(text: string): SidebarEdition;
-/**
- * 把 profile patch 改成指定的左栏档位：自定义写一行 `- id: ui-sidebar` +
- * `disabled: true`，官方删掉我们写的那一行（块里还有别的字段时只删 disabled）。
- * @param text profile 的 cordis.patch.yml 全文。
- * @param edition 目标档位。
- * @returns 新全文；已经是目标档位时原样返回。
- */
 export declare function withEdition(text: string, edition: SidebarEdition): string;
-/**
- * 读口：按 profile patch 里那行 `ui-sidebar` 报当前是官方还是自定义。
- * @param deps 当前 profile 目录。
- * @returns `{ ok: true, edition }`；拿不到 profile 时 `{ ok: false, error }`。
- */
 export declare function sidebarEditionHandler(deps: SidebarEditionDeps): RouteHandler;
-/**
- * 写口：把 profile patch 改成目标档位，写完读回来确认；不改别的行。
- * @param deps 当前 profile 目录。
- * @param payload `{ edition: 'official' | 'custom' }`。
- * @returns 写成功给新档位与“要刷新”；失败给人话。
- */
 export declare function sidebarEditionApply(deps: SidebarEditionDeps, payload: unknown): Promise<SidebarEditionApplied | {
     readonly ok: false;
     readonly text: string;
 }>;
-/**
- * 挂到 `actions` 通道的那一格写口。
- * @param deps 当前 profile 目录。
- * @returns 一个 `PostResource`。
- */
 export declare function sidebarEditionAction(deps: SidebarEditionDeps): PostResource;

package/dist/types/shared/api/host/unit-roster-facts.d.ts

@@ -1,4 +1,4 @@
-import type { UnitRegistry } from './unit-registry';
+import type { UnitRegistry } from '../../../kernel/host/unit-registry';
 export declare function bindRosterFacts(options: {
     readonly units: UnitRegistry;
     readonly bump: (facts: readonly string[]) => void;

package/dist/types/shared/api/host/workspace-root.d.ts

@@ -3,11 +3,4 @@ export interface SessionWorkspace {
     readonly root: string;
     readonly title: string;
 }
-/**
- * 这条会话落在哪个登记工作区：从 cwd 逐级往上问 `workspaceRegistry.resolveByPath`，命中就取那一份
- * 登记 path（会话开在子目录时也落到工作区根）。**不做任何"像不像工坊"的猜测** —— 查不到就是 `null`。
- * @param ctx - 宿主上下文（要 `workspaceRegistry` 服务）。
- * @param workspace - 会话的 cwd；`null` / 空串表示不知道。
- * @returns 登记工作区的根与标题；查不到给 `null`。
- */
 export declare function sessionWorkspaceOf(ctx: DshHostContext, workspace: string | null): Promise<SessionWorkspace | null>;

package/dist/types/shared/api/platform/client.d.ts

@@ -0,0 +1,10 @@
+import type { ClientSurface } from '../../../kernel/contract/platform';
+export interface ClientSurfaceInput {
+    readonly win?: {
+        readonly dshDesktop?: {
+            readonly protocolVersion?: number;
+        };
+    } | undefined;
+    readonly platform?: string | undefined;
+}
+export declare function clientSurface(input?: ClientSurfaceInput): ClientSurface;

package/dist/types/shared/api/unit-board.d.ts

@@ -1,20 +1,4 @@
 import type { ApiError, CapabilityPayload, GateMode, ModuleBlocker, UnitBlockers, UnitGate } from '@dsh-workbench/shared';
-/**
- * 判这张卡现在能不能画。
- * @param capability 环境读数；还没读到给 null。
- * @param mode 闸档。
- * @returns mode 为 none 或读数还没到都放行（先放行让它读）；读到明确不通过（ok 与 unchecked 之外）才拦。
- */
 export declare function gateOf(capability: CapabilityPayload | null, mode: GateMode): UnitGate;
-/**
- * 把候选卡住态分档，每档只留第一个。
- * @param candidates 候选（可能含 undefined），按优先级从高到低给。
- * @returns 分出的 blocker 与 notice；已经有 blocker 时不带 notice（挡住就不必再提示）。
- */
 export declare function splitBlocker(candidates: readonly (ModuleBlocker | undefined)[]): UnitBlockers;
-/**
- * 由读口错误算出「出错搭车强探」的防抖键：同一个键只自动重探一次。
- * @param error 读口错误；undefined 表示这次没有错误。
- * @returns 键字符串；空 code 归一到 unknown。
- */
 export declare function probeKeyOf(error: ApiError | undefined): string | null;

package/dist/types/shared/api/write-outcome.d.ts

@@ -1,15 +1,3 @@
 import type { ApiResponse, WriteChannel, WriteOutcome } from '@dsh-workbench/shared';
-/**
- * 由通道与资源拼出写路由。
- * @param channel 写通道。
- * @param resource 该通道下的资源名。
- * @returns 路由字符串；provision 只有一段，其余是 channel/resource。
- */
 export declare function writeRoute(channel: WriteChannel, resource: string): string;
-/**
- * 把写通道的响应翻成 WriteOutcome。
- * @param response 写口回的响应；null 表示请求本身没成（网络断了，宿主没答）。
- * @param networkText 拿不到任何服务端文案时兜底的那句。
- * @returns 失败时 message 优先用服务端自己的话，没有才用响应正文或 networkText。
- */
 export declare function writeOutcomeOf<T>(response: ApiResponse<T> | null, networkText: string): WriteOutcome<T>;

package/dist/types/shared/components/IconModules.d.ts

@@ -1,8 +1,2 @@
 import type { IconProps } from '@dsh-workbench/shared';
-/**
- * 四宫格："模块"这个概念的通用单色图标（侧栏、面板那颗钮、市场节的标题）；默认 16px。
- * 外壳自己用（`IconBrandMark` 那几枚在 kit 上，这枚不出口）。
- * @param props.size - 边长像素，同时给 `width` 与 `height`。
- * @returns 一枚 `aria-hidden` 的 svg。
- */
 export declare function IconModules({ size }: IconProps): JSX.Element;

package/dist/types/shared/components/PanelFoot.d.ts

@@ -1,16 +1,7 @@
 import type { ReactNode } from '@dsh-workbench/shared';
-/**
- * `<PanelFoot>` 的 prop：左边一句脚注，右边一格内容。
- */
 export interface PanelFootProps {
     readonly text?: string;
     readonly size?: 'sm' | 'md';
     readonly children?: ReactNode;
 }
-/**
- * 面板底部那行脚注：左侧一句 `text`，右侧放 `children`，两样都不给就是一个空的页脚壳。
- * @param props.text - 左侧那句说明文字；不传时左侧什么都不渲染。
- * @param props.size - 文字档（默认 `'sm'`，11px 三级色；`'md'` 是 14px 二级色，给更宽的面板用）。
- * @param props.children - 右侧那一格内容（一般是按钮或状态），可省略。
- */
 export declare function PanelFoot({ text, size, children }: PanelFootProps): JSX.Element;

package/dist/types/shared/components/blocker-action.d.ts

@@ -1,16 +1,3 @@
 import type { BlockerActionShape, BlockerLabelState, BlockerLabelTranslate } from '@dsh-workbench/shared';
-/**
- * 这颗钮此刻该不该按成等待态：这一轮忙还没收，或有一支正在跑。
- * @param busy - 这一轮忙是不是还在。
- * @param running - 正在跑的那一支的 label；没有就给 `null`。
- * @returns 该等待给 `true`，否则 `false`。
- */
 export declare function blockerPending(busy: boolean, running: string | null): boolean;
-/**
- * 这颗钮此刻该显示什么字：正在重试说「重试中…」，正在跑的那一支说「修复中…」，刚复制过的说「已复制」，其余原样。
- * @param action - 这颗钮的形状（行为 + 平时文案）。
- * @param state - 此刻的运行态。
- * @param t - i18n 取词函数。
- * @returns 要显示的文案；三种临时态都不成立时就是 `action.label`。
- */
 export declare function blockerActionLabel(action: BlockerActionShape, state: BlockerLabelState, t: BlockerLabelTranslate): string;

package/dist/types/shared/dev-surface/index.d.ts

@@ -0,0 +1,5 @@
+import type { BoardShape, DevBoard, DevPick, DevPickable, DevPickOptions, DevStrips, DevStripSite, DevSurface, FixtureStripProps } from './types';
+export declare function createNoopDevSurface(): DevSurface;
+export declare function installDevSurface(next: DevSurface): void;
+export { type BoardShape, type DevBoard, type DevPick, type DevPickable, type DevPickOptions, type DevStrips, type DevStripSite, type DevSurface, type FixtureStripProps };
+export declare const devSurface: DevSurface;

package/dist/types/shared/dev-surface/types.d.ts

@@ -0,0 +1,79 @@
+import type { ReactNode } from 'react';
+import type { BoardModule, UnitManifest } from '@dsh-workbench/shared';
+import type { PreflightSnapshot } from '@dsh-workbench/shared/host';
+export type BoardShape = {
+    readonly kind: 'real';
+} | {
+    readonly kind: 'empty';
+} | {
+    readonly kind: 'unread';
+} | {
+    readonly kind: 'kit';
+} | {
+    readonly kind: 'all';
+} | {
+    readonly kind: 'copies';
+    readonly count: number;
+};
+export interface DevPickable {
+    readonly id: string;
+    readonly label: string;
+}
+export interface DevPickOptions<T extends DevPickable> {
+    readonly fixtures: readonly T[];
+    readonly selected?: string | null | undefined;
+    readonly onSelect?: ((id: string | null) => void) | undefined;
+    readonly enabled?: boolean | undefined;
+    readonly initial?: string | null | undefined;
+}
+export interface DevPick<T extends DevPickable> {
+    readonly enabled: boolean;
+    readonly active: string | null;
+    readonly current: T | undefined;
+    readonly nonce: number;
+    readonly index: number;
+    pick(id: string | null): void;
+}
+export interface DevStrips<T extends DevPickable> {
+    readonly pick: DevPick<T>;
+    readonly current: T | undefined;
+    readonly enabled: boolean;
+    readonly strip: ReactNode;
+}
+export interface DevBoard {
+    readonly shape: BoardShape;
+    readonly seed: readonly BoardModule[];
+    readonly strip: (show: boolean) => ReactNode;
+    readonly mode: boolean;
+}
+export type DevStripSite = 'panel' | 'market' | 'addModule';
+export interface FixtureStripProps {
+    readonly mocks: readonly {
+        readonly id: string;
+        readonly label: string;
+    }[];
+    readonly index: number;
+    readonly onPick: (next: number) => void;
+    readonly note?: string;
+    readonly real?: {
+        readonly label: string;
+        readonly active: boolean;
+        readonly onPick: () => void;
+    } | undefined;
+}
+export interface DevSurface {
+    on(search: string): boolean;
+    crash(search: string): boolean;
+    useBoard(input: {
+        readonly manifests: readonly UnitManifest[];
+        readonly all: readonly BoardModule[];
+        readonly search: string;
+    }): DevBoard;
+    useStrips<T extends DevPickable>(site: DevStripSite, manifests: readonly UnitManifest[]): DevStrips<T>;
+    addModuleState(base: unknown, mock: unknown): unknown;
+    gateStrip(options: {
+        readonly onPick: (snapshot: PreflightSnapshot | null) => void;
+    }): HTMLElement | null;
+    readonly Strip: (props: FixtureStripProps) => ReactNode;
+    readonly kitModule: BoardModule | null;
+}

package/dist/types/shared/hooks/bundle-queries.d.ts

@@ -1,19 +1,7 @@
 import type { ApiResponse } from '@dsh-workbench/shared';
-import { type BundleInspectionPayload, type BundleRegistriesPayload, type ModuleVersionsPayload } from '../api/bundle-install';
+import { type BundleInspectionPayload, type BundleRegistriesPayload, type ModuleVersionsPayload } from '../../kernel/contract/bundle-install';
 import { type InstalledPluginsPayload } from '../api/installed-plugins';
-/**
- * 读模块源注册表：装模块时能从哪些源取、当前解析到哪一个。
- */
 export declare function readBundleRegistries(): Promise<ApiResponse<BundleRegistriesPayload>>;
-/**
- * 装之前先看清一个 spec 是什么（收了 / 拒了 / 是个插件）；`registry` 省略或空就按默认源解析。
- */
 export declare function readBundleInspection(spec: string, registry?: string): Promise<ApiResponse<BundleInspectionPayload>>;
-/**
- * 问模块有没有新版；`force: true` 绕过缓存重新问源（“更新”那条路用）。
- */
 export declare function readModuleVersions(force?: boolean): Promise<ApiResponse<ModuleVersionsPayload>>;
-/**
- * 读已装的 opencli 插件台账；`force: true` 绕过缓存重新问一遍。
- */
 export declare function readInstalledPlugins(force?: boolean): Promise<ApiResponse<InstalledPluginsPayload>>;

package/dist/types/shared/hooks/fact-transport.d.ts

@@ -0,0 +1,4 @@
+import { type FactTransportMode } from '@dsh-workbench/shared';
+export declare const factChannel: import("@dsh-workbench/shared").FactChannel;
+export declare function factTransportMode(): FactTransportMode | null;
+export declare function subscribeFactTransportMode(listener: (mode: FactTransportMode | null) => void): () => void;

package/dist/types/shared/hooks/fact-transports.d.ts

@@ -1,6 +1,2 @@
 import { type FactTransport } from '@dsh-workbench/shared';
-/**
- * 事实通道的传输选择：有 `EventSource` 就先用 SSE，连不上（重试一拍仍失败）自动降级成长轮询；
- * 没有 `EventSource` 的运行时直接轮询。返回值是停掉当前这条传输的函数。
- */
 export declare function createAdaptiveTransport(): FactTransport;

package/dist/types/shared/hooks/market-queries.d.ts

@@ -0,0 +1,11 @@
+import type { ApiResponse } from '@dsh-workbench/shared';
+import { type DiscoverDoc, type DiscoverDocKind, type DiscoverPayload, type PublishPreview } from '../../kernel/contract/market-index';
+export declare function readMarketDiscover(options?: {
+    readonly force?: boolean;
+}): Promise<ApiResponse<DiscoverPayload>>;
+export declare function readMarketDoc(name: string, version: string, kind: DiscoverDocKind): Promise<ApiResponse<{
+    readonly doc: DiscoverDoc;
+}>>;
+export declare function readPublishPreview(unit: string, version?: string): Promise<ApiResponse<{
+    readonly preview: PublishPreview | null;
+}>>;

package/dist/types/shared/hooks/panel-state-report.d.ts

@@ -1,24 +1,12 @@
 import type { PanelCardError, PanelCardPhase } from '@dsh-workbench/shared/host';
-/**
- * 从路由里切出单元 id（`cmdb/runs` → `cmdb`）；切不出来（没有前缀）回 `null`。
- */
 export declare function unitOfRoute(route: string): string | null;
-/**
- * 告诉上报这沓“现在的工作区是哪个”；换工作区会丢掉还没冲出去的待报读数。
- */
 export declare function setPanelWorkspace(path: string | null): void;
-/**
- * 卡片读数落地时调它（`useApiResource` 已经接好）：同一单元同一条路由只留最新一条，攒一拍再一起冲给宿主。
- */
 export declare function reportPanelRead(input: {
     readonly unit: string;
     readonly route: string;
     readonly phase: PanelCardPhase;
     readonly error?: PanelCardError | undefined;
 }): void;
-/**
- * 卡片崩了时调它：`unit` 与原因立刻报给宿主（不攒）；还不知道工作区时不报。
- */
 export declare function reportPanelCrash(input: {
     readonly unit: string;
     readonly reason: string;

package/dist/types/shared/hooks/sidebar-edition.d.ts

@@ -1,7 +1,2 @@
-import type { SidebarEditionSnapshot } from '../api/sidebar-edition';
-/**
- * 启动时读一次「左栏用哪一档」：这是静态组合决定的值（改了要刷新页面），不是事实流，
- * 所以不走 `useApiResource` 的订阅那一路；调用点只在客户端 apply 里一次。
- * @returns 宿主写的档位；读不到时 `undefined`（按官方 + 官方没落地再兜底）。
- */
+import type { SidebarEditionSnapshot } from '../../kernel/contract/sidebar-edition';
 export declare function readSidebarEdition(): Promise<SidebarEditionSnapshot | undefined>;

package/dist/types/shared/hooks/use-blocker-actions.d.ts

@@ -1,7 +1,4 @@
 import type { BlockerAction } from '@dsh-workbench/shared';
-/**
- * blocker 那几个动作的句柄：`run(action)` 执行、`copied` 刚复制走的文本、`running` 正在跑的修复标签、`failure` 失败信息。
- */
 export interface BlockerActions {
     run(action: BlockerAction): void;
     copied: string | null;
@@ -11,9 +8,4 @@ export interface BlockerActions {
         detail?: string;
     } | null;
 }
-/**
- * `<BlockerState>` 用它把 blocker 的动作接到实处：`retry` 与修复成功后的重试走 `onRetry`、`run-fix` 走 provision
- * 写通道、`copy` 写剪贴板、`open-url` 开新窗；`open-market` 没给 `onOpenMarket` 时退回 `onRetry`。
- * 自己画 blocker 那一块才直接用。
- */
 export declare function useBlockerActions(onRetry: () => void, onOpenMarket?: () => void): BlockerActions;

package/dist/types/shared/hooks/use-capabilities.d.ts

@@ -1,85 +1,26 @@
 import type { CapabilityPayload } from '@dsh-workbench/shared';
-/**
- * 纯函数：`refreshToken` 与上一次不同，这一次就该强制重探。
- */
 export declare function shouldForce(refreshToken: number, previousToken: number): boolean;
-/**
- * 整张能力表：单元 id → 那一格声明的能力（`design.json` 里那份）。
- */
 export type CapabilityMap = Record<string, CapabilityPayload>;
-/**
- * 探针状态：`checkedAt` 上一次探完的时刻（没探过是 `null`）、`checking` 是不是正在探。
- */
 export interface CapabilityProbeState {
     readonly checkedAt: number | null;
     readonly checking: boolean;
 }
-/**
- * 让下一次强探静默（不点亮 `checking`）—— 装机预检那类不该惊动界面的探用。
- */
 export declare function markNextProbeSilent(): void;
-/**
- * 探针状态的取值口，给 `useSyncExternalStore` 用；渲染里要状态请用 `useCapabilityProbe`。
- */
 export declare function probeValue(): CapabilityProbeState;
-/**
- * 探针状态的订阅口，返回退订函数；渲染里要状态请用 `useCapabilityProbe`。
- */
 export declare function subscribeProbe(listener: () => void): () => void;
-/**
- * 能力表那条事实的名字：写完之后 `useFactInvalidate(CAPABILITY_FACT)` 标它，读者自动重取。
- */
 export declare const CAPABILITY_FACT = "capability";
-/**
- * 写完之后把读数作废：写之前发出去的在飞探测即使回来也不许发布（它探的是改之前的样子）。
- * 配一次 `force` 的读，界面才不会拿着旧能力表再摆一次「更新」。
- */
 export declare function bumpCapabilityEpoch(): void;
-/**
- * 当前整张能力表的取值口（没探过是 `null`），给 `useSyncExternalStore` 用；渲染里请用 `useCapabilities`。
- */
 export declare function capabilityValue(): CapabilityMap | null;
-/**
- * 能力表的订阅口，返回退订函数；渲染里请用 `useCapabilities`。
- */
 export declare function subscribeCapabilities(listener: () => void): () => void;
-/**
- * 写入口：换整张表并通知订阅者（同值不通知）；传 `null` 清探针状态，`rechecked: true` 时顺手记下 `checkedAt`。
- */
 export declare function setCapabilities(next: CapabilityMap | null, rechecked?: boolean): void;
-/**
- * 一次强探开始：点亮“正在探”；已经在探就跳过。
- */
 export declare function beginProbe(): void;
-/**
- * 一次强探收尾：熄灭“正在探”。
- */
 export declare function endProbe(): void;
-/**
- * 把一次探测的结果发布出去：读到了就广播并回 `true`；没读到（`null`）时已有结论就留着回 `false`，
- * 从来没有过结论才落一张空表回 `true`（“探不动”不等于“还没探”）。
- */
 export declare function publishCapability(result: CapabilityMap | null, rechecked?: boolean): boolean;
-/**
- * 同一语义（同一个 `force`）的在飞探测搭车：并发调用共享同一个 promise；落地或失败就清掉，
- * 下一次强探会真的再跑一遍；`force` 不同不搭车。
- */
 export declare function shareCapabilityFetch(force: boolean, load: (force: boolean) => Promise<CapabilityMap | null>): Promise<CapabilityMap | null>;
-/**
- * 探一次能力表并发布：`force` 决定这是“重探”还是顺带读 —— 只有重探负责点亮 / 熄灭探针（`silent` 时连点亮都不做），
- * 被更新的一次重探盖过的非强制结果会丢掉。
- */
 export declare function runCapabilityRead(options: {
     readonly force: boolean;
     readonly silent?: boolean;
     readonly load?: (force: boolean) => Promise<CapabilityMap | null>;
 }): Promise<void>;
-/**
- * 渲染里要整张能力表时调用：所有读者共享同一份结论，没探过是 `null`。
- * `refreshToken` 变化算一次强制重探，事实版本（`CAPABILITY_FACT`）与 `reloadToken` 变化各触发一次重读。
- */
 export declare function useCapabilities(refreshToken: number, reloadToken?: number): CapabilityMap | null;
-/**
- * 渲染里要探针状态（`checking` / `checkedAt`）时调用，比如“最近检查”那一行。
- */
 export declare function useCapabilityProbe(): CapabilityProbeState;

package/dist/types/shared/hooks/use-diy-debug.d.ts

@@ -1,21 +1,8 @@
 import type { DebugState } from '@dsh-workbench/shared/host';
 import type { HostWrite } from './use-host-write';
-/**
- * 调试约定的读路由（宿主侧那半同名）。
- */
 export declare const DIY_DEBUG_ROUTE = "panels/diy-debug";
-/**
- * 调试约定那条事实的名字：写完调 `useFactInvalidate(DIY_DEBUG_FACT)`，读者自动重取。
- */
 export declare const DIY_DEBUG_FACT = "diy-debug";
-/**
- * 要读“现在的调试约定是什么”时调用（左栏底部那枚状态）；跟着事实变化自动重取，不上报面板；
- * 还没读到或后端说没有约定时都是 `null`。
- */
 export declare function useDiyDebugState(): DebugState | null;
-/**
- * 要发“开始 / 暂停 / 继续 / 结束调试”那几把动作时调用；写走 `diy-debug/act` 通道。
- */
 export declare function useDiyDebugAct(): HostWrite<{
     text?: string;
 }>;

package/dist/types/shared/hooks/use-diy-record.d.ts

@@ -1,21 +1,8 @@
 import type { RecordState } from '@dsh-workbench/shared/host';
 import type { HostWrite } from './use-host-write';
-/**
- * 录制交接的读路由（宿主侧那半同名）。
- */
 export declare const DIY_RECORD_ROUTE = "panels/diy-record";
-/**
- * 录制交接那条事实的名字：写完调 `useFactInvalidate(DIY_RECORD_FACT)`，读者自动重取。
- */
 export declare const DIY_RECORD_FACT = "diy-record";
-/**
- * 要读“这一段录制交接进行到哪了”时调用（左栏底部那枚状态）；跟着事实变化自动重取，不上报面板；
- * 还没读到或后端说没有交接时都是 `null`。
- */
 export declare function useDiyRecordState(): RecordState | null;
-/**
- * 要发录制交接那几把动作（准备 / 读回 / 收尾）时调用；写走 `diy-record/act` 通道。
- */
 export declare function useDiyRecordAct(): HostWrite<{
     text?: string;
 }>;

package/dist/types/shared/hooks/use-shell-long-tasks.d.ts

@@ -1,8 +1,2 @@
-import { type ShellLongTaskRow } from '../api/long-tasks';
-/**
- * 左栏那颗 loading 点读的长任务清单：**全进程还在跑的**那些（不分单元、不分工作区，每行带它属于
- * 哪个工作区、是哪个会话起的）。起 / 走一步 / 收尾宿主都会推一条事实，收到就当场重读；那个定时器
- * 只是兜底 —— 有在跑的按快档问，都闲着按慢档。
- * @returns 还在跑的长任务；读数还没回来时是空数组。
- */
+import { type ShellLongTaskRow } from '../../kernel/contract/long-tasks';
 export declare function useShellLongTasks(): readonly ShellLongTaskRow[];