dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/packages/market-runtime/src/runtime/host/extension-tool-gates.js

@@ -0,0 +1,96 @@
+import { finalExtension } from '@deepseek-ai/dsh-lsp';
+import { scopeChainOf } from '@deepseek-ai/dsh-scope';
+/** Keep error-code and identity prefixes stable; suffixes explain recovery without granting permission. */
+const DISABLED_SUFFIX = ' — unavailable in this session. Do not retry unchanged; if required, ask the user to check session readiness and enable this resource.';
+const INVALID_FILE_PATH_SUFFIX = ' — pass the file_path string of the target file, for example "src/index.ts".';
+const NO_PROVIDER_SUFFIX = ' — no mounted LSP provider serves this extension. If required, ask the user to configure one.';
+const AMBIGUOUS_PROVIDER_SUFFIX = ' — more than one mounted LSP provider serves this extension. Ask the user to resolve the configuration to exactly one mounted provider before retrying.';
+/**
+ * Filter inherited extension tools and guard Native/PTC execution using the public rc.2 runtime.
+ * Policy errors and unready sessions deny owned capabilities. Project MCP mounts in the agent's
+ * own scope must also filter their wanted rows: host restrictions do not hide own-scope tools.
+ */
+export function attachExtensionToolGates(agent, ownership, policy) {
+    const tools = agent.ctx.tools;
+    let disposed = false;
+    let refreshing = false;
+    let deniedNames = '';
+    let releaseRestriction;
+    const allows = (resource) => {
+        try {
+            return policy.ready(agent) && policy.allows(agent, resource.resourceId, resource.suiteId);
+        }
+        catch {
+            return false;
+        }
+    };
+    const lspAllowed = () => ownership.lspProviders().some(allows);
+    const refresh = () => {
+        if (disposed || refreshing)
+            return;
+        refreshing = true;
+        try {
+            const ancestors = scopeChainOf(agent).slice(1);
+            const deny = new Set(ownership
+                .mcpTools()
+                .filter(entry => (entry.scope === undefined || ancestors.includes(entry.scope)) && tools.get(entry.name, ancestors[0]) === entry.definition && !allows(entry))
+                .map(entry => entry.name));
+            if (ownership.ownsLspTool() && tools.get('lsp') !== undefined && !lspAllowed())
+                deny.add('lsp');
+            const names = [...deny].sort();
+            const signature = JSON.stringify(names);
+            if (signature === deniedNames)
+                return;
+            // Publish the signature before restrict/dispose emit unfiltered tools/change notifications.
+            deniedNames = signature;
+            const previous = releaseRestriction;
+            releaseRestriction = names.length === 0 ? undefined : tools.restrict({ deny: names });
+            previous?.();
+        }
+        finally {
+            refreshing = false;
+        }
+    };
+    const releaseGuard = tools.guard(exec => {
+        if (exec.agent !== agent)
+            return undefined;
+        const definition = tools.get(exec.name, agent);
+        const owned = ownership.mcpTools().find(entry => entry.definition === definition);
+        if (owned !== undefined && !allows(owned))
+            return 'extension-resource-disabled: ' + owned.resourceId + DISABLED_SUFFIX;
+        if (exec.name !== 'lsp' || !ownership.ownsLspTool() || definition !== tools.get('lsp'))
+            return undefined;
+        const args = exec.arguments;
+        if (typeof args !== 'object' || args === null || !('file_path' in args) || typeof args.file_path !== 'string')
+            return 'extension-lsp-route-unavailable: invalid file_path' + INVALID_FILE_PATH_SUFFIX;
+        const extension = finalExtension(args.file_path);
+        const providers = ownership.lspProviders().filter(provider => provider.extensions.includes(extension));
+        if (providers.length === 0)
+            return 'extension-lsp-route-unavailable: ' + extension + NO_PROVIDER_SUFFIX;
+        if (providers.length > 1)
+            return 'extension-lsp-route-unavailable: ' + extension + AMBIGUOUS_PROVIDER_SUFFIX;
+        const provider = providers[0];
+        return allows(provider) ? undefined : 'extension-resource-disabled: ' + provider.resourceId + DISABLED_SUFFIX;
+    });
+    const releaseListener = agent.ctx.on('tools/change', refresh);
+    try {
+        refresh();
+    }
+    catch (error) {
+        releaseListener();
+        releaseGuard();
+        releaseRestriction?.();
+        throw error;
+    }
+    return {
+        refresh,
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            releaseListener();
+            releaseGuard();
+            releaseRestriction?.();
+        }
+    };
+}

package/lib/{runtime → packages/market-runtime/src/runtime}/host/failure-detail.js

@@ -9,7 +9,7 @@
  *
  * @module runtime/failure-detail
  */
-import { redactErrorMessage } from '../../application/mcp/mcp-redaction.js';
+import { redactErrorMessage } from '../../../../market-contracts/src/redaction.js';
 /** How many cause messages one failure keeps; a mount failure's chain is short. */
 const MAX_CAUSES = 4;
 /** The message text of an error, a thrown string, or an object carrying one. */

package/lib/{runtime → packages/market-runtime/src/runtime}/host/host-locale.js

@@ -14,11 +14,13 @@
  */
 const zh = {
     commandAcknowledged: '/{command} 已转交模型执行',
+    commandNotSelected: '/{command} 未在当前会话启用',
     userCommandSourceLabel: '用户命令',
     feedbackToolCardTitle: '提交市场体验反馈'
 };
 const en = {
     commandAcknowledged: '/{command} forwarded to the model for execution',
+    commandNotSelected: '/{command} is not enabled in this session',
     userCommandSourceLabel: 'user command',
     feedbackToolCardTitle: 'File market feedback'
 };

package/lib/packages/market-runtime/src/runtime/host/menu-row-identities.js

@@ -0,0 +1,38 @@
+/**
+ * Pair the installed and user-authored entries this plugin owns with the menu
+ * rows they appear as.
+ *
+ * A command whose registration has no panel entry is skipped rather than
+ * guessed at: without the panel's own text there is no id to share and no
+ * translation to show. A skill the panel lists contributes whatever translation
+ * the panel already resolved for it.
+ * @param source - the panels to read and the live command registrations to match.
+ * @returns one identity per owned menu row.
+ */
+export async function collectMenuRowIdentities(source) {
+    const [skills, commands] = await Promise.all([source.panels.skills.list(), source.panels.commands.list()]);
+    const commandsByPanelId = new Map(commands.map(entry => [entry.id ?? entry.name, entry]));
+    const identities = [];
+    for (const registration of source.commands) {
+        const entry = commandsByPanelId.get(registration.id);
+        if (entry === undefined)
+            continue;
+        identities.push({
+            source: 'commands',
+            name: registration.name,
+            id: registration.id,
+            authoredName: entry.name,
+            ...(entry.description === '' ? {} : { authoredDescription: entry.description })
+        });
+    }
+    for (const entry of skills) {
+        identities.push({
+            source: 'skills',
+            name: entry.name,
+            id: entry.id ?? entry.name,
+            authoredName: entry.name,
+            ...(entry.description === '' ? {} : { authoredDescription: entry.description })
+        });
+    }
+    return identities;
+}

package/lib/packages/market-runtime/src/runtime/host/resource-filter-service.js

@@ -0,0 +1,81 @@
+import { SURFACE_TOGGLE_KEYS } from '../../../../market-contracts/src/contracts/surface-toggles.js';
+import { allFiltersOn, loadResourceFilters, mutateResourceFilters } from '../../application/state/workspace-policy.js';
+import { deleteResourceFavorite, loadResourceFavorites, saveResourceFavorite } from '../../application/state/resource-favorites.js';
+export class ResourceFilterService {
+    dataRoot;
+    hooks;
+    filters = allFiltersOn();
+    workspace;
+    tail = Promise.resolve();
+    constructor(dataRoot, workspace, hooks) {
+        this.dataRoot = dataRoot;
+        this.hooks = hooks;
+        this.workspace = workspace ?? '';
+    }
+    enqueue(work) {
+        const running = this.tail.then(work);
+        this.tail = running.then(() => { }, () => { });
+        return running;
+    }
+    /** Reload shares mutation ordering; an earlier read cannot overwrite a later write. */
+    async reload() {
+        await this.enqueue(async () => {
+            if (this.workspace !== '')
+                this.filters = await loadResourceFilters(this.dataRoot, this.workspace);
+        });
+    }
+    /** Callers receive detached data, never the owner's mutable snapshot. */
+    currentFilters() {
+        return structuredClone(this.filters);
+    }
+    currentToggles() {
+        return { ...this.filters.toggles };
+    }
+    allowsSurface(key) {
+        return this.filters.toggles[key];
+    }
+    allowsEntry(face, entryId) {
+        return !(this.filters.offEntries[face]?.includes(entryId) ?? false);
+    }
+    allows(face, entryId) {
+        return this.allowsEntry(face, entryId);
+    }
+    offEntriesOf(face) {
+        return [...(this.filters.offEntries[face] ?? [])];
+    }
+    mutate(change) {
+        return this.enqueue(async () => {
+            const next = this.workspace === '' ? change(structuredClone(this.filters)) : await mutateResourceFilters(this.dataRoot, this.workspace, change);
+            this.filters = next;
+            await this.hooks.onFiltersChanged();
+            return this.currentFilters();
+        });
+    }
+    async setSurface(key, enabled) {
+        if (!SURFACE_TOGGLE_KEYS.includes(key))
+            return this.currentToggles();
+        return (await this.mutate(current => ({ ...current, toggles: { ...current.toggles, [key]: enabled } }))).toggles;
+    }
+    async setEntry(face, entryId, enabled) {
+        return this.mutate(current => {
+            const entries = current.offEntries[face] ?? [];
+            const next = enabled ? entries.filter(id => id !== entryId) : entries.includes(entryId) ? entries : [...entries, entryId];
+            const offEntries = next.length === 0 ? Object.fromEntries(Object.entries(current.offEntries).filter(([key]) => key !== face)) : { ...current.offEntries, [face]: next };
+            return { ...current, offEntries };
+        });
+    }
+    /** One complete commit and one refresh. Failed refresh does not roll back persisted state. */
+    async applyFilters(toggles, offEntries) {
+        const captured = structuredClone({ toggles, offEntries });
+        return this.mutate(() => captured);
+    }
+    async favorites() {
+        return loadResourceFavorites(this.dataRoot);
+    }
+    async saveFavorite(input) {
+        return saveResourceFavorite(this.dataRoot, input);
+    }
+    async deleteFavorite(id) {
+        await deleteResourceFavorite(this.dataRoot, id);
+    }
+}

package/lib/packages/market-runtime/src/runtime/host/scoped-contributors.js

@@ -0,0 +1,304 @@
+import { pluginResourceId } from '../../application/panel-resources.js';
+import { hookResourceId } from '../../../../market-contracts/src/contracts/extension-presets.js';
+import { exposesIndividualHooks } from '../../application/extension-hook-selection.js';
+import { SuiteSkillProvider } from '../surfaces/skills-provider.js';
+import { CommandMountRegistry } from '../surfaces/commands-mounts.js';
+import { UserCommandMountRegistry } from '../panels/user-commands.js';
+import { UserPanelSkillProvider } from '../panels/user-panels.js';
+import { ExtensionHooks } from '../surfaces/extension-hooks.js';
+import { suiteInstructions } from '../surfaces/project-runtime.js';
+import { bindHostLocale } from './host-locale.js';
+import { inspectToolRegistry } from './tool-registry-observer.js';
+const suiteId = (suite) => 'market:' + suite.sourceId + '/' + suite.id;
+const entryId = (suite, kind, name) => kind + ':' + pluginResourceId(suite.sourceId, suite.id, kind, name);
+export class ScopedExtensionContributors {
+    ports;
+    mounted = new Map();
+    hostMcp = new Map();
+    hostQueues = new Map();
+    constructor(ports) {
+        this.ports = ports;
+    }
+    registrationAllows(agent, id) {
+        return (this.ports.registrationAllows ?? this.ports.allows)(agent, id);
+    }
+    registerSkills(agent, scope, mount) {
+        mount.releaseSkills.push(scope.skills.registerProvider(control => {
+            mount.controls.push(control);
+            return new SuiteSkillProvider(this.ports.catalog, {
+                dataRoot: this.ports.dataRoot,
+                shell: this.ports.shell,
+                ...(this.ports.suites === undefined
+                    ? {}
+                    : {
+                        suites: () => this.ports.suites(agent),
+                        overrideDisabled: (suite, skill) => mount.active && this.ports.allows(agent, entryId(suite, 'skills', skill.name))
+                    }),
+                suiteAllowed: suite => mount.active && this.ports.allows(agent, suiteId(suite)),
+                entryAllowed: (suite, skill) => mount.active && this.ports.allows(agent, entryId(suite, 'skills', skill.name))
+            });
+        }));
+        const skills = this.ports.panels?.skills;
+        if (skills) {
+            mount.releaseSkills.push(scope.skills.registerProvider(control => {
+                mount.controls.push(control);
+                return new UserPanelSkillProvider(skills, {
+                    enabled: entry => mount.active && this.ports.allows(agent, 'skills:' + entry.name)
+                });
+            }));
+        }
+    }
+    async attach(agent) {
+        const current = this.mounted.get(agent);
+        if (current)
+            return current;
+        const mount = { controls: [], releaseSkills: [], instructions: [], active: true };
+        this.mounted.set(agent, mount);
+        if (!this.ports.panels) {
+            const fiber = agent.ctx.inject(['skills'], scope => this.registerSkills(agent, scope, mount));
+            mount.fiber = fiber;
+            await fiber;
+            return mount;
+        }
+        const fiber = agent.ctx.inject(['skills', 'commands', 'tools', 'systemPrompt'], scope => {
+            this.registerSkills(agent, scope, mount);
+            const t = this.ports.t ?? bindHostLocale(undefined);
+            mount.commands = new CommandMountRegistry(scope, t, this.ports.dataRoot);
+            mount.users = new UserCommandMountRegistry(scope, this.ports.panels.commands, t);
+            mount.commands.setSelectionPolicy((suite, name) => mount.active && this.ports.allows(agent, entryId(suite, 'commands', name)), (suite, name) => mount.active && this.registrationAllows(agent, entryId(suite, 'commands', name)), { allowDisabled: this.ports.suites !== undefined });
+            mount.users.setSelectionPolicy(name => mount.active && this.ports.allows(agent, 'commands:' + name), name => mount.active && this.registrationAllows(agent, 'commands:' + name), { allowDisabled: this.ports.suites !== undefined });
+            mount.hookFiber = scope.inject(['shell', 'sessionProjections'], hookScope => {
+                // The suite grant covers every hook of a suite that publishes no individual
+                // row; a suite that does publish them is decided hook by hook, on the exact
+                // identity the inventory exposed.
+                mount.hooks = new ExtensionHooks(hookScope, agent, suite => mount.active && this.ports.allows(agent, suiteId(suite)), (suite, event, index) => !exposesIndividualHooks(suite) || (mount.active && this.ports.allows(agent, hookResourceId(suite.sourceId, suite.id, event, index))), this.ports.dataRoot);
+                hookScope.effect(() => () => mount.hooks.dispose(), 'dsh-agent-plugins-market: scoped hooks');
+            });
+            mount.mcp = this.ports.mcpMounts(scope, this.ports.dataRoot);
+            mount.mcp.setBackendProvider(() => this.ports.catalog.mcpBackend());
+            mount.mcp.setOverridesProvider(async () => {
+                const suites = this.ports.suites === undefined
+                    ? (await this.ports.catalog.readProjectCatalog(agent.session.header.cwd)).enabledSuites
+                    : (await this.ports.suites(agent)).filter(suite => suite.dimension === 'project');
+                const overrides = await this.ports.catalog.allMcpOverrides(suites);
+                if (this.ports.suites === undefined)
+                    return overrides;
+                const projected = new Map(overrides);
+                for (const suite of suites) {
+                    const owner = suite.sourceId + '/' + suite.id;
+                    const rows = { ...overrides.get(owner) };
+                    for (const key of Object.keys(suite.mcp?.servers ?? {})) {
+                        if (this.registrationAllows(agent, 'mcp:plugin:' + owner + '/' + key))
+                            rows[key] = { ...rows[key], enabled: true };
+                    }
+                    projected.set(owner, rows);
+                }
+                return projected;
+            });
+            scope.systemPrompt.section({
+                name: 'agent-plugins:instructions',
+                order: 500,
+                text: () => mount.active
+                    ? mount.instructions
+                        .filter(row => this.ports.allows(agent, row.parent) && this.ports.allows(agent, row.id))
+                        .map(row => row.text)
+                        .join('\n\n')
+                    : ''
+            });
+            scope.effect(() => async () => {
+                mount.active = false;
+                mount.instructions = [];
+                await mount.hooks?.dispose();
+                mount.commands?.disposeAll();
+                mount.users?.disposeAll();
+                await mount.mcp?.disposeAll();
+            }, 'dsh-agent-plugins-market: scoped contributors');
+        });
+        mount.fiber = fiber;
+        try {
+            await fiber;
+            if (!mount.commands || !mount.mcp)
+                throw new Error('extension-contributors-not-ready');
+            return mount;
+        }
+        catch (error) {
+            await this.dispose(agent);
+            throw error;
+        }
+    }
+    /** Called inside the session maintenance transaction, before its committed record. */
+    async reconcile(agent, selection) {
+        if (!this.ports.panels && !selection.enabledIds.some(id => id.startsWith('market:'))) {
+            await this.dispose(agent);
+            return;
+        }
+        const mount = await this.attach(agent);
+        for (const control of mount.controls)
+            control.invalidate();
+        if (!this.ports.panels)
+            return;
+        const [suites, backend] = await Promise.all([
+            this.ports.suites?.(agent) ??
+                Promise.all([this.ports.catalog.enabledUserSuites(), this.ports.catalog.readProjectCatalog(agent.session.header.cwd)]).then(([user, project]) => [
+                    ...user,
+                    ...project.enabledSuites
+                ]),
+            this.ports.catalog.mcpBackend()
+        ]);
+        const selected = suites.filter(suite => this.registrationAllows(agent, suiteId(suite)));
+        if (selected.some(suite => suite.activeSurfaces.hooks && suite.surfaces.hooks > 0) && !mount.hooks)
+            throw new Error('extension-hooks-require-shell-and-session-projections');
+        const diagnostics = await Promise.all([mount.commands.reconcile(selected), mount.users.reconcile(), mount.hooks?.reconcile(selected) ?? []]);
+        for (const group of diagnostics)
+            for (const diagnostic of group)
+                agent.ctx.logger.warn('[dsh-agent-plugins-market] ' + (typeof diagnostic === 'string' ? diagnostic : diagnostic.reason));
+        const instructions = [];
+        for (const suite of selected) {
+            const parent = suiteId(suite);
+            const { startupSkill, ...manifest } = suite.manifest;
+            const paths = { dataRoot: this.ports.dataRoot, projectDir: agent.session.header.cwd };
+            const system = await suiteInstructions([{ ...suite, manifest }], paths);
+            if (system.text)
+                instructions.push({ id: parent, parent, text: system.text });
+            if (startupSkill && this.registrationAllows(agent, entryId(suite, 'skills', startupSkill))) {
+                const withoutSystem = { ...suite };
+                delete withoutSystem.systemPrompt;
+                const startup = await suiteInstructions([withoutSystem], paths);
+                if (startup.text)
+                    instructions.push({ id: entryId(suite, 'skills', startupSkill), parent, text: startup.text });
+            }
+        }
+        mount.instructions = instructions;
+        if (backend === 'host') {
+            await mount.mcp.reconcile([]);
+            // Host compatibility remains global-managed, independent of session projection.
+            await this.reconcileHostMcp(agent, mount, (await this.ports.catalog.readProjectCatalog(agent.session.header.cwd)).enabledSuites);
+        }
+        else {
+            await this.releaseHostMcp(agent, mount);
+            const projectMcp = selected
+                .filter(suite => suite.dimension === 'project')
+                .map(suite => suite.mcp === undefined
+                ? suite
+                : {
+                    ...suite,
+                    mcp: {
+                        ...suite.mcp,
+                        servers: Object.fromEntries(Object.entries(suite.mcp.servers).filter(([key]) => this.registrationAllows(agent, 'mcp:plugin:' + suite.sourceId + '/' + suite.id + '/' + key)))
+                    }
+                });
+            for (const diagnostic of await mount.mcp.reconcile(projectMcp))
+                agent.ctx.logger.warn('[dsh-agent-plugins-market] project MCP: ' + diagnostic.reason);
+        }
+    }
+    async hostOperation(cwd, work) {
+        const pending = (this.hostQueues.get(cwd) ?? Promise.resolve()).catch(() => { }).then(work);
+        this.hostQueues.set(cwd, pending);
+        try {
+            await pending;
+        }
+        finally {
+            if (this.hostQueues.get(cwd) === pending)
+                this.hostQueues.delete(cwd);
+        }
+    }
+    async reconcileHostMcp(agent, mount, suites) {
+        const cwd = agent.session.header.cwd;
+        await this.hostOperation(cwd, async () => {
+            let shared = this.hostMcp.get(cwd);
+            if (!shared) {
+                const host = this.ports.hostContext;
+                if (!host)
+                    throw new Error('extension-host-mcp-owner-unavailable');
+                let registry;
+                const fiber = host.inject(['tools'], scope => {
+                    registry = this.ports.mcpMounts(scope, this.ports.dataRoot);
+                    registry.setBackendProvider(async () => 'host');
+                    registry.setToolNamesProvider(() => inspectToolRegistry(scope.tools).map(tool => tool.name));
+                    registry.setOverridesProvider(async () => this.ports.catalog.allMcpOverrides((await this.ports.catalog.readProjectCatalog(cwd)).enabledSuites));
+                    scope.effect(() => () => registry.disposeAll(), 'dsh-agent-plugins-market: shared project MCP');
+                });
+                try {
+                    await fiber;
+                }
+                catch (error) {
+                    await fiber.dispose();
+                    throw error;
+                }
+                if (!registry) {
+                    await fiber.dispose();
+                    throw new Error('extension-host-mcp-owner-unavailable');
+                }
+                shared = { fiber, registry, agents: new Set() };
+                this.hostMcp.set(cwd, shared);
+            }
+            shared.agents.add(agent);
+            mount.hostMcpWorkspace = cwd;
+            for (const diagnostic of await shared.registry.reconcile(suites))
+                agent.ctx.logger.warn('[dsh-agent-plugins-market] project MCP: ' + diagnostic.reason);
+        });
+    }
+    async releaseHostMcp(agent, mount) {
+        const cwd = mount.hostMcpWorkspace;
+        if (cwd === undefined)
+            return;
+        delete mount.hostMcpWorkspace;
+        await this.hostOperation(cwd, async () => {
+            const shared = this.hostMcp.get(cwd);
+            if (!shared)
+                return;
+            shared.agents.delete(agent);
+            if (shared.agents.size > 0)
+                return;
+            try {
+                await shared.fiber.dispose();
+            }
+            finally {
+                this.hostMcp.delete(cwd);
+            }
+        });
+    }
+    committed(agent) {
+        for (const control of this.mounted.get(agent)?.controls ?? [])
+            control.invalidate();
+    }
+    /** Invalidate cached summaries and run startup hooks only after the session is durably ready. */
+    async ready(agent, source) {
+        const mount = this.mounted.get(agent);
+        for (const control of mount?.controls ?? [])
+            control.invalidate();
+        if (source === 'clear' || source === 'compact' || source === undefined)
+            return;
+        try {
+            await mount?.hooks?.start(source === 'resume' || source === 'legacy' ? 'resume' : 'startup');
+        }
+        catch (error) {
+            agent.ctx.logger.warn('[dsh-agent-plugins-market] SessionStart hook failed: ' + String(error));
+        }
+    }
+    invalidateAll() {
+        for (const mount of this.mounted.values())
+            for (const control of mount.controls)
+                control.invalidate();
+    }
+    toolOwnership(agent) {
+        return this.mounted.get(agent)?.mcp?.toolOwnership() ?? [];
+    }
+    registrations() {
+        return [...this.mounted.values()].flatMap(mount => [...(mount.commands?.registrations() ?? []), ...(mount.users?.registrations() ?? [])]);
+    }
+    async dispose(agent) {
+        const mount = this.mounted.get(agent);
+        if (!mount)
+            return;
+        this.mounted.delete(agent);
+        mount.active = false;
+        for (const release of mount.releaseSkills.splice(0))
+            release();
+        await mount.fiber?.dispose();
+        await this.releaseHostMcp(agent, mount);
+    }
+    async disposeAll() {
+        await Promise.all([...this.mounted.keys()].map(agent => this.dispose(agent)));
+    }
+}

package/lib/packages/market-runtime/src/runtime/host/surface-toggle-service.js

@@ -0,0 +1,15 @@
+export class SurfaceToggleService {
+    owner;
+    constructor(owner) {
+        this.owner = owner;
+    }
+    async reload() {
+        await this.owner.reload();
+    }
+    currentToggles() {
+        return this.owner.currentToggles();
+    }
+    async set(key, enabled) {
+        return this.owner.setSurface(key, enabled);
+    }
+}