@dsh-workbench/shared 0.3.10 → 1.0.0-beta.0

package/src/{api → lib}/dsh-client.ts

@@ -23,6 +23,7 @@ export interface WorkspaceSnapshot {
 
 /**
  * 会话一行的来源（标题、空会话、在跑与否、被谁留住）；retainedBy 按视图名记留住它的份数，mainView 大于 0 即正被主视图占着。
+ * projectionValues 是 dsh 的会话投影，外壳只读 `agentPreset` 一位（没选过模式时没有这一位）。
  */
 export interface SessionSummary {
   readonly id: string;
@@ -32,6 +33,7 @@ export interface SessionSummary {
   readonly updatedAt: number;
   readonly origin?: string;
   readonly retainedBy: Readonly<Partial<Record<string, number>>>;
+  readonly projectionValues?: Readonly<Record<string, unknown>>;
 }
 
 /**
@@ -254,7 +256,10 @@ export interface DshConversationService {
  * 浏览器侧的会话服务：快照加按 id 取作用域；create 是可选写口，不是每个 dsh 版本都有。
  */
 export interface DshSessionsService {
-  readonly list: { getSnapshot(): SessionsSnapshot };
+  readonly list: {
+    getSnapshot(): SessionsSnapshot;
+    subscribe?(listener: () => void): () => void;
+  };
   scope(sessionId: string): unknown | undefined;
   create?(request: {
     readonly workspaceId?: string;
@@ -295,10 +300,19 @@ export interface DshSessionsRemote {
 }
 
 /**
- * dsh 客户端的远端写口集合；目前只有会话一家。
+ * remote.agentPresets 写口：给还没开跑的会话挑模式（同一件事就是模式选择器点一下）；
+ * 会话发出第一条消息后 dsh 会拒（模式已锁）。
+ */
+export interface DshAgentPresetsRemote {
+  select(sessionId: string, presetId: string): Promise<unknown>;
+}
+
+/**
+ * dsh 客户端的远端写口集合；会话与模式两家。
  */
 export interface DshClientRemote {
   readonly sessions: DshSessionsRemote;
+  readonly agentPresets?: DshAgentPresetsRemote;
 }
 
 /**

package/src/lib/market-index.ts

@@ -0,0 +1,36 @@
+import type { MarketIndexSource, MarketLocalizedText } from '../contract/protocol/market-index.js';
+
+const BRANCH = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+
+export function marketBranchOk(value: string): boolean {
+  const branch = value.trim();
+  return (
+    BRANCH.test(branch) &&
+    !branch.includes('..') &&
+    !branch.endsWith('/') &&
+    !branch.endsWith('.') &&
+    !branch.includes('@{')
+  );
+}
+
+export function marketText(value: MarketLocalizedText | undefined, locale: string): string {
+  if (value === undefined) return '';
+  const zh = value.zh ?? '';
+  const en = value.en ?? '';
+  return locale.toLowerCase().startsWith('zh') ? zh || en : en || zh;
+}
+
+export function marketInstallTarget(
+  name: string,
+  version: string,
+  source: MarketIndexSource,
+): { readonly spec: string; readonly registry?: string } {
+  if (source.type === 'npm') {
+    const registry = (source.registry ?? '').trim();
+    return { spec: `${name}@${version}`, ...(registry === '' ? {} : { registry }) };
+  }
+  const base = `git+${source.url.trim().replace(/^git\+/, '')}#${source.commit}`;
+  const path = (source.path ?? '').trim().replace(/^\/+/, '');
+  return { spec: path === '' ? base : `${base}&path:/${path}` };
+}
+

package/src/lib/react-types.ts

@@ -0,0 +1,5 @@
+/**
+ * 从 react 借来的三个类型（`ReactNode` / `CSSProperties` / `ChangeEvent`）—— 模块从这里拿，
+ * 就不必自己直接依赖 react。只取类型：编译期擦除，不进任何产物。
+ */
+export type { ReactNode, CSSProperties, ChangeEvent } from 'react';

package/src/lib/react.ts

@@ -2,60 +2,21 @@ import type * as ReactTypes from 'react';
 
 const react = require('react') as typeof ReactTypes;
 
-/**
- * React 的 `createElement` 换个短名字再导出 —— 这套代码用 `h(...)` 写元素。
- */
 export const h = react.createElement;
 
-/**
- * React 的 `Fragment` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const Fragment = react.Fragment;
 
-/**
- * React 的 `Component` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const Component = react.Component;
 
-/**
- * React 的 `createContext` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const createContext = react.createContext;
-/**
- * React 的 `useContext` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const useContext = react.useContext;
 
-/**
- * React 的 `useState` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const useState = react.useState;
-/**
- * React 的 `useEffect` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const useEffect = react.useEffect;
-/**
- * React 的 `useLayoutEffect` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const useLayoutEffect = react.useLayoutEffect;
-/**
- * React 的 `useMemo` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const useMemo = react.useMemo;
-/**
- * React 的 `useCallback` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const useCallback = react.useCallback;
-/**
- * React 的 `useRef` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const useRef = react.useRef;
-/**
- * React 的 `useSyncExternalStore` 原样再导出 —— 模块从这里拿，就不必自己直接依赖 react。
- */
 export const useSyncExternalStore = react.useSyncExternalStore;
 
-/**
- * 从 react 借来的三个类型（`ReactNode` / `CSSProperties` / `ChangeEvent`）—— 模块从这里拿，就不必自己直接依赖 react。
- */
-export type { ReactNode, CSSProperties, ChangeEvent } from 'react';
+export type { ReactNode, CSSProperties, ChangeEvent } from './react-types.js';

package/src/lib/text.test.ts

@@ -16,7 +16,7 @@ describe('parseJsonLoose', () => {
     expect(parseJsonLoose('[1,2]\n完成')).toEqual([1, 2]);
   });
 
-  it('★ 噪音行自己带方括号时也不认错起点（真机：pagoda 的调试命令先打两行带 [] 的话）', () => {
+  it('★ 噪音行自己带方括号时也不认错起点（真机：acme 的调试命令先打两行带 [] 的话）', () => {
     const stdout = [
       '数据源 [dify_dataset] 调试成功',
       '结构类型: 3, 字段: code, name',
@@ -38,7 +38,7 @@ describe('parseJsonLoose', () => {
     ]);
   });
 
-  it('解析不出来给 undefined，让调用方报 coding-bad-output', () => {
+  it('解析不出来给 undefined，让调用方报 demo-bad-output', () => {
     expect(parseJsonLoose('')).toBeUndefined();
     expect(parseJsonLoose('not json at all')).toBeUndefined();
     expect(parseJsonLoose('[1,2')).toBeUndefined();

package/src/lib/ui.test.ts

@@ -1,3 +1,4 @@
+import dayjs from 'dayjs';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   cx,
@@ -15,7 +16,7 @@ const t: TimeTranslate = (key, params) => {
   return `${key}:${String(params.n ?? params.t ?? '')}`;
 };
 
-const NOW = Date.parse('2026-09-27T12:00:00.000Z');
+const NOW = dayjs('2026-09-27T12:00:00.000Z').valueOf();
 
 describe('cx', () => {
   it('拼上真值、丢掉假值', () => {
@@ -55,7 +56,7 @@ describe('relativeTime', () => {
 
     expect(old).not.toContain('time.');
     expect(old.match(/:/g)).toHaveLength(2);
-    expect(old).toContain(String(new Date(NOW).getFullYear()));
+    expect(old).toContain(String(dayjs(NOW).year()));
   });
 
   it('非法时间戳给空串而不是 NaN', () => {
@@ -125,12 +126,12 @@ describe('parseLocalTimestamp', () => {
   it('按本地时区解析 Coding 的时间戳形态', () => {
     const parsed = parseLocalTimestamp('2026-09-27 08:18:36');
     expect(Number.isFinite(parsed)).toBe(true);
-    expect(parsed).toBe(new Date('2026-09-27T08:18:36').getTime());
+    expect(parsed).toBe(dayjs('2026-09-27T08:18:36').valueOf());
   });
 
   it('也接受 ISO 的 T 分隔写法', () => {
     expect(parseLocalTimestamp('2026-09-27T08:18:36')).toBe(
-      new Date('2026-09-27T08:18:36').getTime(),
+      dayjs('2026-09-27T08:18:36').valueOf(),
     );
   });
 
@@ -142,7 +143,7 @@ describe('parseLocalTimestamp', () => {
 
   it('容忍首尾空白', () => {
     expect(parseLocalTimestamp('  2026-09-27 08:18:36  ')).toBe(
-      new Date('2026-09-27T08:18:36').getTime(),
+      dayjs('2026-09-27T08:18:36').valueOf(),
     );
   });
 });

package/src/lib/ui.ts

@@ -1,3 +1,4 @@
+import dayjs from 'dayjs';
 /**
  * 拼类名：只留真值、用空格连接（`false` / `null` / `undefined` / 空串都丢掉）。
  * @param parts - 若干类名或条件值。
@@ -91,14 +92,7 @@ export function relativeTime(epochMs: number, t: TimeTranslate): string {
   if (diff < 60 * MINUTE) return t('time.minutes', { n: Math.floor(diff / MINUTE) });
   if (diff < 24 * 60 * MINUTE) return t('time.hours', { n: Math.floor(diff / (60 * MINUTE)) });
   if (diff < 7 * 24 * 60 * MINUTE) return t('time.days', { n: Math.floor(diff / (24 * 60 * MINUTE)) });
-  return new Date(epochMs).toLocaleString(undefined, {
-    year: 'numeric',
-    month: 'numeric',
-    day: 'numeric',
-    hour: '2-digit',
-    minute: '2-digit',
-    second: '2-digit',
-  });
+  return dayjs(epochMs).format('YYYY/M/D HH:mm:ss');
 }
 
 /**
@@ -122,5 +116,5 @@ const LOCAL_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})$/;
 export function parseLocalTimestamp(text: string | null | undefined): number {
   const raw = String(text ?? '').trim();
   if (!LOCAL_TIMESTAMP.test(raw)) return Number.NaN;
-  return new Date(raw.replace(' ', 'T')).getTime();
+  return dayjs(raw.replace(' ', 'T')).valueOf();
 }

package/src/testing/__tests__/declaration.test.ts

@@ -19,7 +19,7 @@ afterEach(() => {
 });
 
 const DECLARED = {
-  apiVersion: 1,
+  apiVersion: 2,
   unit: 'demo',
   card: { titleKey: 'demo.cardTitle', order: 7 },
   tools: [{ name: 'workbench_demo_list', writes: false }],

package/src/testing/data.ts

@@ -0,0 +1,66 @@
+import type { CallOverrides, DataReader, DataRequest, RecipeCalls, RecipeResults, RequestRecipe } from '../contract/data.js';
+
+export interface RecipeCall {
+  readonly kind: 'request' | 'submit' | 'many';
+  readonly recipe: RequestRecipe;
+  readonly overrides?: CallOverrides | undefined;
+  readonly calls?: RecipeCalls | undefined;
+}
+
+const NO_DATA = {
+  ok: false as const,
+  error: { code: 'invalid-request' as const, message: '测试没有注入 DataReader' },
+};
+
+function filled(names: readonly string[], value: unknown): RecipeResults {
+  const out: Record<string, unknown> = {};
+  for (const name of names) out[name] = value;
+  return out as RecipeResults;
+}
+
+export function createNoopDataReader(): DataReader {
+  return {
+    read: async () => NO_DATA,
+    request: async () => NO_DATA,
+    requestMany: async <T = unknown>(_recipe: RequestRecipe, calls: RecipeCalls): Promise<RecipeResults<T>> =>
+      filled(Object.keys(calls), NO_DATA) as RecipeResults<T>,
+    submit: async () => NO_DATA,
+  };
+}
+
+export function createFakeDataReader(
+  reply: unknown | ((request: DataRequest, index: number) => unknown) = { ok: true, data: null },
+  recipeReply: unknown | ((call: RecipeCall, index: number) => unknown) = { ok: true, data: null },
+): DataReader & {
+  readonly requests: readonly DataRequest[];
+  readonly calls: readonly RecipeCall[];
+} {
+  const requests: DataRequest[] = [];
+  const calls: RecipeCall[] = [];
+  const answer = (call: RecipeCall): unknown =>
+    typeof recipeReply === 'function' ? recipeReply(call, calls.length - 1) : recipeReply;
+  const reader = {
+    async read(request: DataRequest): Promise<unknown> {
+      requests.push(request);
+      return typeof reply === 'function' ? reply(request, requests.length - 1) : reply;
+    },
+    async request(recipe: RequestRecipe, overrides?: CallOverrides): Promise<unknown> {
+      calls.push({ kind: 'request', recipe, overrides });
+      return answer(calls[calls.length - 1] as RecipeCall);
+    },
+    async requestMany(recipe: RequestRecipe, plan: RecipeCalls): Promise<RecipeResults> {
+      calls.push({ kind: 'many', recipe, calls: plan });
+      const answered = answer(calls[calls.length - 1] as RecipeCall);
+      return typeof answered === 'object' && answered !== null && !('ok' in answered)
+        ? (answered as RecipeResults)
+        : filled(Object.keys(plan), answered);
+    },
+    async submit(recipe: RequestRecipe, overrides?: CallOverrides): Promise<unknown> {
+      calls.push({ kind: 'submit', recipe, overrides });
+      return answer(calls[calls.length - 1] as RecipeCall);
+    },
+  } as unknown as DataReader;
+  return Object.assign(reader, { requests, calls });
+}
+
+export const fakeDataReader = createFakeDataReader;

package/src/testing/declaration.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import type { UnitManifest } from '../api/unit.js';
-import { readDeclaration } from '../host/unit-declaration.js';
+import type { UnitManifest } from '../contract/unit.js';
+import { readDeclaration } from '../contract/unit-declaration.js';
 
 export function declarationOfPackage(pkg: string, packageJson: URL | string): UnitManifest {
   const at = typeof packageJson === 'string' ? packageJson : fileURLToPath(packageJson);

package/src/testing/host-fakes.ts

@@ -1,6 +1,5 @@
 import { setTimeout as delay } from 'node:timers/promises';
 import type { DshShell } from '../api/dsh.js';
-import type { Opencli, OpencliResult } from '../host/opencli.js';
 
 export interface ShellCall {
   command: string;
@@ -66,43 +65,6 @@ export function createFakeShell(replies: ShellReply[] | ((call: ShellCall, index
   };
 }
 
-export interface OpencliCall {
-  args: readonly string[];
-  key?: string;
-  workdir?: string;
-  session?: string;
-  refresh?: boolean;
-}
-
-export function createFakeOpencli(
-  replies: Array<unknown | Error> | ((call: OpencliCall, index: number) => unknown | Error) = [],
-) {
-  const calls: OpencliCall[] = [];
-
-  const opencli: Opencli = {
-    async json(args, options = {}) {
-      const call: OpencliCall = {
-        args,
-        ...(options.key === undefined ? {} : { key: options.key }),
-        ...(options.workdir === undefined ? {} : { workdir: options.workdir }),
-        ...(options.session === undefined ? {} : { session: options.session }),
-      };
-      calls.push(call);
-      const index = calls.length - 1;
-      const reply =
-        typeof replies === 'function' ? replies(call, index) : (replies[index] ?? []);
-
-      if (reply instanceof Error) throw reply;
-      return { value: reply, at: Date.now() } satisfies OpencliResult;
-    },
-  };
-
-  return {
-    opencli,
-    calls,
-    keys: () => calls.map((call) => call.key),
-  };
-}
 
 export function createFakeLogger() {
   const warnings: string[] = [];

package/src/testing/needs.ts

@@ -0,0 +1,80 @@
+import type {
+  BinNeed,
+  EnvNeed,
+  ExtensionNeed,
+  LibNeed,
+  Need,
+  NeedKind,
+  SupplySource,
+} from '../contract/needs.js';
+import type { NeedState } from '../contract/unit-capability.js';
+import type { UnitCapability } from '../contract/unit-capability.js';
+import type { UnitManifest } from '../contract/unit.js';
+
+export const fakeNpmSource: SupplySource = {
+  kind: 'npm',
+  registryEnv: 'WB_TEST_REGISTRY',
+  registryDefault: 'https://registry.invalid/',
+};
+
+export function extensionNeedOf(name: string, extra: Partial<ExtensionNeed> = {}): ExtensionNeed {
+  return {
+    kind: 'extension',
+    runtime: 'opencli',
+    name,
+    commands: [`${name}-read`],
+    purpose: '测试',
+    ...extra,
+  };
+}
+
+export function libNeedOf(name: string, extra: Partial<LibNeed> = {}): LibNeed {
+  return { kind: 'lib', name, purpose: '测试', ...extra };
+}
+
+export function binNeedOf(name: string, extra: Partial<BinNeed> = {}): BinNeed {
+  return { kind: 'bin', name, purpose: '测试', ...extra };
+}
+
+export function envNeedOf(name: string, extra: Partial<EnvNeed> = {}): EnvNeed {
+  return { kind: 'env', name, purpose: '测试', ...extra };
+}
+
+export function manifestOf(
+  options: {
+    readonly id?: string | undefined;
+    readonly needs?: readonly Need[] | undefined;
+    readonly card?: UnitManifest['card'];
+  } = {},
+): UnitManifest {
+  return {
+    id: options.id ?? 'fixture',
+    card: options.card === undefined ? { titleKey: `${options.id ?? 'fixture'}.mine`, order: 10 } : options.card,
+    tools: [],
+    host: { inject: [] },
+    ...(options.needs === undefined ? {} : { needs: options.needs }),
+  };
+}
+
+export function needStateOf(
+  need: Need,
+  status: NeedState['status'] = 'ok',
+  extra: Partial<NeedState> = {},
+): NeedState {
+  return {
+    id: need.id ?? `${need.kind}:${need.name}`,
+    kind: need.kind as NeedKind,
+    name: need.name,
+    status,
+    detail: `测试：${need.name}`,
+    ...extra,
+  };
+}
+
+export function capabilityOf(
+  unit: string,
+  needs: readonly NeedState[] = [],
+  extra: Partial<UnitCapability> = {},
+): UnitCapability {
+  return { unit, status: needs.some((need) => need.status !== 'ok') ? 'missing' : 'ok', needs, ...extra };
+}

package/src/testing.ts

@@ -1,2 +1,4 @@
 export * from './testing/host-fakes.js';
 export * from './testing/declaration.js';
+export * from './testing/needs.js';
+export * from './testing/data.js';

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

@@ -1,39 +0,0 @@
-import type { ModuleBlocker } from './blocker.js';
-import type { CapabilityPayload } from './workbench-contract.js';
-import type { ApiError } from './workbench-client.js';
-/**
- * 卡片闸的两种档：capability 按环境读数判，none 无条件放行。
- */
-export type GateMode = 'capability' | 'none';
-/**
- * 一次放行判定的结果；gated 为假时卡片不画。
- */
-export interface UnitGate {
-    readonly gated: boolean;
-}
-/**
- * 判这张卡现在能不能画。
- * @param capability 环境读数；还没读到给 null。
- * @param mode 闸档。
- * @returns mode 为 none 或读数还没到都放行（先放行让它读）；读到明确不通过（ok 与 unchecked 之外）才拦。
- */
-export declare function gateOf(capability: CapabilityPayload | null, mode: GateMode): UnitGate;
-/**
- * 一个单元攒下的卡住态：blocker 顶掉卡片，notice 只提示；组装方产出，卡片消费。
- */
-export interface UnitBlockers {
-    readonly blocker?: ModuleBlocker;
-    readonly notice?: ModuleBlocker;
-}
-/**
- * 把候选卡住态分档，每档只留第一个。
- * @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/api/unit-board.js

@@ -1,45 +0,0 @@
-/**
- * 判这张卡现在能不能画。
- * @param capability 环境读数；还没读到给 null。
- * @param mode 闸档。
- * @returns mode 为 none 或读数还没到都放行（先放行让它读）；读到明确不通过（ok 与 unchecked 之外）才拦。
- */
-export function gateOf(capability, mode) {
-    if (mode === 'none')
-        return { gated: true };
-    if (capability === null)
-        return { gated: true };
-    return { gated: capability.status === 'ok' || capability.status === 'unchecked' };
-}
-/**
- * 把候选卡住态分档，每档只留第一个。
- * @param candidates 候选（可能含 undefined），按优先级从高到低给。
- * @returns 分出的 blocker 与 notice；已经有 blocker 时不带 notice（挡住就不必再提示）。
- */
-export function splitBlocker(candidates) {
-    let blocker;
-    let notice;
-    for (const candidate of candidates) {
-        if (candidate === undefined)
-            continue;
-        if (candidate.severity === 'block') {
-            blocker ??= candidate;
-            continue;
-        }
-        notice ??= candidate;
-    }
-    return {
-        ...(blocker === undefined ? {} : { blocker }),
-        ...(blocker !== undefined || notice === undefined ? {} : { notice }),
-    };
-}
-/**
- * 由读口错误算出「出错搭车强探」的防抖键：同一个键只自动重探一次。
- * @param error 读口错误；undefined 表示这次没有错误。
- * @returns 键字符串；空 code 归一到 unknown。
- */
-export function probeKeyOf(error) {
-    if (error === undefined)
-        return null;
-    return error.code === '' ? 'unknown' : error.code;
-}

package/dist/api/unit.d.ts

@@ -1,85 +0,0 @@
-/**
- * 一张卡片在清单里的静态声明（文案键加排序位）；默认显不显示由运行期面板配置定。
- */
-export interface UnitCard {
-    readonly titleKey: string;
-    readonly order: number;
-}
-/**
- * 一条工具在清单里的样子：全名加会不会写；审批按 writes 认领。
- */
-export interface UnitTool {
-    readonly name: string;
-    readonly writes: boolean;
-}
-/**
- * 模块要外壳的哪些服务：inject 缺一个就挂不上，optional 缺了照挂。
- */
-export interface UnitHostNeeds {
-    readonly inject: readonly string[];
-    readonly optional?: readonly string[];
-}
-/**
- * 一个 opencli 插件的来源三选一（git / 本地 / npm）；npm 那支的安装源先看 registryEnv 那个环境变量，没设才用 registryDefault。
- */
-export type PluginSource = {
-    readonly kind: 'git';
-    readonly url: string;
-} | {
-    readonly kind: 'local';
-    readonly env: string;
-} | {
-    readonly kind: 'npm';
-    readonly package: string;
-    readonly registryEnv: string;
-    readonly registryDefault?: string;
-};
-/**
- * 模块要的一个 opencli 插件：名字、它得提供的命令，以及装它的来源（没写就是不代装）。
- */
-export interface UnitPluginNeed {
-    readonly name: string;
-    readonly commands?: readonly string[];
-    readonly installSource?: PluginSource;
-}
-/**
- * 模块要的一个共用库：名字、期望范围与它为什么要这个版本（purpose 会进申报文案）。
- */
-export interface UnitLibNeed {
-    readonly name: string;
-    readonly version?: string | undefined;
-    readonly registryEnv: string;
-    readonly registryDefault: string;
-    readonly purpose: string;
-}
-/**
- * 模块的整份环境需要：一条自检命令，加上插件与共用库两张表。
- */
-export interface UnitEnvNeeds {
-    readonly command?: string;
-    readonly plugins?: readonly UnitPluginNeed[];
-    readonly libs?: readonly UnitLibNeed[];
-}
-/**
- * 已装插件与源上最新版那一对，用来判该不该提示升级；latest 缺省表示还没查到。
- */
-export interface PluginRelease {
-    readonly installed: string;
-    readonly latest?: string;
-}
-/**
- * 装配期用的模块清单：单元 id、卡片、工具与宿主 / 环境需要，比声明少一层协议包装。
- */
-export interface UnitManifest {
-    readonly id: string;
-    readonly card: UnitCard | null;
-    readonly tools: readonly UnitTool[];
-    readonly host: UnitHostNeeds;
-    readonly env?: UnitEnvNeeds;
-}
-/**
- * 判这个模块要不要往外装东西。
- * @param manifest 模块清单。
- * @returns 插件与共用库两张表都空时给 false。
- */
-export declare function hasEnvSupply(manifest: UnitManifest): boolean;

package/dist/api/unit.js

@@ -1,8 +0,0 @@
-/**
- * 判这个模块要不要往外装东西。
- * @param manifest 模块清单。
- * @returns 插件与共用库两张表都空时给 false。
- */
-export function hasEnvSupply(manifest) {
-    return (manifest.env?.plugins ?? []).length > 0 || (manifest.env?.libs ?? []).length > 0;
-}