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

package/dist/{api → contract}/unit-declaration.js

@@ -1,13 +1,14 @@
+import { needsProblemsOf } from './needs.js';
 /**
  * 声明协议当前版本；模块清单的 dsh.workbench.apiVersion 要写这个整数。
  */
-export const WORKBENCH_API_VERSION = 1;
+export const WORKBENCH_API_VERSION = 2;
 /**
  * 外壳愿意认的协议版本；不在表里的模块当场被拒，不猜语义。
  */
 export const SUPPORTED_API_VERSIONS = [WORKBENCH_API_VERSION];
 /**
- * 协议认得的全部键；写了别的键不会被采纳（外壳静默忽略），所以字段名拼错不会有提示。
+ * 协议认得的全部键；写了别的键这份清单会被拒（`protocol` 判据与运行时同一套），拼错当场报出来。
  */
 export const DECLARATION_KEYS = [
     'apiVersion',
@@ -15,10 +16,10 @@ export const DECLARATION_KEYS = [
     'card',
     'tools',
     'host',
-    'env',
+    'needs',
 ];
 /**
- * 协议要求必写的键；env 不在其中（没有环境需要就不写）。
+ * 协议要求必写的键；needs 不在其中（没有环境需要就不写）。
  */
 export const DECLARATION_REQUIRED_KEYS = [
     'apiVersion',
@@ -61,20 +62,25 @@ export function declarationProblemsOf(subject, raw) {
     if (version === undefined) {
         return [
             `${subject}: dsh.workbench 没有 apiVersion —— 协议从 v${WORKBENCH_API_VERSION} 起，` +
-                `写 \`"apiVersion": ${WORKBENCH_API_VERSION}\`。缺它 = 外壳不认这个模块（ADR-0038 §2.3）`,
+                `写 \`"apiVersion": ${WORKBENCH_API_VERSION}\`。缺它 = 外壳不认这个模块`,
         ];
     }
     if (!Number.isInteger(version) || !SUPPORTED_API_VERSIONS.includes(version)) {
+        const hint = version === 1
+            ? ` —— v2 把 \`env\` 的三张表（command / plugins / libs）换成了 \`needs\`：` +
+                '把外部需要逐条写成 `{ kind, name, purpose, ... }`（kind 是 bin / extension / lib / env），' +
+                '再把 apiVersion 改成 2'
+            : '';
         return [
             `${subject}: dsh.workbench.apiVersion 是 ${JSON.stringify(version)}，这里只认 ` +
-                `${SUPPORTED_API_VERSIONS.join(' / ')}（要整数）`,
+                `${SUPPORTED_API_VERSIONS.join(' / ')}（要整数）${hint}`,
         ];
     }
     const problems = [];
     const unknown = outsideKeys(raw, DECLARATION_KEYS);
     if (unknown.length > 0) {
         problems.push(`${subject}: dsh.workbench 里有协议 v${WORKBENCH_API_VERSION} 不认识的键 ${listOf(unknown)} —— ` +
-            `只有 ${listOf(DECLARATION_KEYS)}。（拼错的键会被外壳**静默忽略**：那句声明等于没写）`);
+            `只有 ${listOf(DECLARATION_KEYS)}。（协议外的键会让这份清单被拒：那句声明等于没写）`);
     }
     for (const key of DECLARATION_REQUIRED_KEYS) {
         if (raw[key] === undefined) {
@@ -170,10 +176,6 @@ export function declarationProblemsOf(subject, raw) {
             }
         }
     }
-    if (raw.env !== undefined && !isRecord(raw.env)) {
-        problems.push(`${subject}: dsh.workbench.env 要是对象（command / plugins / libs）—— ` +
-            `语义由门禁的 env 判据查，这里只查形状`);
-    }
     return problems;
 }
 /**
@@ -185,8 +187,11 @@ export function declarationProblemsOf(subject, raw) {
 export function readDeclaration(subject, raw) {
     const problems = declarationProblemsOf(subject, raw);
     if (problems.length > 0)
-        return { problems };
+        return { problems, warnings: [] };
     const declaration = raw;
+    const needsRead = needsProblemsOf(subject, declaration.needs);
+    if (needsRead.errors.length > 0)
+        return { problems: needsRead.errors, warnings: needsRead.warnings };
     const card = declaration.card;
     return {
         declaration,
@@ -207,7 +212,8 @@ export function readDeclaration(subject, raw) {
                 inject: [...(declaration.host.inject ?? [])],
                 ...(declaration.host.optional === undefined ? {} : { optional: [...declaration.host.optional] }),
             },
-            ...(declaration.env === undefined ? {} : { env: declaration.env }),
+            ...(declaration.needs === undefined ? {} : { needs: declaration.needs }),
         },
+        warnings: needsRead.warnings,
     };
 }

package/dist/contract/unit.d.ts

@@ -0,0 +1,57 @@
+import type { ExtensionNeed, LibNeed, Need } from './needs.js';
+/**
+ * 一张卡片在清单里的静态声明（文案键加排序位）；默认显不显示由运行期面板配置定。
+ */
+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[];
+}
+/**
+ * 已装插件与源上最新版那一对，用来判该不该提示升级；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 needs?: readonly Need[];
+}
+/**
+ * 模块声明的全部环境需要（没写就是空表）。
+ * @param manifest 模块清单。
+ * @returns need 列表。
+ */
+export declare function needsOf(manifest: UnitManifest): readonly Need[];
+/**
+ * 宿主能代装的那些需要：只有写了 `sources` 的 extension / lib 算。
+ * @param manifest 模块清单。
+ * @returns 可代装的 need 列表。
+ */
+export declare function provisionableNeedsOf(manifest: UnitManifest): readonly (ExtensionNeed | LibNeed)[];
+/**
+ * 市场门槛要看的那些需要：声明了 extension / lib 就算（不要求写了来源）。
+ * @param manifest 模块清单。
+ * @returns extension / lib 的 need 列表。
+ */
+export declare function supplyNeedsOf(manifest: UnitManifest): readonly (ExtensionNeed | LibNeed)[];

package/dist/contract/unit.js

@@ -0,0 +1,24 @@
+/**
+ * 模块声明的全部环境需要（没写就是空表）。
+ * @param manifest 模块清单。
+ * @returns need 列表。
+ */
+export function needsOf(manifest) {
+    return manifest.needs ?? [];
+}
+/**
+ * 宿主能代装的那些需要：只有写了 `sources` 的 extension / lib 算。
+ * @param manifest 模块清单。
+ * @returns 可代装的 need 列表。
+ */
+export function provisionableNeedsOf(manifest) {
+    return needsOf(manifest).filter((need) => (need.kind === 'extension' || need.kind === 'lib') && (need.sources ?? []).length > 0);
+}
+/**
+ * 市场门槛要看的那些需要：声明了 extension / lib 就算（不要求写了来源）。
+ * @param manifest 模块清单。
+ * @returns extension / lib 的 need 列表。
+ */
+export function supplyNeedsOf(manifest) {
+    return needsOf(manifest).filter((need) => need.kind === 'extension' || need.kind === 'lib');
+}

package/dist/contract/workbench-contract.d.ts

@@ -0,0 +1,15 @@
+import type { NeedState } from '../contract/unit-capability.js';
+/**
+ * 供给动作的那几档（装 / 升 / 卸，模块、共用依赖与插件各一套）；写口按它分派。
+ */
+export type ProvisionAction = 'install' | 'update' | 'uninstall' | 'update-dependency' | 'install-bundle' | 'install-version' | 'update-bundle' | 'remove-bundle' | 'cancel-install' | 'update-plugin' | 'uninstall-plugin' | 'update-workbench';
+/**
+ * 宿主对「这个单元现在能不能用」的那份读数：状态汇总加逐条 need 的细节。
+ */
+export interface CapabilityPayload {
+    readonly unit: string;
+    readonly status: 'ok' | 'degraded' | 'missing' | 'outdated' | 'unchecked' | 'unsupported' | 'failed';
+    readonly needs: readonly NeedState[];
+    readonly detail?: string;
+    readonly released?: boolean;
+}

package/dist/contract/workbench-contract.js

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

package/dist/host/adapter-set.d.ts

@@ -0,0 +1,26 @@
+import type { DshHostContext } from '../api/dsh.js';
+import { type AdapterSet, type CoreAdapterSet } from './adapters.js';
+export interface WorkbenchConfig {
+    readonly adapterSet?: string;
+}
+export type AdapterSetFailure = 'not-configured' | 'no-profile' | 'malformed' | 'not-resolvable' | 'import-failed' | 'bad-export' | 'factory-failed' | 'incompatible-version' | 'missing-member';
+export type AdapterSetLoad = {
+    readonly ok: true;
+    readonly spec: string;
+    readonly set: CoreAdapterSet;
+} | {
+    readonly ok: false;
+    readonly spec?: string;
+    readonly failure: AdapterSetFailure;
+    readonly detail: string;
+    readonly cause?: unknown;
+};
+export declare function validateAdapterSet(value: unknown, spec: string): AdapterSetLoad;
+export declare function loadAdapterSet(ctx: DshHostContext, spec: string | undefined): Promise<AdapterSetLoad>;
+export declare function withDefaultAdapterSet(defaults: AdapterSet, loaded: AdapterSetLoad): AdapterSet;
+export declare function resolveAdapterSet(ctx: DshHostContext, spec: string | undefined, makeDefaults: () => Promise<AdapterSet>): Promise<{
+    readonly set: AdapterSet;
+    readonly load: AdapterSetLoad;
+    readonly usedDefaults: boolean;
+}>;
+export type { AdapterSet, CoreAdapterSet };

package/dist/host/adapter-set.js

@@ -0,0 +1,243 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ADAPTER_SET_API_VERSION, SUPPORTED_ADAPTER_API_VERSIONS, } from './adapters.js';
+import { isPackageName } from './spec.js';
+const CORE_MEMBERS = ['data', 'supply', 'profile', 'probe'];
+const CORE_METHODS = [
+    ['data', 'read'],
+    ['data', 'request'],
+    ['data', 'requestMany'],
+    ['data', 'submit'],
+    ['supply', 'resolvePluginSource'],
+    ['supply', 'libInstallCommand'],
+    ['supply', 'pluginInstallPlan'],
+    ['supply', 'latestVersion'],
+    ['supply', 'missingReleaseParts'],
+    ['supply', 'probeRelease'],
+    ['supply', 'splitNpmSpec'],
+    ['profile', 'dirOf'],
+    ['profile', 'dshPlugins'],
+    ['profile', 'selfUpdateView'],
+    ['probe', 'probeUnits'],
+    ['probe', 'registerPreflight'],
+    ['probe', 'declaredPluginCommands'],
+];
+const FULL_MEMBERS = ['modules', 'runtime', 'plugins', 'actions'];
+const FULL_METHODS = [
+    ['modules', 'isolatedHome'],
+    ['modules', 'cliCatalogPath'],
+    ['modules', 'vendorPluginsDir'],
+    ['modules', 'opencliInstallCommand'],
+    ['modules', 'profileDirOf'],
+    ['modules', 'profileModules'],
+    ['modules', 'readInstalledModule'],
+    ['modules', 'readProfilePackage'],
+    ['modules', 'readBundleManager'],
+    ['modules', 'createRegistryNotebook'],
+    ['modules', 'declarationGaps'],
+    ['modules', 'moduleDeclarationOf'],
+    ['modules', 'registryDeclarationOf'],
+    ['modules', 'pathDeclarationOf'],
+    ['modules', 'declarationRefusalOf'],
+    ['modules', 'refusalReason'],
+    ['modules', 'packageRouteOf'],
+    ['modules', 'isNewerVersion'],
+    ['modules', 'startSelfUpdate'],
+    ['runtime', 'packageRoot'],
+    ['runtime', 'opencliCommand'],
+    ['runtime', 'seed'],
+    ['runtime', 'warnUnwritableRoot'],
+    ['plugins', 'declarationLookup'],
+    ['plugins', 'createUnits'],
+    ['actions', 'configSyncHandler'],
+    ['actions', 'profileCreateHandler'],
+    ['actions', 'configSyncAction'],
+    ['actions', 'profileCreateAction'],
+];
+function methodOf(value, member, method) {
+    const part = value[member];
+    if (typeof part !== 'object' || part === null)
+        return undefined;
+    return part[method];
+}
+function failure(failureKind, detail, spec, cause) {
+    return {
+        ok: false,
+        ...(spec === undefined ? {} : { spec }),
+        failure: failureKind,
+        detail,
+        ...(cause === undefined ? {} : { cause }),
+    };
+}
+function profileDirOf(ctx) {
+    const profile = ctx.get('profileContext');
+    const dir = typeof profile?.dir === 'string' ? profile.dir.trim() : '';
+    return dir === '' ? null : dir;
+}
+function packageDirOf(spec, from) {
+    let dir = from;
+    for (;;) {
+        const candidate = join(dir, 'node_modules', spec);
+        if (existsSync(join(candidate, 'package.json')))
+            return candidate;
+        const up = dirname(dir);
+        if (up === dir)
+            return undefined;
+        dir = up;
+    }
+}
+function entryOf(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const record = value;
+    for (const key of ['import', 'node', 'module', 'default', 'require']) {
+        const found = entryOf(record[key]);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+function exportsEntryOf(value) {
+    if (typeof value !== 'object' || value === null)
+        return entryOf(value);
+    const record = value;
+    return '.' in record ? entryOf(record['.']) : entryOf(record);
+}
+function esmEntryUrl(spec, profileDir) {
+    const dir = packageDirOf(spec, profileDir);
+    if (dir === undefined)
+        return undefined;
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    const main = typeof pkg['main'] === 'string' ? pkg['main'] : undefined;
+    const module = typeof pkg['module'] === 'string' ? pkg['module'] : undefined;
+    const entry = exportsEntryOf(pkg['exports']) ?? module ?? main ?? 'index.js';
+    const file = join(dir, entry);
+    return existsSync(file) ? pathToFileURL(file).href : undefined;
+}
+function resolveFromProfile(spec, profileDir) {
+    const esm = esmEntryUrl(spec, profileDir);
+    if (esm !== undefined)
+        return esm;
+    const parent = pathToFileURL(join(profileDir, 'package.json')).href;
+    try {
+        return pathToFileURL(createRequire(parent).resolve(spec)).href;
+    }
+    catch {
+        return undefined;
+    }
+}
+function versionOf(value) {
+    const version = value['apiVersion'];
+    return typeof version === 'number' && Number.isInteger(version) ? version : undefined;
+}
+export function validateAdapterSet(value, spec) {
+    if (typeof value !== 'object' || value === null) {
+        return failure('missing-member', `${spec} 的 createAdapterSet(ctx) 没回一个对象`, spec);
+    }
+    const record = value;
+    const version = versionOf(record);
+    if (version === undefined || !SUPPORTED_ADAPTER_API_VERSIONS.includes(version)) {
+        return failure('incompatible-version', `${spec} 的适配器协议版本是 ${String(record['apiVersion'])}，工作台只认 v${ADAPTER_SET_API_VERSION}`, spec);
+    }
+    const missing = CORE_MEMBERS.filter((member) => record[member] === undefined || record[member] === null);
+    for (const [member, method] of CORE_METHODS) {
+        if (typeof methodOf(record, member, method) !== 'function')
+            missing.push(`${member}.${method}`);
+    }
+    if (typeof record['id'] !== 'string' || record['id'].trim() === '')
+        missing.push('id');
+    if (typeof record['version'] !== 'string' || record['version'].trim() === '')
+        missing.push('version');
+    if (FULL_MEMBERS.some((member) => record[member] !== undefined)) {
+        for (const member of FULL_MEMBERS) {
+            if (typeof record[member] !== 'object' || record[member] === null)
+                missing.push(member);
+        }
+        for (const [member, method] of FULL_METHODS) {
+            if (typeof methodOf(record, member, method) !== 'function')
+                missing.push(`${member}.${method}`);
+        }
+    }
+    if (missing.length > 0) {
+        return failure('missing-member', `${spec} 少了 ${missing.join(' / ')}`, spec);
+    }
+    return { ok: true, spec, set: record };
+}
+export async function loadAdapterSet(ctx, spec) {
+    const wanted = typeof spec === 'string' ? spec.trim() : spec === undefined ? '' : String(spec).trim();
+    if (wanted === '')
+        return failure('not-configured', '没有配置 adapterSet');
+    const profileDir = profileDirOf(ctx);
+    if (profileDir === null)
+        return failure('no-profile', '找不到 profile 目录，无法从 profile 解析适配器集合', wanted);
+    if (!isPackageName(wanted)) {
+        return failure('malformed', `适配器集合要写包名（如 @acme/adapters-set），收到 ${JSON.stringify(wanted)}`, wanted);
+    }
+    const url = resolveFromProfile(wanted, profileDir);
+    if (url === undefined) {
+        return failure('not-resolvable', `在 profile 里解析不到 ${wanted}，先把它装进这个 profile`, wanted);
+    }
+    let mod;
+    try {
+        mod = (await import(url));
+    }
+    catch (error) {
+        return failure('import-failed', `${wanted} 的入口没加载成：${String(error)}`, wanted, error);
+    }
+    const factory = mod['createAdapterSet'] ?? mod['default'];
+    if (typeof factory !== 'function') {
+        return failure('bad-export', `${wanted} 没导出 createAdapterSet(ctx)，导出键：${Object.keys(mod).join(', ')}`, wanted);
+    }
+    let value;
+    try {
+        const raw = await factory(ctx);
+        if (typeof raw !== 'object' || raw === null) {
+            return failure('missing-member', `${wanted} 的 createAdapterSet(ctx) 没回一个对象`, wanted);
+        }
+        value = raw;
+    }
+    catch (error) {
+        return failure('factory-failed', `${wanted} 的 createAdapterSet(ctx) 抛了：${String(error)}`, wanted, error);
+    }
+    return validateAdapterSet(value, wanted);
+}
+export function withDefaultAdapterSet(defaults, loaded) {
+    if (!loaded.ok)
+        return defaults;
+    const set = loaded.set;
+    return {
+        apiVersion: set.apiVersion ?? defaults.apiVersion,
+        id: set.id ?? defaults.id,
+        version: set.version ?? defaults.version,
+        data: set.data ?? defaults.data,
+        supply: set.supply ?? defaults.supply,
+        modules: set.modules ?? defaults.modules,
+        profile: set.profile ?? defaults.profile,
+        probe: set.probe ?? defaults.probe,
+        runtime: set.runtime ?? defaults.runtime,
+        plugins: set.plugins ?? defaults.plugins,
+        actions: set.actions ?? defaults.actions,
+    };
+}
+function isFullAdapterSet(value) {
+    const candidate = value;
+    return ['modules', 'runtime', 'plugins', 'actions'].every((member) => typeof candidate[member] === 'object' && candidate[member] !== null);
+}
+export async function resolveAdapterSet(ctx, spec, makeDefaults) {
+    const load = await loadAdapterSet(ctx, spec);
+    if (load.ok && isFullAdapterSet(load.set)) {
+        return { set: load.set, load, usedDefaults: false };
+    }
+    const defaults = await makeDefaults();
+    return { set: withDefaultAdapterSet(defaults, load), load, usedDefaults: true };
+}

package/dist/host/adapter-types.d.ts

@@ -0,0 +1,79 @@
+import type { BundleCancellation, BundleChange, BundleInspection, BundleInstallRequest, BundleRegistries, BundleRegistry } from '../contract/protocol/bundle-install.js';
+export type InstalledModule = {
+    readonly kind: 'module';
+    readonly pkg: string;
+    readonly unit: string;
+    readonly version: string;
+    readonly registry?: string;
+    readonly local?: boolean;
+} | {
+    readonly kind: 'not-module';
+    readonly pkg: string;
+} | {
+    readonly kind: 'unknown';
+    readonly pkg: string;
+};
+export interface ProfileModule {
+    readonly pkg: string;
+    readonly unit: string;
+    readonly version: string;
+    readonly registry?: string;
+    readonly local?: boolean;
+}
+export interface ProfilePackage {
+    readonly pkg: string;
+    readonly version: string;
+    readonly registry?: string;
+    readonly local?: boolean;
+}
+export interface BundleManager {
+    registries(): Promise<BundleRegistries | null>;
+    inspect(spec: string, registry?: BundleRegistry): Promise<BundleInspection | null>;
+    install(request: BundleInstallRequest): Promise<BundleChange | null>;
+    remove(name: string): Promise<BundleChange | null>;
+    setEnabled?(name: string, enabled: boolean): Promise<BundleChange | null>;
+    cancel(requestId: string): Promise<BundleCancellation | null>;
+}
+export interface RegistryEntry {
+    readonly scope: string;
+    readonly registry: string;
+}
+export interface RegistryNotebook {
+    sources(): readonly RegistryEntry[];
+    remember(entries: readonly RegistryEntry[]): readonly string[];
+}
+export interface SelfUpdatePaths {
+    readonly dir: string;
+    readonly script: string;
+    readonly marker: string;
+    readonly log: string;
+}
+export interface SelfUpdateRequest {
+    readonly dshHome: string;
+    readonly profile: string;
+    readonly pkg: string;
+    readonly from: string;
+    readonly to: string;
+    readonly pinned: boolean;
+}
+export interface SelfUpdateStart {
+    readonly started: boolean;
+    readonly paths: SelfUpdatePaths;
+    readonly forward: string;
+}
+export interface OpencliResolution {
+    readonly command: string;
+    readonly source: 'env' | 'isolated' | 'path';
+    readonly isolated: string | null;
+}
+export declare function scopeOf(pkg: string): string | null;
+export declare function normalizeRegistry(url: string): string;
+export declare function sameRegistry(a: string | null | undefined, b: string | null | undefined): boolean;
+export declare function registryFailure(change: {
+    application?: string;
+    packageResult?: {
+        kind?: string;
+        output?: string;
+    };
+    errorDetail?: string;
+}): boolean;

package/dist/host/adapter-types.js

@@ -0,0 +1,23 @@
+export function scopeOf(pkg) {
+    const slash = pkg.indexOf('/');
+    return pkg.startsWith('@') && slash > 1 ? pkg.slice(0, slash) : null;
+}
+export function normalizeRegistry(url) {
+    const trimmed = url.trim();
+    return trimmed.endsWith('/') ? trimmed : `${trimmed}/`;
+}
+export function sameRegistry(a, b) {
+    if (a === null || a === undefined || b === null || b === undefined)
+        return false;
+    if (a.trim() === '' || b.trim() === '')
+        return false;
+    return normalizeRegistry(a) === normalizeRegistry(b);
+}
+export function registryFailure(change) {
+    if (change.application !== 'failed')
+        return false;
+    if (change.packageResult?.kind === 'not-found')
+        return true;
+    const output = change.packageResult?.output ?? change.errorDetail ?? '';
+    return /ERR_PNPM_[A-Z_]*FETCH/.test(output);
+}

package/dist/host/adapters.d.ts

@@ -0,0 +1,22 @@
+import type { DshHostContext } from '../api/dsh.js';
+import type { DataReader } from '../contract/data.js';
+import type { EnvSupplyPort, HostActions, ModulePort, PluginSurface, ProbePort, ProfilePort, RuntimePort } from './port-types.js';
+export declare const WORKBENCH_ADAPTERS = "workbenchAdapters";
+export declare const ADAPTER_SET_API_VERSION = 1;
+export declare const SUPPORTED_ADAPTER_API_VERSIONS: readonly number[];
+export interface AdapterSet {
+    readonly apiVersion: number;
+    readonly id: string;
+    readonly version: string;
+    readonly data: DataReader;
+    readonly supply: EnvSupplyPort;
+    readonly modules: ModulePort;
+    readonly profile: ProfilePort;
+    readonly probe: ProbePort;
+    readonly runtime: RuntimePort;
+    readonly plugins: PluginSurface;
+    readonly actions: HostActions;
+}
+export type CoreAdapterSet = Pick<AdapterSet, 'apiVersion' | 'id' | 'version' | 'data' | 'supply' | 'profile' | 'probe'>;
+export type WorkbenchAdapters = AdapterSet;
+export declare function adaptersOf(ctx: DshHostContext): AdapterSet;

package/dist/host/adapters.js

@@ -0,0 +1,9 @@
+export const WORKBENCH_ADAPTERS = 'workbenchAdapters';
+export const ADAPTER_SET_API_VERSION = 1;
+export const SUPPORTED_ADAPTER_API_VERSIONS = [ADAPTER_SET_API_VERSION];
+export function adaptersOf(ctx) {
+    const adapters = ctx.get(WORKBENCH_ADAPTERS, false);
+    if (adapters !== undefined)
+        return adapters;
+    throw new Error('workbenchAdapters 未提供');
+}

package/dist/host/browser.d.ts

@@ -0,0 +1,3 @@
+export declare const BROWSER_SCREEN_SESSION = "workbench";
+export declare const BROWSER_READ_SESSION = "workbench-read";
+export declare const BROWSER_RECORD_SESSION = "workbench-rec";

package/dist/host/browser.js

@@ -0,0 +1,3 @@
+export const BROWSER_SCREEN_SESSION = 'workbench';
+export const BROWSER_READ_SESSION = 'workbench-read';
+export const BROWSER_RECORD_SESSION = 'workbench-rec';

package/dist/host/changelog.d.ts

@@ -0,0 +1,21 @@
+export declare const CHANGELOG_FILE = "CHANGELOG.md";
+export declare const CHANGELOG_KINDS: readonly ["added", "changed", "fixed", "removed", "security", "deprecated"];
+export type ChangelogKind = (typeof CHANGELOG_KINDS)[number];
+export interface ChangelogSection {
+    readonly version: string;
+    readonly body: string;
+}
+export interface ChangelogEntryOptions {
+    readonly version: string;
+    readonly kind?: ChangelogKind | undefined;
+    readonly note: string;
+    readonly date?: string | undefined;
+}
+export declare function changelogVersion(value: string): string;
+export declare function changelogDate(now?: Date): string;
+export declare function normalizeChangelogText(text: string): string;
+export declare function changelogSkeleton(): string;
+export declare function parseChangelog(text: string): readonly ChangelogSection[];
+export declare function changelogSectionOf(text: string, version: string): string | undefined;
+export declare function changelogHasEntry(text: string, version: string): boolean;
+export declare function appendChangelogEntry(text: string, options: ChangelogEntryOptions): string;