@dsh-workbench/shared 0.3.11 → 1.0.0-beta.1

package/dist/contract/command.d.ts

@@ -0,0 +1,22 @@
+export interface CommandFile {
+    readonly content: string;
+    readonly suffix?: string | undefined;
+}
+export interface CommandRequest {
+    readonly argv: readonly string[];
+    readonly timeoutMs?: number | undefined;
+    readonly cwd?: string | undefined;
+    readonly files?: readonly CommandFile[] | undefined;
+    readonly appendFileArgs?: string | undefined;
+}
+export interface CommandResult {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode: number;
+    readonly timedOut: boolean;
+    readonly filePaths: readonly string[];
+    readonly error?: string | undefined;
+}
+export interface CommandReader {
+    run(request: CommandRequest): Promise<CommandResult>;
+}

package/dist/contract/data.d.ts

@@ -0,0 +1,127 @@
+export interface DataRequestBase {
+    readonly timeoutMs?: number;
+}
+export interface HttpDataRequest extends DataRequestBase {
+    readonly kind: 'http';
+    readonly url: string;
+    readonly headers?: Readonly<Record<string, string>>;
+}
+export interface BrowserDataRequest extends DataRequestBase {
+    readonly kind: 'browser';
+    readonly script: string;
+    readonly url?: string;
+    readonly loginUrl?: string;
+    readonly session?: string;
+    readonly open?: boolean;
+}
+export interface CommandDataRequest extends DataRequestBase {
+    readonly kind: 'command';
+    readonly adapter: string;
+    readonly argv: readonly string[];
+}
+export type DataRequest = HttpDataRequest | BrowserDataRequest | CommandDataRequest;
+export type DataErrorCode = 'invalid-request' | 'http' | 'auth' | 'timeout' | 'parse' | 'command' | 'browser';
+export interface DataError {
+    readonly code: DataErrorCode;
+    readonly message: string;
+    readonly status?: number;
+    readonly detail?: string;
+    readonly hint?: string;
+    readonly helpUrl?: string;
+    readonly pageCode?: string;
+}
+export interface DataSuccess<T = unknown> {
+    readonly ok: true;
+    readonly data: T;
+}
+export interface DataFailure {
+    readonly ok: false;
+    readonly error: DataError;
+}
+export type DataResult<T = unknown> = DataSuccess<T> | DataFailure;
+export interface CredentialSourceCookie {
+    readonly kind: 'cookie';
+}
+export interface CredentialSourceCookieValue {
+    readonly kind: 'cookieValue';
+    readonly name: string;
+}
+export interface CredentialSourceEndpoint {
+    readonly kind: 'endpoint';
+    readonly url: string;
+    readonly method?: 'GET' | 'POST';
+    readonly body?: unknown;
+    readonly path: string;
+}
+export interface CredentialSourceMeta {
+    readonly kind: 'meta';
+    readonly name: string;
+}
+export interface CredentialSourceGlobal {
+    readonly kind: 'global';
+    readonly path: string;
+}
+export interface CredentialSourceStorage {
+    readonly kind: 'storage';
+    readonly area: 'local' | 'session';
+    readonly key: string;
+    readonly path?: string;
+}
+export type CredentialSource = CredentialSourceCookie | CredentialSourceCookieValue | CredentialSourceEndpoint | CredentialSourceMeta | CredentialSourceGlobal | CredentialSourceStorage;
+export type CredentialPlace = {
+    readonly in: 'cookie';
+} | {
+    readonly in: 'header';
+    readonly name: string;
+    readonly prefix?: string;
+} | {
+    readonly in: 'query';
+    readonly name: string;
+} | {
+    readonly in: 'body';
+    readonly field: string;
+};
+export type RecipeAuth = {
+    readonly kind: 'none';
+} | {
+    readonly kind?: undefined;
+    readonly source: CredentialSource;
+    readonly place: CredentialPlace;
+};
+export interface RecipeRequest {
+    readonly method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    readonly path: string;
+    readonly query?: Readonly<Record<string, string | number | boolean>>;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: unknown;
+    readonly contentType?: 'json' | 'form';
+}
+export interface RecipeResponse {
+    readonly kind: 'json' | 'text';
+    readonly path?: string;
+    readonly maxBytes?: number;
+}
+export interface RequestRecipe {
+    readonly origin: string;
+    readonly loginUrl?: string;
+    readonly session?: string;
+    readonly timeoutMs?: number;
+    readonly auth?: RecipeAuth;
+    readonly request: RecipeRequest;
+    readonly response?: RecipeResponse;
+}
+export interface CallOverrides {
+    readonly path?: string;
+    readonly query?: Readonly<Record<string, string | number | boolean>>;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: unknown;
+    readonly response?: Partial<RecipeResponse>;
+}
+export type RecipeCalls = Readonly<Record<string, CallOverrides>>;
+export type RecipeResults<T = unknown> = Readonly<Record<string, DataResult<T>>>;
+export interface DataReader {
+    read<T = unknown>(request: DataRequest): Promise<DataResult<T>>;
+    request<T = unknown>(recipe: RequestRecipe, overrides?: CallOverrides): Promise<DataResult<T>>;
+    requestMany<T = unknown>(recipe: RequestRecipe, calls: RecipeCalls): Promise<RecipeResults<T>>;
+    submit<T = unknown>(recipe: RequestRecipe, overrides?: CallOverrides): Promise<DataResult<T>>;
+}

package/dist/contract/extension.d.ts

@@ -0,0 +1,14 @@
+export type ExtensionSession = 'persistent' | 'ephemeral' | 'none';
+export interface ExtensionCallOptions {
+    readonly key?: string;
+    readonly workdir?: string;
+    readonly session?: ExtensionSession;
+    readonly timeoutMs?: number;
+}
+export interface ExtensionValue<T = unknown> {
+    readonly value: T;
+    readonly at: number;
+}
+export interface ExtensionCaller {
+    json(args: readonly string[], options?: ExtensionCallOptions): Promise<ExtensionValue>;
+}

package/dist/contract/extension.js

@@ -0,0 +1 @@
+export {};

package/dist/{api → contract}/facts.d.ts

@@ -7,7 +7,7 @@ export interface FactFrame {
     readonly facts: readonly string[];
 }
 /**
- * 范围查法的后缀：cmdb/* 这类名字表示「这个前缀下的一族」，不是一条事实。
+ * 范围查法的后缀：inventory/* 这类名字表示「这个前缀下的一族」，不是一条事实。
  */
 export declare const FACT_SCOPE_SUFFIX = "*";
 /**
@@ -23,16 +23,23 @@ export declare function isFactScope(name: string): boolean;
  */
 export declare function scopePrefixOf(name: string): string;
 /**
- * 事实的来路：start 建连并按帧回调，cursor 报已收到的宿主 rev（断线重连时交给宿主）。
+ * 事实传输层的来路：SSE 直连，或降级成轮询。
+ */
+export type FactTransportMode = 'sse' | 'polling';
+/**
+ * 事实的来路：start 建连并按帧回调，cursor 报已收到的宿主 rev（断线重连时交给宿主），
+ * onMode 报这一层现在是哪种传输。
  */
 export interface FactTransport {
     start(handlers: {
         readonly onFrame: (frame: FactFrame) => void;
         readonly cursor: () => number;
+        readonly onMode?: ((mode: FactTransportMode) => void) | undefined;
     }): () => void;
 }
 /**
- * 浏览器侧的事实通道：订阅、读版本、手动刷新，帧到了由它分发给订阅者。
+ * 浏览器侧的事实通道：订阅、读版本、手动刷新，帧到了由它分发给订阅者；
+ * mode 是传输层现在走的来路（还没建连就是 null），subscribeMode 听它换档。
  */
 export interface FactChannel {
     subscribe(fact: string, listener: () => void): () => void;
@@ -40,6 +47,8 @@ export interface FactChannel {
     refresh(fact?: string): void;
     applyFrame(frame: FactFrame): void;
     subscriberCount(): number;
+    mode(): FactTransportMode | null;
+    subscribeMode(listener: () => void): () => void;
 }
 /**
  * 造一条事实通道：第一次订阅时才连传输层，最后一个订阅者走掉就断开。

package/dist/{api → contract}/facts.js

@@ -1,5 +1,5 @@
 /**
- * 范围查法的后缀：cmdb/* 这类名字表示「这个前缀下的一族」，不是一条事实。
+ * 范围查法的后缀：inventory/* 这类名字表示「这个前缀下的一族」，不是一条事实。
  */
 export const FACT_SCOPE_SUFFIX = '*';
 /**
@@ -25,10 +25,19 @@ export function scopePrefixOf(name) {
  */
 export function createFactChannel(options) {
     const entries = new Map();
+    const modeListeners = new Set();
     let epoch = null;
     let stopTransport = null;
     let hostRev = 0;
     let generation = 0;
+    let mode = null;
+    const setMode = (next) => {
+        if (mode === next)
+            return;
+        mode = next;
+        for (const listener of [...modeListeners])
+            listener();
+    };
     const entryOf = (fact) => {
         const existing = entries.get(fact);
         if (existing !== undefined)
@@ -72,6 +81,7 @@ export function createFactChannel(options) {
         stopTransport = options.transport.start({
             onFrame: (frame) => channel.applyFrame(frame),
             cursor: () => hostRev,
+            onMode: (next) => setMode(next),
         });
     };
     const releaseTransport = () => {
@@ -79,6 +89,7 @@ export function createFactChannel(options) {
             return;
         stopTransport();
         stopTransport = null;
+        setMode(null);
     };
     const channel = {
         revisionOf: (fact) => entries.get(fact)?.rev ?? 0,
@@ -98,6 +109,13 @@ export function createFactChannel(options) {
                 count += entry.listeners.size;
             return count;
         },
+        mode: () => mode,
+        subscribeMode(listener) {
+            modeListeners.add(listener);
+            return () => {
+                modeListeners.delete(listener);
+            };
+        },
         refresh(fact) {
             generation += 1;
             if (fact === undefined) {

package/dist/contract/git.d.ts

@@ -0,0 +1,38 @@
+export type OriginRead = {
+    readonly kind: 'ok';
+    readonly remote: string;
+} | {
+    readonly kind: 'no-origin';
+    readonly detail?: string;
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string;
+    readonly detail?: string;
+};
+export type BranchRead = {
+    readonly kind: 'ok';
+    readonly branch: string;
+} | {
+    readonly kind: 'no-branch';
+    readonly detail?: string | undefined;
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string;
+    readonly detail?: string | undefined;
+};
+export type HeadRead = {
+    readonly kind: 'ok';
+    readonly commit: string;
+} | {
+    readonly kind: 'no-head';
+    readonly detail?: string;
+} | {
+    readonly kind: 'unknown';
+    readonly reason: string;
+    readonly detail?: string;
+};
+export interface GitReader {
+    origin(path: string): Promise<OriginRead>;
+    branch(path: string): Promise<BranchRead>;
+    head(path: string): Promise<HeadRead>;
+}

package/dist/contract/git.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/lib.d.ts

@@ -0,0 +1,4 @@
+import type { LibNeed } from './needs.js';
+export interface LibReader {
+    load<T = unknown>(need: LibNeed, entry: string): Promise<T>;
+}

package/dist/contract/lib.js

@@ -0,0 +1 @@
+export {};

package/dist/contract/needs.d.ts

@@ -0,0 +1,132 @@
+/**
+ * 模块要的一样东西的类别；v2 只认这四种，加种类在注册表里加，不改这份形状。
+ */
+export declare const NEED_KINDS: readonly ["bin", "extension", "lib", "env"];
+/**
+ * need 的类别。
+ */
+export type NeedKind = (typeof NEED_KINDS)[number];
+/**
+ * 一种外部来源；每一种都只说「去哪拿」，装不装、怎么装由宿主决定。
+ */
+export type SupplySource = {
+    readonly kind: 'npm';
+    readonly package?: string;
+    readonly registryEnv?: string;
+    readonly registryDefault?: string;
+} | {
+    readonly kind: 'git';
+    readonly url: string;
+    readonly ref?: string;
+} | {
+    readonly kind: 'local';
+    readonly path?: string;
+    readonly env?: string;
+};
+/**
+ * 协议认得的外部来源种类。
+ */
+export declare const SUPPLY_SOURCE_KINDS: readonly ["npm", "git", "local"];
+/**
+ * 外部来源的类别。
+ */
+export type SupplySourceKind = (typeof SUPPLY_SOURCE_KINDS)[number];
+/**
+ * 每条 need 都有的字段：为什么需要它、缺了算不算问题。
+ */
+export interface NeedCommon {
+    readonly kind: NeedKind;
+    readonly purpose: string;
+    readonly required?: boolean;
+    readonly id?: string;
+}
+/**
+ * 机器上要有一个可执行文件；探法是 `command -v` / `where`。
+ */
+export interface BinNeed extends NeedCommon {
+    readonly kind: 'bin';
+    readonly name: string;
+}
+/**
+ * 某个运行时上要有一个扩展（opencli 的插件就是这种），并且要提供这些命令。
+ */
+export interface ExtensionNeed extends NeedCommon {
+    readonly kind: 'extension';
+    readonly runtime: string;
+    readonly name: string;
+    readonly commands?: readonly string[];
+    readonly version?: string;
+    readonly sources?: readonly SupplySource[];
+}
+/**
+ * 要在隔离运行时里有一个共用依赖包。
+ */
+export interface LibNeed extends NeedCommon {
+    readonly kind: 'lib';
+    readonly name: string;
+    readonly version?: string;
+    readonly sources?: readonly SupplySource[];
+}
+/**
+ * 跑起来时要有这个环境变量；`secret` 为真时任何地方都不回显它的值。
+ */
+export interface EnvNeed extends NeedCommon {
+    readonly kind: 'env';
+    readonly name: string;
+    readonly secret?: boolean;
+}
+/**
+ * 模块声明的一条需要。
+ */
+export type Need = BinNeed | ExtensionNeed | LibNeed | EnvNeed;
+/**
+ * 一份 needs 校验结果：错误拒收，警告只提醒（未知可选字段就是警告）。
+ */
+export interface NeedsProblems {
+    readonly errors: readonly string[];
+    readonly warnings: readonly string[];
+}
+/**
+ * 协议认得的 need 字段；`x-` 前缀的字段留给第三方扩展，直接忽略。
+ */
+export declare const NEED_KEYS: readonly string[];
+/**
+ * 注册表把「怎么校验、怎么探、能不能代装」收在一处；加一种 kind 只在这里加一行。
+ */
+export interface NeedKindSpec {
+    readonly kind: NeedKind;
+    readonly probe: 'bin' | 'extension' | 'package' | 'env';
+    readonly sources: readonly SupplySourceKind[];
+    readonly validate: (raw: Readonly<Record<string, unknown>>, at: string) => readonly string[];
+}
+/**
+ * 这个字符串是不是协议认得的 need 类别。
+ * @param value 待判的值。
+ * @returns 是就收窄成 NeedKind。
+ */
+export declare function isKnownNeedKind(value: unknown): value is NeedKind;
+/**
+ * 一条 need 的稳定标识：作者写 `id` 就用它，否则 `kind:name`。
+ * @param need 一条 need。
+ * @returns 标识串。
+ */
+export declare function needIdOf(need: Need): string;
+/**
+ * 一张表说了算：每种 kind 的探法、可用来源与校验。
+ */
+export declare const NEED_KIND_SPECS: Readonly<Record<NeedKind, NeedKindSpec>>;
+/**
+ * 校验一条 need；未知类别是错误，未知字段是警告。
+ * @param label 报错时用的主语（模块包名）。
+ * @param raw 这一条 need 的原始值。
+ * @param index 它在 needs 里的下标。
+ * @returns 错误与警告。
+ */
+export declare function needProblemsOf(label: string, raw: unknown, index: number): NeedsProblems;
+/**
+ * 校验整张 needs 表（没写就是空表）。
+ * @param label 报错时用的主语。
+ * @param raw 声明里的 needs 原始值。
+ * @returns 错误与警告。
+ */
+export declare function needsProblemsOf(label: string, raw: unknown): NeedsProblems;

package/dist/contract/needs.js

@@ -0,0 +1,232 @@
+/**
+ * 模块要的一样东西的类别；v2 只认这四种，加种类在注册表里加，不改这份形状。
+ */
+export const NEED_KINDS = ['bin', 'extension', 'lib', 'env'];
+/**
+ * 协议认得的外部来源种类。
+ */
+export const SUPPLY_SOURCE_KINDS = ['npm', 'git', 'local'];
+/**
+ * 协议认得的 need 字段；`x-` 前缀的字段留给第三方扩展，直接忽略。
+ */
+export const NEED_KEYS = [
+    'kind',
+    'purpose',
+    'required',
+    'id',
+    'name',
+    'runtime',
+    'commands',
+    'version',
+    'sources',
+    'secret',
+];
+const SOURCE_KEYS = ['kind', 'package', 'registryEnv', 'registryDefault', 'url', 'ref', 'path', 'env'];
+const REGISTRY_PATTERN = /^(?:https?|file):\/\//;
+function text(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * 这个字符串是不是协议认得的 need 类别。
+ * @param value 待判的值。
+ * @returns 是就收窄成 NeedKind。
+ */
+export function isKnownNeedKind(value) {
+    return typeof value === 'string' && NEED_KINDS.includes(value);
+}
+/**
+ * 一条 need 的稳定标识：作者写 `id` 就用它，否则 `kind:name`。
+ * @param need 一条 need。
+ * @returns 标识串。
+ */
+export function needIdOf(need) {
+    return need.id === undefined || need.id.trim() === '' ? `${need.kind}:${need.name}` : need.id;
+}
+function sourceProblemsOf(raw, at) {
+    if (!isRecord(raw))
+        return [`${at} 要是对象`];
+    const kind = text(raw['kind']);
+    if (!SUPPLY_SOURCE_KINDS.includes(kind)) {
+        return [`${at}.kind 不认识 —— ${JSON.stringify(raw['kind'])}（只有 ${SUPPLY_SOURCE_KINDS.join(' / ')}）`];
+    }
+    const errors = [];
+    for (const key of Object.keys(raw)) {
+        if (SOURCE_KEYS.includes(key) || key.startsWith('x-'))
+            continue;
+        errors.push(`${at} 有不认识的字段 ${key}`);
+    }
+    if (kind === 'npm') {
+        if (raw['package'] !== undefined && text(raw['package']) === '')
+            errors.push(`${at}.package 是空串`);
+        if (raw['registryEnv'] !== undefined && text(raw['registryEnv']) === '') {
+            errors.push(`${at}.registryEnv 是空串`);
+        }
+        if (raw['registryDefault'] !== undefined && !REGISTRY_PATTERN.test(text(raw['registryDefault']))) {
+            errors.push(`${at}.registryDefault 要是 http(s):// 或 file:// 的源地址`);
+        }
+        return errors;
+    }
+    if (kind === 'git') {
+        if (text(raw['url']) === '')
+            errors.push(`${at}.url 没写`);
+        return errors;
+    }
+    if (text(raw['path']) === '' && text(raw['env']) === '') {
+        errors.push(`${at} 是 local，但 path 与 env 都没写`);
+    }
+    return errors;
+}
+function sourcesProblemsOf(raw, at, allowed) {
+    if (raw === undefined)
+        return [];
+    if (!Array.isArray(raw))
+        return [`${at}.sources 要是数组`];
+    if (raw.length === 0)
+        return [`${at}.sources 是空数组 —— 不代装就整条删掉`];
+    if (allowed.length === 0) {
+        return [`${at} 这种需要不支持 sources —— 它没有「从哪装」这回事`];
+    }
+    const errors = [];
+    raw.forEach((source, index) => {
+        const one = sourceProblemsOf(source, `${at}.sources[${index}]`);
+        errors.push(...one);
+        if (one.length === 0 && isRecord(source)) {
+            const kind = text(source['kind']);
+            if (!allowed.includes(kind)) {
+                errors.push(`${at}.sources[${index}].kind 是 ${kind}，这种需要只支持 ${allowed.join(' / ')}`);
+            }
+        }
+    });
+    return errors;
+}
+function commonProblemsOf(raw, at) {
+    const errors = [];
+    if (text(raw['purpose']) === '')
+        errors.push(`${at}.purpose 没写 —— 「为什么要它」是缺失文案的那半句`);
+    if (raw['required'] !== undefined && typeof raw['required'] !== 'boolean') {
+        errors.push(`${at}.required 要是布尔`);
+    }
+    if (raw['id'] !== undefined && text(raw['id']) === '')
+        errors.push(`${at}.id 是空串`);
+    return errors;
+}
+function perKindProblemsOf(kind, raw, at) {
+    const errors = [];
+    if (kind === 'bin' || kind === 'lib' || kind === 'env') {
+        if (text(raw['name']) === '')
+            errors.push(`${at}.name 没写`);
+    }
+    if (kind === 'extension') {
+        if (text(raw['runtime']) === '')
+            errors.push(`${at}.runtime 没写 —— 扩展属于哪个运行时（如 opencli）`);
+        if (text(raw['name']) === '')
+            errors.push(`${at}.name 没写`);
+        if (raw['commands'] !== undefined) {
+            if (!Array.isArray(raw['commands']))
+                errors.push(`${at}.commands 要是数组`);
+            else if (raw['commands'].some((one) => text(one) === ''))
+                errors.push(`${at}.commands 里有空字符串`);
+        }
+    }
+    if (kind === 'env' && raw['secret'] !== undefined && typeof raw['secret'] !== 'boolean') {
+        errors.push(`${at}.secret 要是布尔`);
+    }
+    return errors;
+}
+function validateKind(kind) {
+    return (raw, at) => perKindProblemsOf(kind, raw, at);
+}
+/**
+ * 一张表说了算：每种 kind 的探法、可用来源与校验。
+ */
+export const NEED_KIND_SPECS = Object.freeze({
+    bin: Object.freeze({
+        kind: 'bin',
+        probe: 'bin',
+        sources: Object.freeze([]),
+        validate: validateKind('bin'),
+    }),
+    extension: Object.freeze({
+        kind: 'extension',
+        probe: 'extension',
+        sources: Object.freeze(['npm', 'git', 'local']),
+        validate: validateKind('extension'),
+    }),
+    lib: Object.freeze({
+        kind: 'lib',
+        probe: 'package',
+        sources: Object.freeze(['npm']),
+        validate: validateKind('lib'),
+    }),
+    env: Object.freeze({
+        kind: 'env',
+        probe: 'env',
+        sources: Object.freeze([]),
+        validate: validateKind('env'),
+    }),
+});
+/**
+ * 校验一条 need；未知类别是错误，未知字段是警告。
+ * @param label 报错时用的主语（模块包名）。
+ * @param raw 这一条 need 的原始值。
+ * @param index 它在 needs 里的下标。
+ * @returns 错误与警告。
+ */
+export function needProblemsOf(label, raw, index) {
+    const at = `${label}.needs[${index}]`;
+    if (!isRecord(raw))
+        return { errors: [`${at} 要是对象`], warnings: [] };
+    const kind = text(raw['kind']);
+    if (!isKnownNeedKind(kind)) {
+        return {
+            errors: [
+                `${at}.kind 不认识 —— ${JSON.stringify(raw['kind'])}（v2 只认 ${NEED_KINDS.join(' / ')}；` +
+                    '要是模块用了更新的工作台才有的种类，升级工作台）',
+            ],
+            warnings: [],
+        };
+    }
+    const warnings = [];
+    for (const key of Object.keys(raw)) {
+        if (NEED_KEYS.includes(key) || key.startsWith('x-'))
+            continue;
+        warnings.push(`${at} 有不认识的字段 ${key}（宿主会忽略它）`);
+    }
+    const errors = [
+        ...commonProblemsOf(raw, at),
+        ...perKindProblemsOf(kind, raw, at),
+        ...sourcesProblemsOf(raw['sources'], at, NEED_KIND_SPECS[kind].sources),
+    ];
+    return { errors, warnings };
+}
+/**
+ * 校验整张 needs 表（没写就是空表）。
+ * @param label 报错时用的主语。
+ * @param raw 声明里的 needs 原始值。
+ * @returns 错误与警告。
+ */
+export function needsProblemsOf(label, raw) {
+    if (raw === undefined)
+        return { errors: [], warnings: [] };
+    if (!Array.isArray(raw))
+        return { errors: [`${label}.needs 要是数组`], warnings: [] };
+    const errors = [];
+    const warnings = [];
+    const seen = new Set();
+    raw.forEach((one, index) => {
+        const found = needProblemsOf(label, one, index);
+        errors.push(...found.errors);
+        warnings.push(...found.warnings);
+        if (found.errors.length > 0 || !isRecord(one))
+            return;
+        const kind = text(one['kind']);
+        const id = text(one['id']) === '' ? `${kind}:${text(one['name'])}` : text(one['id']);
+        if (seen.has(id))
+            errors.push(`${label}.needs 里 ${id} 重复了 —— 每条 need 的 id 要唯一`);
+        seen.add(id);
+    });
+    return { errors, warnings };
+}

package/dist/contract/plugin-source.d.ts

@@ -0,0 +1 @@
+export type ProvisionProblem = 'not-declared' | 'env-missing' | 'malformed';

package/dist/contract/plugin-source.js

@@ -0,0 +1 @@
+export {};