@jingyi0605/codingns4dsh 0.1.0

package/data/build/dist/client/workspace-session-logo-dom.js

@@ -0,0 +1,128 @@
+import { providerVisual } from './provider-icons.js';
+import { sessionAdapterId, subscribeSessionAdapters } from './session-adapter-cache.js';
+import { resolveDshSessionId } from './workspace-session-fiber.js';
+export const WORKSPACE_SESSION_ROW_SELECTOR = '[role="treeitem"]';
+export const WORKSPACE_SESSION_LOGO_ATTRIBUTE = 'data-codingns-session-logo';
+/**
+ * 为 DSH 0.1.6-alpha.2 会话行安装兼容注入器。
+ *
+ * 该版本没有 leading Slot，也没有把 sessionId 写进 DOM。这里仅读取 React
+ * Fiber 上 `node.id`/`result.id` 两个已验证字段；任何不匹配都直接跳过。
+ */
+export function startWorkspaceSessionLogoDom(options = {}) {
+    const dom = options.document ?? (typeof document === 'undefined' ? undefined : document);
+    const Observer = options.MutationObserver
+        ?? (typeof MutationObserver === 'undefined' ? undefined : MutationObserver);
+    // SessionStore 只记录显式选择；没有外部绑定时，DSH Registry 的权威默认值就是 dsh。
+    const adapterIdForSession = options.adapterIdForSession
+        ?? ((sessionId) => sessionAdapterId(sessionId) ?? 'dsh');
+    const visualForAdapter = options.visualForAdapter ?? providerVisual;
+    let disposed = false;
+    let scanQueued = false;
+    const scan = () => {
+        if (disposed || dom === undefined)
+            return;
+        // DSH 原生工作区会话行和搜索结果都声明为 treeitem。只读这个稳定语义
+        // 标记，禁止把对话区里的按钮、复制按钮或适配器选择按钮当成会话行。
+        const rows = dom.querySelectorAll(WORKSPACE_SESSION_ROW_SELECTOR);
+        for (const row of rows) {
+            const sessionId = resolveDshSessionId(row);
+            if (sessionId === undefined)
+                continue;
+            upsertSessionLogo(row, sessionId, visualForAdapter(adapterIdForSession(sessionId)), dom);
+        }
+    };
+    const scheduleScan = () => {
+        if (disposed || scanQueued)
+            return;
+        scanQueued = true;
+        queueMicrotask(() => {
+            scanQueued = false;
+            scan();
+        });
+    };
+    const observer = dom === undefined || Observer === undefined
+        ? undefined
+        : new Observer(scheduleScan);
+    if (observer !== undefined && dom !== undefined) {
+        observer.observe(dom.documentElement, { childList: true, subtree: true });
+    }
+    const unsubscribe = subscribeSessionAdapters(scheduleScan);
+    scan();
+    return {
+        refresh: scheduleScan,
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            observer?.disconnect();
+            unsubscribe();
+            if (dom !== undefined)
+                removeWorkspaceSessionLogos(dom);
+        },
+    };
+}
+/** 移除当前文档中全部由本模块插入的节点。 */
+export function removeWorkspaceSessionLogos(dom) {
+    for (const node of dom.querySelectorAll(`[${WORKSPACE_SESSION_LOGO_ATTRIBUTE}]`))
+        node.remove();
+}
+function upsertSessionLogo(row, sessionId, visual, dom) {
+    const existing = row.querySelector(`[${WORKSPACE_SESSION_LOGO_ATTRIBUTE}]`);
+    const adapterKey = visual.adapterId ?? '';
+    if (existing?.dataset.codingnsSessionId === sessionId
+        && existing.dataset.codingnsAdapterId === adapterKey)
+        return;
+    existing?.remove();
+    const logo = createLogoElement(dom, sessionId, visual);
+    const parent = row.tagName === 'BUTTON' && row.firstElementChild !== null
+        ? row.firstElementChild
+        : row;
+    parent.insertBefore(logo, parent.firstChild);
+}
+function createLogoElement(dom, sessionId, visual) {
+    const container = dom.createElement('span');
+    container.setAttribute(WORKSPACE_SESSION_LOGO_ATTRIBUTE, '');
+    container.dataset.codingnsSessionId = sessionId;
+    container.dataset.codingnsAdapterId = visual.adapterId ?? '';
+    container.title = visual.displayName;
+    container.setAttribute('aria-hidden', 'true');
+    Object.assign(container.style, {
+        width: '16px',
+        height: '16px',
+        flex: '0 0 16px',
+        display: 'inline-flex',
+        alignItems: 'center',
+        justifyContent: 'center',
+        marginRight: '4px',
+        pointerEvents: 'none',
+        overflow: 'hidden',
+    });
+    if (visual.iconUrl !== undefined) {
+        const image = dom.createElement('img');
+        image.src = visual.iconUrl;
+        image.alt = '';
+        image.setAttribute('aria-hidden', 'true');
+        Object.assign(image.style, {
+            width: '16px',
+            height: '16px',
+            display: 'block',
+            objectFit: 'contain',
+        });
+        container.appendChild(image);
+        return container;
+    }
+    container.textContent = '?';
+    Object.assign(container.style, {
+        boxSizing: 'border-box',
+        border: '1px solid var(--dsw-alias-border-l2, currentColor)',
+        borderRadius: '4px',
+        color: 'var(--dsw-alias-label-tertiary, currentColor)',
+        fontSize: '10px',
+        fontWeight: '600',
+        lineHeight: '14px',
+    });
+    return container;
+}
+export { resolveDshSessionId } from './workspace-session-fiber.js';
+//# sourceMappingURL=workspace-session-logo-dom.js.map

package/data/build/dist/features/index.d.ts

@@ -0,0 +1,3 @@
+export { FeatureRegistry, FeatureRegistryError, FeatureResourceScopeImpl, type FeatureRegistryErrorCode, type FeatureSnapshot, } from './registry.js';
+export type { FeatureContext, FeatureDescriptor, FeatureDisposer, FeatureModule, FeatureResourceScope, FeatureRuntime, FeatureState, FeatureUiDescriptor, } from '../shared/contracts/feature.js';
+//# sourceMappingURL=index.d.ts.map

package/data/build/dist/features/index.js

@@ -0,0 +1,2 @@
+export { FeatureRegistry, FeatureRegistryError, FeatureResourceScopeImpl, } from './registry.js';
+//# sourceMappingURL=index.js.map

package/data/build/dist/features/registry.d.ts

@@ -0,0 +1,74 @@
+import type { FeatureDescriptor, FeatureDisposer, FeatureModule, FeatureResourceScope, FeatureState } from '../shared/contracts/feature.js';
+export type FeatureRegistryErrorCode = 'FEATURE_INVALID_DESCRIPTOR' | 'FEATURE_ALREADY_REGISTERED' | 'FEATURE_NOT_FOUND' | 'FEATURE_DEPENDENCY_MISSING' | 'FEATURE_DEPENDENCY_CYCLE' | 'FEATURE_START_FAILED' | 'FEATURE_DISPOSE_FAILED' | 'FEATURE_STATE_INVALID';
+export declare class FeatureRegistryError extends Error {
+    readonly code: FeatureRegistryErrorCode;
+    readonly featureName: string | null;
+    constructor(code: FeatureRegistryErrorCode, message: string, featureName?: string | null, options?: ErrorOptions);
+}
+export interface FeatureSnapshot {
+    name: string;
+    version: string;
+    state: FeatureState;
+    runtime: FeatureDescriptor['runtime'];
+    dependencies: readonly string[];
+    reason: string | null;
+}
+/**
+ * 管理功能模块的依赖、状态和资源所有权。
+ *
+ * 注册表本身不创建计时器、socket 或进程；所有资源必须通过 context.resources
+ * 登记，卸载时由注册表统一按逆序释放。它不感知界面：设置页需要的标题、说明和
+ * 排序放在 descriptor.ui 中由宿主读取，因此新增模块不需要修改注册表。
+ */
+export declare class FeatureResourceScopeImpl implements FeatureResourceScope {
+    private readonly disposers;
+    private isDisposed;
+    get disposed(): boolean;
+    add(disposer: FeatureDisposer): void;
+    dispose(): Promise<void>;
+}
+/**
+ * 模块注册表：负责依赖排序、状态迁移、并发串行化和资源释放。
+ *
+ * @typeParam S - 注入给每个模块的宿主服务集合。
+ * @typeParam M - 注册的模块类型；宿主可用它携带额外模块契约（例如设置面板）。
+ */
+export declare class FeatureRegistry<S = unknown, M extends FeatureModule<S> = FeatureModule<S>> {
+    private readonly services;
+    private readonly records;
+    private readonly operations;
+    /** @param services - 每个模块在 start 时通过 context.services 取用的服务集合。 */
+    constructor(services: S);
+    register(module: M): void;
+    registerMany(modules: readonly M[]): void;
+    has(name: string): boolean;
+    getState(name: string): FeatureState;
+    getSnapshot(name: string): FeatureSnapshot;
+    list(): FeatureSnapshot[];
+    /** 按注册顺序返回模块本体，供宿主渲染设置页或查询模块能力。 */
+    modules(): readonly M[];
+    /** 返回单个模块本体；未注册时抛出 FEATURE_NOT_FOUND。 */
+    getModule(name: string): M;
+    /** 按注册顺序返回描述符，宿主用它计算期望启用集合。 */
+    descriptors(): readonly FeatureDescriptor[];
+    validate(): void;
+    start(name: string): Promise<void>;
+    /**
+     * 把模块状态对齐到期望启用集合。
+     *
+     * 期望启用的模块连同它们的依赖会被启动，其余已启用模块会被停用。依赖会被
+     * 自动纳入期望集合，避免「子模块要启用、父模块却被停用」互相拆台。
+     * 并发调用按模块串行队列排队，最终状态由最后一次调用决定。
+     */
+    reconcile(enabledNames: readonly string[]): Promise<void>;
+    drain(name: string): Promise<void>;
+    dispose(name: string): Promise<void>;
+    disable(name: string): Promise<void>;
+    /** 把期望集合补齐为含依赖的闭包，避免依赖在停用阶段被误停。 */
+    private resolveDesired;
+    private startInternal;
+    private activeDependents;
+    private getRecord;
+    private enqueue;
+}
+//# sourceMappingURL=registry.d.ts.map

package/data/build/dist/features/registry.js

@@ -0,0 +1,382 @@
+export class FeatureRegistryError extends Error {
+    code;
+    featureName;
+    constructor(code, message, featureName = null, options) {
+        super(message, options);
+        this.name = 'FeatureRegistryError';
+        this.code = code;
+        this.featureName = featureName;
+    }
+}
+/**
+ * 管理功能模块的依赖、状态和资源所有权。
+ *
+ * 注册表本身不创建计时器、socket 或进程；所有资源必须通过 context.resources
+ * 登记，卸载时由注册表统一按逆序释放。它不感知界面：设置页需要的标题、说明和
+ * 排序放在 descriptor.ui 中由宿主读取，因此新增模块不需要修改注册表。
+ */
+export class FeatureResourceScopeImpl {
+    disposers = [];
+    isDisposed = false;
+    get disposed() {
+        return this.isDisposed;
+    }
+    add(disposer) {
+        if (typeof disposer !== 'function') {
+            throw new TypeError('Feature disposer must be a function');
+        }
+        if (this.isDisposed) {
+            throw new Error('Feature resource scope is already disposed');
+        }
+        this.disposers.push(disposer);
+    }
+    async dispose() {
+        if (this.isDisposed)
+            return;
+        this.isDisposed = true;
+        const errors = [];
+        for (let index = this.disposers.length - 1; index >= 0; index -= 1) {
+            try {
+                await this.disposers[index]();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        this.disposers.length = 0;
+        if (errors.length > 0) {
+            throw new AggregateError(errors, 'One or more feature resources failed to dispose');
+        }
+    }
+}
+/**
+ * 模块注册表：负责依赖排序、状态迁移、并发串行化和资源释放。
+ *
+ * @typeParam S - 注入给每个模块的宿主服务集合。
+ * @typeParam M - 注册的模块类型；宿主可用它携带额外模块契约（例如设置面板）。
+ */
+export class FeatureRegistry {
+    services;
+    records = new Map();
+    operations = new Map();
+    /** @param services - 每个模块在 start 时通过 context.services 取用的服务集合。 */
+    constructor(services) {
+        this.services = services;
+    }
+    register(module) {
+        validateDescriptor(module?.descriptor);
+        const name = module.descriptor.name;
+        if (this.records.has(name)) {
+            throw new FeatureRegistryError('FEATURE_ALREADY_REGISTERED', `Feature already registered: ${name}`, name);
+        }
+        const resources = new FeatureResourceScopeImpl();
+        this.records.set(name, {
+            module,
+            state: 'disabled',
+            reason: null,
+            resources,
+            context: { descriptor: module.descriptor, resources, services: this.services },
+        });
+    }
+    registerMany(modules) {
+        for (const module of modules)
+            this.register(module);
+    }
+    has(name) {
+        return this.records.has(name);
+    }
+    getState(name) {
+        return this.getRecord(name).state;
+    }
+    getSnapshot(name) {
+        return snapshot(this.getRecord(name));
+    }
+    list() {
+        return [...this.records.values()].map(snapshot);
+    }
+    /** 按注册顺序返回模块本体，供宿主渲染设置页或查询模块能力。 */
+    modules() {
+        return [...this.records.values()].map((record) => record.module);
+    }
+    /** 返回单个模块本体；未注册时抛出 FEATURE_NOT_FOUND。 */
+    getModule(name) {
+        return this.getRecord(name).module;
+    }
+    /** 按注册顺序返回描述符，宿主用它计算期望启用集合。 */
+    descriptors() {
+        return [...this.records.values()].map((record) => record.module.descriptor);
+    }
+    validate() {
+        for (const record of this.records.values()) {
+            for (const dependency of record.module.descriptor.dependencies) {
+                if (!this.records.has(dependency)) {
+                    throw new FeatureRegistryError('FEATURE_DEPENDENCY_MISSING', `Feature ${record.module.descriptor.name} depends on missing feature ${dependency}`, record.module.descriptor.name);
+                }
+            }
+        }
+        const visiting = new Set();
+        const visited = new Set();
+        const visit = (name) => {
+            if (visiting.has(name)) {
+                throw new FeatureRegistryError('FEATURE_DEPENDENCY_CYCLE', `Feature dependency cycle includes ${name}`, name);
+            }
+            if (visited.has(name))
+                return;
+            visiting.add(name);
+            for (const dependency of this.getRecord(name).module.descriptor.dependencies)
+                visit(dependency);
+            visiting.delete(name);
+            visited.add(name);
+        };
+        for (const name of this.records.keys())
+            visit(name);
+    }
+    async start(name) {
+        return this.enqueue(name, async () => {
+            this.validate();
+            await this.startInternal(name, new Set());
+        });
+    }
+    /**
+     * 把模块状态对齐到期望启用集合。
+     *
+     * 期望启用的模块连同它们的依赖会被启动，其余已启用模块会被停用。依赖会被
+     * 自动纳入期望集合，避免「子模块要启用、父模块却被停用」互相拆台。
+     * 并发调用按模块串行队列排队，最终状态由最后一次调用决定。
+     */
+    async reconcile(enabledNames) {
+        this.validate();
+        const desired = this.resolveDesired(enabledNames);
+        for (const name of this.records.keys()) {
+            if (desired.has(name))
+                await this.start(name);
+        }
+        for (const name of this.records.keys()) {
+            if (!desired.has(name))
+                await this.disable(name);
+        }
+    }
+    async drain(name) {
+        return this.enqueue(name, async () => {
+            const record = this.getRecord(name);
+            if (record.state === 'disabled')
+                return;
+            if (record.state === 'enabling') {
+                throw new FeatureRegistryError('FEATURE_STATE_INVALID', `Cannot drain enabling feature: ${name}`, name);
+            }
+            if (record.state === 'draining')
+                return;
+            if (record.state === 'failed')
+                return;
+            record.state = 'draining';
+            try {
+                await record.module.drain?.(record.context);
+            }
+            catch (error) {
+                record.reason = errorMessage(error);
+                throw new FeatureRegistryError('FEATURE_DISPOSE_FAILED', `Failed to drain feature ${name}`, name, {
+                    cause: error,
+                });
+            }
+        });
+    }
+    async dispose(name) {
+        return this.enqueue(name, async () => {
+            const record = this.getRecord(name);
+            if (record.state === 'disabled')
+                return;
+            const errors = [];
+            if (record.state === 'enabled') {
+                record.state = 'draining';
+                try {
+                    await record.module.drain?.(record.context);
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+            }
+            try {
+                await record.module.dispose?.(record.context);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            try {
+                await record.resources.dispose();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+            record.state = 'disabled';
+            record.reason = errors.length > 0 ? errors.map(errorMessage).join('; ') : null;
+            if (errors.length > 0) {
+                throw new FeatureRegistryError('FEATURE_DISPOSE_FAILED', `Failed to dispose feature ${name}`, name, {
+                    cause: new AggregateError(errors),
+                });
+            }
+        });
+    }
+    async disable(name) {
+        this.validate();
+        const dependents = this.activeDependents(name);
+        for (const dependent of dependents)
+            await this.disable(dependent);
+        await this.dispose(name);
+    }
+    /** 把期望集合补齐为含依赖的闭包，避免依赖在停用阶段被误停。 */
+    resolveDesired(enabledNames) {
+        const desired = new Set();
+        const include = (name) => {
+            if (desired.has(name))
+                return;
+            desired.add(name);
+            for (const dependency of this.getRecord(name).module.descriptor.dependencies)
+                include(dependency);
+        };
+        for (const name of enabledNames) {
+            if (this.records.has(name))
+                include(name);
+        }
+        return desired;
+    }
+    async startInternal(name, starting) {
+        const record = this.getRecord(name);
+        if (record.state === 'enabled')
+            return;
+        if (record.state === 'enabling') {
+            throw new FeatureRegistryError('FEATURE_STATE_INVALID', `Feature is already enabling: ${name}`, name);
+        }
+        if (record.state === 'draining') {
+            throw new FeatureRegistryError('FEATURE_STATE_INVALID', `Feature is draining: ${name}`, name);
+        }
+        if (starting.has(name)) {
+            throw new FeatureRegistryError('FEATURE_DEPENDENCY_CYCLE', `Feature dependency cycle includes ${name}`, name);
+        }
+        starting.add(name);
+        for (const dependency of record.module.descriptor.dependencies) {
+            await this.enqueue(dependency, () => this.startInternal(dependency, starting));
+        }
+        starting.delete(name);
+        if (record.resources.disposed) {
+            record.resources = new FeatureResourceScopeImpl();
+            record.context = { descriptor: record.module.descriptor, resources: record.resources, services: this.services };
+        }
+        record.state = 'enabling';
+        record.reason = null;
+        try {
+            const returned = await record.module.start(record.context);
+            addReturnedDisposer(record.resources, returned);
+            record.state = 'enabled';
+        }
+        catch (error) {
+            try {
+                await record.resources.dispose();
+            }
+            catch (disposeError) {
+                error = new AggregateError([error, disposeError], 'Feature start and cleanup failed');
+            }
+            record.state = 'failed';
+            record.reason = errorMessage(error);
+            throw new FeatureRegistryError('FEATURE_START_FAILED', `Failed to start feature ${name}`, name, { cause: error });
+        }
+    }
+    activeDependents(name) {
+        const result = [];
+        for (const record of this.records.values()) {
+            if (record.state !== 'enabled' && record.state !== 'draining')
+                continue;
+            if (record.module.descriptor.dependencies.includes(name))
+                result.push(record.module.descriptor.name);
+        }
+        return result;
+    }
+    getRecord(name) {
+        const record = this.records.get(name);
+        if (!record)
+            throw new FeatureRegistryError('FEATURE_NOT_FOUND', `Feature not found: ${name}`, name);
+        return record;
+    }
+    enqueue(name, operation) {
+        const previous = this.operations.get(name) ?? Promise.resolve();
+        const next = previous.then(operation, operation);
+        this.operations.set(name, next);
+        const cleanup = () => {
+            if (this.operations.get(name) === next)
+                this.operations.delete(name);
+        };
+        void next.then(cleanup, cleanup);
+        return next;
+    }
+}
+function validateDescriptor(descriptor) {
+    if (!descriptor || typeof descriptor.name !== 'string' || descriptor.name.trim() === '') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', 'Feature descriptor requires a non-empty name');
+    }
+    if (typeof descriptor.version !== 'string' || descriptor.version.trim() === '') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} requires a version`, descriptor.name);
+    }
+    if (typeof descriptor.enabledByDefault !== 'boolean') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid enabledByDefault`, descriptor.name);
+    }
+    if (descriptor.runtime !== 'host' && descriptor.runtime !== 'client' && descriptor.runtime !== 'both') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid runtime`, descriptor.name);
+    }
+    if (descriptor.activation !== undefined && descriptor.activation !== 'live' && descriptor.activation !== 'restart') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid activation`, descriptor.name);
+    }
+    if (descriptor.minimumDshVersion !== undefined
+        && (typeof descriptor.minimumDshVersion !== 'string' || descriptor.minimumDshVersion.trim() === '')) {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid minimumDshVersion`, descriptor.name);
+    }
+    if (!Array.isArray(descriptor.dependencies) || descriptor.dependencies.some((dependency) => typeof dependency !== 'string' || dependency.trim() === '')) {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid dependencies`, descriptor.name);
+    }
+    if (new Set(descriptor.dependencies).size !== descriptor.dependencies.length) {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has duplicate dependencies`, descriptor.name);
+    }
+    validateUiDescriptor(descriptor);
+}
+function validateUiDescriptor(descriptor) {
+    const ui = descriptor.ui;
+    if (ui === undefined)
+        return;
+    if (typeof ui.label !== 'string' || ui.label.trim() === '') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid ui.label`, descriptor.name);
+    }
+    if (typeof ui.description !== 'string' || ui.description.trim() === '') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid ui.description`, descriptor.name);
+    }
+    if (ui.order !== undefined && !Number.isFinite(ui.order)) {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid ui.order`, descriptor.name);
+    }
+    if (ui.defaultOpen !== undefined && typeof ui.defaultOpen !== 'boolean') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid ui.defaultOpen`, descriptor.name);
+    }
+    if (ui.alwaysEnabled !== undefined && typeof ui.alwaysEnabled !== 'boolean') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid ui.alwaysEnabled`, descriptor.name);
+    }
+    if (ui.legacyFallback !== undefined && typeof ui.legacyFallback !== 'boolean') {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid ui.legacyFallback`, descriptor.name);
+    }
+    if (ui.legacyFallbackKey !== undefined && (typeof ui.legacyFallbackKey !== 'string' || ui.legacyFallbackKey.trim() === '')) {
+        throw new FeatureRegistryError('FEATURE_INVALID_DESCRIPTOR', `Feature ${descriptor.name} has invalid ui.legacyFallbackKey`, descriptor.name);
+    }
+}
+function addReturnedDisposer(resources, returned) {
+    if (returned !== undefined)
+        resources.add(returned);
+}
+function snapshot(record) {
+    return {
+        name: record.module.descriptor.name,
+        version: record.module.descriptor.version,
+        state: record.state,
+        runtime: record.module.descriptor.runtime,
+        dependencies: [...record.module.descriptor.dependencies],
+        reason: record.reason,
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=registry.js.map

package/data/build/dist/features/resource-scope/index.d.ts

@@ -0,0 +1,39 @@
+import { type ResourceScopeDisposer, type ResourceScopeInput, type ResourceScopeRef, type ResourceScopeSnapshot } from '../../shared/contracts/peer-host.js';
+export { ResourceScopeStaleError, type ResourceScopeDisposer, type ResourceScopeInput, type ResourceScopeRef, type ResourceScopeSnapshot, } from '../../shared/contracts/peer-host.js';
+/**
+ * 管理当前 Host/Workspace/PeerHost 资源作用域。
+ *
+ * 这是纯状态协调器：它不发请求、不创建连接，也不理解具体资源类型。
+ * 作用域切换会立即让旧 generation 失效，然后清理旧 disposer，最后保留新快照。
+ */
+export declare class ResourceScopeManager {
+    private activeScope;
+    private nextGeneration;
+    private transitionTail;
+    constructor(initialScope?: ResourceScopeInput);
+    /** 返回当前快照；返回值不可用于修改管理器内部状态。 */
+    getCurrent(): ResourceScopeSnapshot | null;
+    /**
+     * 切换作用域。并发切换会按调用顺序串行化，避免旧 disposer 交叉执行。
+     * 相同作用域不会制造无意义的新 generation，但仍可附加 disposer。
+     */
+    switchTo(input: ResourceScopeInput, disposer?: ResourceScopeDisposer): Promise<ResourceScopeSnapshot>;
+    /**
+     * 为当前作用域注册清理函数。传入旧快照会直接失败，防止资源归属错乱。
+     */
+    addDisposer(disposer: ResourceScopeDisposer): () => void;
+    /**
+     * 按快照注册清理函数。异步初始化完成后应优先使用此方法，避免旧作用域
+     * 的初始化结果把 disposer 错挂到新作用域。
+     */
+    registerDisposer(scope: ResourceScopeRef, disposer: ResourceScopeDisposer): () => void;
+    /** 判断快照是否仍然代表当前作用域。 */
+    isCurrent(scope: ResourceScopeRef | null | undefined): boolean;
+    /** 旧请求回写前调用；作用域不匹配时抛出稳定错误。 */
+    assertCurrent(scope: ResourceScopeRef): void;
+    /** 只有当前作用域才能执行写入，避免旧请求污染新作用域。 */
+    commitIfCurrent<T>(scope: ResourceScopeRef, write: () => T): T;
+    /** 清理当前作用域并使其失效。后续可重新 switchTo。 */
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map