dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/packages/market-runtime/src/runtime/panels/user-commands.js

@@ -0,0 +1,211 @@
+/**
+ * User command mounting: every enabled entry of the user commands panel
+ * registers as a dsh slash command, so user-authored quick replies behave
+ * exactly like suite commands — the body with `$ARGUMENTS` substituted rides
+ * one follow-up message on the receiving agent. A nested entry registers
+ * under its flattened call name (`git/commit` → `git-commit`) while the panel
+ * keeps addressing it by path; when two entries flatten to one call name the
+ * later one takes a numeric suffix (`git-commit-1`) and is reported, because a
+ * second registration of one name is what makes the host's slash menu drop it.
+ * Reconciled on every catalog change, keyed by the entry path.
+ * @module runtime/user-commands
+ */
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { commandCallName } from '../../../../market-contracts/src/model/command-names.js';
+import { USER_ENTRY_PATH, parseFrontmatterRecord } from '../../application/panels/user-store.js';
+import { pluginMarketSource } from '../../../../market-contracts/src/host/plugin-message-source.js';
+import { CommandNameRegistry, registerWithAllocatedName } from '../host/command-name-allocator.js';
+/** Render a thrown value for a diagnostic, without trusting its string coercion. */
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Register/unregister user-panel commands to match the panel's enabled entries. */
+export class UserCommandMountRegistry {
+    ctx;
+    store;
+    t;
+    fingerprints = new Map();
+    live = new Map();
+    /**
+     * The call names this seat holds, and the entry each one was registered for.
+     *
+     * Occupancy is per layer, which is the unit the host checks: this registry
+     * registers into the global layer, so its names must be unique among
+     * themselves and against every other registration in that layer.
+     */
+    names = new CommandNameRegistry();
+    registeredName = new Map();
+    /** The menu row each live registration produces, with the panel id it translates as. */
+    registered = new Map();
+    /** Per-workspace entry filter; an absent provider registers everything wanted. */
+    entryFilter;
+    selectionPolicy;
+    registrationPolicy;
+    allowDisabled = false;
+    constructor(ctx, store, t) {
+        this.ctx = ctx;
+        this.store = store;
+        this.t = t;
+    }
+    /**
+     * Install the per-workspace entry filter read at wanted-row time, keyed by
+     * the panel path name the resource window lists (`commands:${entry.name}`).
+     */
+    setEntryFilter(filter) {
+        this.entryFilter = filter;
+    }
+    /** Gate reconcile and execution by the original panel path name; unset allows all. */
+    setSelectionPolicy(callback, registration = callback, options = {}) {
+        this.selectionPolicy = callback;
+        this.registrationPolicy = registration;
+        this.allowDisabled = options.allowDisabled === true;
+    }
+    /**
+     * Sync the live registrations with the panel's enabled entries.
+     *
+     * A switched-off commands surface reconciles against no entries at all,
+     * which unregisters whatever is live — skipping the pass would leave the
+     * previous registrations mounted after the switch went off.
+     * @param allow - whether the workspace's commands switch is on.
+     */
+    async reconcile(allow = true) {
+        const diagnostics = [];
+        const entries = allow ? await this.store.list() : [];
+        const wanted = new Map();
+        // Keyed by the entry path, not the call name: two entries that flatten to
+        // one call name are two commands, and the second gets a suffixed call name
+        // rather than replacing the first in the wanted map.
+        for (const entry of entries) {
+            if (entry.metadata['validationError'] !== undefined)
+                continue;
+            try {
+                parseFrontmatterRecord(entry.rawText);
+            }
+            catch {
+                continue;
+            }
+            if (entry.disabled && !(this.allowDisabled && this.registrationPolicy?.(entry.name) === true))
+                continue;
+            if (this.entryFilter?.().allows('commands', `commands:${entry.name}`) === false)
+                continue;
+            if (this.registrationPolicy?.(entry.name) === false)
+                continue;
+            if (!USER_ENTRY_PATH.test(entry.name))
+                continue;
+            wanted.set(entry.name, {
+                name: commandCallName(entry.name),
+                description: entry.description === '' ? `[${this.t('userCommandSourceLabel')}] ${commandCallName(entry.name)}` : `[${this.t('userCommandSourceLabel')}] ${entry.description}`,
+                ...(typeof entry.metadata['argument-hint'] === 'string' && entry.metadata['argument-hint'] !== '' ? { hint: entry.metadata['argument-hint'] } : {}),
+                body: entry.content
+            });
+        }
+        for (const [key, disposer] of [...this.live]) {
+            if (!wanted.has(key)) {
+                disposer();
+                this.live.delete(key);
+                this.fingerprints.delete(key);
+                this.releaseName(key);
+            }
+        }
+        const host = this.ctx;
+        const commands = host.commands;
+        if (typeof commands?.register !== 'function') {
+            if (wanted.size > 0)
+                diagnostics.push('ctx.commands is not available in this profile; user commands stay unregistered');
+            return diagnostics;
+        }
+        for (const [key, spec] of wanted) {
+            const fingerprint = JSON.stringify(spec);
+            if (this.live.has(key) && this.fingerprints.get(key) === fingerprint)
+                continue;
+            this.live.get(key)?.();
+            this.live.delete(key);
+            this.fingerprints.delete(key);
+            this.releaseName(key);
+            const attempt = registerWithAllocatedName(this.names, spec.name, name => commands.register({
+                name,
+                description: spec.description,
+                ...(spec.hint === undefined ? {} : { input: { hint: spec.hint } }),
+                handler: invocation => {
+                    const agent = invocation.agent;
+                    const send = (body) => {
+                        if (this.selectionPolicy?.(key) === false)
+                            return { kind: 'error', text: this.t('commandNotSelected', { command: name }) };
+                        agent.followup(createUserMessage({
+                            content: [{ type: 'text', text: body.replaceAll('$ARGUMENTS', invocation.rawInput.trim()) }],
+                            source: pluginMarketSource()
+                        }));
+                        return { kind: 'success', text: this.t('commandAcknowledged', { command: name }) };
+                    };
+                    if (!this.selectionPolicy)
+                        return send(spec.body);
+                    return (async () => {
+                        const denied = () => ({ kind: 'error', text: this.t('commandNotSelected', { command: name }) });
+                        if (this.selectionPolicy?.(key) !== true)
+                            return denied();
+                        try {
+                            const entry = await this.store.get(key);
+                            if (!entry || entry.metadata['validationError'] !== undefined || (entry.disabled && !this.allowDisabled))
+                                return denied();
+                            parseFrontmatterRecord(entry.rawText);
+                            if (this.selectionPolicy?.(key) !== true)
+                                return denied();
+                            return send(entry.content);
+                        }
+                        catch {
+                            return denied();
+                        }
+                    })();
+                }
+            }));
+            if (attempt.kind === 'failed') {
+                diagnostics.push(`command "${spec.name}": ${messageOf(attempt.error)}`);
+                continue;
+            }
+            this.live.set(key, attempt.disposer);
+            this.fingerprints.set(key, fingerprint);
+            this.registeredName.set(key, attempt.name);
+            // The wanted map is keyed by the entry name the panel lists, which is also
+            // the id the panel translated that entry under — one spelling, one cache
+            // entry, so the menu shows the text the panel already paid for.
+            this.registered.set(key, { name: attempt.name, id: key });
+            // The panel addresses the entry by path, so a renamed registration is
+            // reported where the entry is listed rather than left to be discovered
+            // from the slash menu.
+            if (attempt.name !== spec.name) {
+                diagnostics.push(`command "${spec.name}": registered as "${attempt.name}" because the call name is already taken`);
+            }
+        }
+        return diagnostics;
+    }
+    /**
+     * Every command this seat currently holds: the call name the menu row carries
+     * and the panel identity that owns its translation.
+     *
+     * The registry is the only place that knows a name allocation suffixed, and a
+     * user entry's panel identity is the entry name the panel lists.
+     * @returns one row per live registration, in registration-key order.
+     */
+    registrations() {
+        return [...this.registered.values()];
+    }
+    /** Dispose every registration (plugin teardown). */
+    disposeAll() {
+        for (const disposer of [...this.live.values()])
+            disposer();
+        for (const key of [...this.registeredName.keys()])
+            this.releaseName(key);
+        this.registered.clear();
+        this.live.clear();
+        this.fingerprints.clear();
+    }
+    /** Free the call name one unmounted entry held, so a later claim can reuse it. */
+    releaseName(key) {
+        const name = this.registeredName.get(key);
+        if (name === undefined)
+            return;
+        this.names.forget(name);
+        this.registeredName.delete(key);
+        this.registered.delete(key);
+    }
+}

package/lib/{runtime → packages/market-runtime/src/runtime}/panels/user-panels.js

@@ -30,7 +30,7 @@
  * @module runtime/user-panels
  */
 import { dirname } from 'node:path';
-import { skillEntryRejection } from '../../catalog/skills-parse.js';
+import { skillEntryRejection } from '../../../../market-catalog/src/index.js';
 import { deleteEntryDocument, entryExists, listEntryDocuments, listEntryFiles, readEntryDocument, resolveEntryDocument, SKILL_ENTRY_SHAPES, USER_ENTRY_NAME, USER_ENTRY_PATH, userEntryDir, writeEntryDocument, writeEntryFile } from '../../application/panels/user-store.js';
 /** The skill-source label user-panel entries carry into the skill registry. */
 export const USER_PANEL_SKILL_SOURCE = 'user-panel';
@@ -43,9 +43,8 @@ export const USER_PANEL_SKILL_SOURCE = 'user-panel';
  * (450), so a skill the user wrote by hand wins over one an installed suite
  * ships under the same name.
  *
- * Switching a skill off is not this provider's job: the panel writes the
- * harness's own invocation pair into the document, which every reader of that
- * file honors.
+ * Global panel switches write the invocation pair into the document. A scoped
+ * selection policy overrides only that session and never writes the document.
  */
 const USER_PANEL_RANK = 440;
 /** Throwing CRUD over one panel directory, shared by the three panels. */
@@ -205,15 +204,33 @@ export function isUserSkillEntryName(name) {
  */
 export class UserPanelSkillProvider {
     skills;
+    options;
     name = 'user-panel';
-    constructor(skills) {
+    constructor(skills, options = {}) {
         this.skills = skills;
+        this.options = options;
+    }
+    invocation(entry) {
+        if (!isUserSkillEntryName(entry.name) || entry.metadata['validationError'] !== undefined)
+            return undefined;
+        if (!this.options.enabled && entry.disabled)
+            return undefined;
+        const authored = {
+            modelInvocable: entry.metadata['disable-model-invocation'] !== true,
+            userInvocable: entry.metadata['user-invocable'] !== false
+        };
+        if (!this.options.enabled)
+            return authored;
+        if (!this.options.enabled(entry))
+            return { modelInvocable: false, userInvocable: false };
+        return !authored.modelInvocable && !authored.userInvocable ? { modelInvocable: true, userInvocable: true } : authored;
     }
     async list(_options) {
         const candidates = [];
         const skills = await this.skills.list();
         for (const entry of skills) {
-            if (entry.disabled || !isUserSkillEntryName(entry.name))
+            const invocation = this.invocation(entry);
+            if (!invocation)
                 continue;
             candidates.push({
                 // The entry's name is the one its document declares, which is also the
@@ -224,10 +241,7 @@ export class UserPanelSkillProvider {
                 // catalog a suite skill does.
                 description: entry.description === '' ? entry.name : entry.description,
                 ...(typeof entry.metadata['whenToUse'] === 'string' && entry.metadata['whenToUse'] !== '' ? { whenToUse: entry.metadata['whenToUse'] } : {}),
-                invocation: {
-                    modelInvocable: entry.metadata['disable-model-invocation'] !== true,
-                    userInvocable: entry.metadata['user-invocable'] !== false
-                },
+                invocation,
                 source: USER_PANEL_SKILL_SOURCE,
                 provider: this.name,
                 rank: USER_PANEL_RANK,
@@ -240,15 +254,21 @@ export class UserPanelSkillProvider {
     }
     async get(candidate, _options) {
         const locator = candidate.locator;
-        const store = this.skills;
-        const entry = await store.get(locator.name);
-        if (entry === undefined || entry.disabled)
+        if (typeof locator?.name !== 'string' || !isUserSkillEntryName(locator.name))
+            return undefined;
+        if (this.options.enabled && (candidate.provider !== this.name || candidate.source !== USER_PANEL_SKILL_SOURCE || candidate.name !== locator.name))
+            return undefined;
+        const entry = await this.skills.get(locator.name);
+        if (entry === undefined || (this.options.enabled && (entry.name !== candidate.name || entry.path !== candidate.path)))
+            return undefined;
+        const invocation = this.invocation(entry);
+        if (!invocation || (!invocation.modelInvocable && !invocation.userInvocable))
             return undefined;
         return {
             name: candidate.name,
             description: candidate.description,
             ...(typeof entry.metadata['whenToUse'] === 'string' && entry.metadata['whenToUse'] !== '' ? { whenToUse: entry.metadata['whenToUse'] } : {}),
-            invocation: candidate.invocation,
+            invocation: this.options.enabled ? invocation : candidate.invocation,
             source: candidate.source,
             provider: this.name,
             resourceBase: { kind: 'directory', path: this.resourceDirectory(entry) },

package/lib/packages/market-runtime/src/runtime/surfaces/commands-mounts.js

@@ -0,0 +1,256 @@
+import { createUserMessage } from '@deepseek-ai/dsh-llm';
+import { qualifiedSuiteId, suiteDataDir } from '../../../../market-catalog/src/index.js';
+import { expandPluginPaths, pluginRootOf } from '../../../../market-catalog/src/index.js';
+import { defaultMarkdownResources, resourceText } from '../../../../market-catalog/src/index.js';
+import { parseCommandResource, readCommands } from '../../application/command-resources.js';
+export { readCommands } from '../../application/command-resources.js';
+import { bindHostLocale } from '../host/host-locale.js';
+import { injectDynamicContext, shellSeamOf } from './dynamic-context.js';
+import { pluginMarketSource } from '../../../../market-contracts/src/host/plugin-message-source.js';
+import { CommandNameRegistry, registerWithAllocatedName } from '../host/command-name-allocator.js';
+import { pluginResourceId } from '../../application/panel-resources.js';
+/** Render a thrown value for a diagnostic, without trusting its string coercion. */
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export class CommandMountRegistry {
+    ctx;
+    t;
+    dataRoot;
+    fingerprints = new Map();
+    live = new Map();
+    /**
+     * The call names this seat holds, and the keys they were registered under.
+     *
+     * Occupancy is per layer, which is the unit the host checks: this registry
+     * instance registers into one layer (an agent's scope on the project path,
+     * the global layer on the user path), and a sibling registry in another
+     * layer neither sees nor is seen by these names.
+     */
+    names = new CommandNameRegistry();
+    registeredName = new Map();
+    /** The menu row each live registration produces, with the panel id it translates as. */
+    registered = new Map();
+    /** Per-workspace entry filter; an absent provider registers everything wanted. */
+    entryFilter;
+    selectionPolicy;
+    registrationPolicy;
+    allowDisabled = false;
+    constructor(ctx, t = bindHostLocale(undefined), dataRoot) {
+        this.ctx = ctx;
+        this.t = t;
+        this.dataRoot = dataRoot;
+    }
+    /**
+     * Install the per-workspace entry filter read at wanted-row time. A filtered
+     * command never becomes wanted, which unregisters it through the ordinary
+     * reconcile pass — the same path a removed command file takes.
+     */
+    setEntryFilter(filter) {
+        this.entryFilter = filter;
+    }
+    /**
+     * Gate reconcile and execution by owning suite and authored resource name,
+     * before call-name flattening or collision allocation. Unset allows all.
+     */
+    setSelectionPolicy(callback, registration = callback, options = {}) {
+        this.selectionPolicy = callback;
+        this.registrationPolicy = registration;
+        this.allowDisabled = options.allowDisabled === true;
+    }
+    /** The live shell seam, when the profile has one; dynamic context stays literal without it. */
+    shell() {
+        return shellSeamOf(this.ctx);
+    }
+    /** Register/unregister suite commands to match the enabled suites exactly. */
+    async reconcile(enabledSuites) {
+        const diagnostics = [];
+        const wanted = new Map();
+        /** How many specs already claimed one suite-qualified call name this pass. */
+        const occurrences = new Map();
+        for (const suite of enabledSuites) {
+            const specs = [];
+            const resources = suite.activeSurfaces.commands === false ? [] : (suite.resources?.commands ?? (await defaultMarkdownResources(suite.root, 'commands')));
+            for (const resource of resources) {
+                const includeDisabled = this.allowDisabled && this.registrationPolicy?.(suite, resource.name) === true;
+                for (const spec of await readCommands(suite.root, [resource], { includeDisabled }))
+                    specs.push({ ...spec, resource });
+            }
+            const suiteRoot = pluginRootOf(suite);
+            const suiteData = suiteRoot === undefined || this.dataRoot === undefined ? undefined : suiteDataDir(this.dataRoot, suite.sourceId, suite.id);
+            for (const spec of specs) {
+                // The registry key is source-qualified: bare suite ids are unique per
+                // source only, so two sources' same-named suites would collide.
+                const suiteKey = qualifiedSuiteId(suite.sourceId, suite.id);
+                // Two files of one suite flatten to one call name (`git/commit` and
+                // `git-commit`) and are both real commands, so the key counts them
+                // apart and allocation gives the second one a suffix instead of
+                // dropping it. The count is per pass, so re-reading the same suite
+                // reproduces the same keys.
+                const qualified = `${suiteKey}/${spec.name}`;
+                const occurrence = occurrences.get(qualified) ?? 0;
+                occurrences.set(qualified, occurrence + 1);
+                const key = occurrence === 0 ? qualified : `${qualified}#${occurrence}`;
+                // The per-workspace resource filter answers by the call name the model
+                // types, so the window and the registry agree on what one row names.
+                if (this.entryFilter?.().allows('commands', `commands:${spec.name}`) === false)
+                    continue;
+                if (this.registrationPolicy?.(suite, spec.resourceName) === false)
+                    continue;
+                wanted.set(key, {
+                    ...spec,
+                    suite,
+                    suiteId: suiteKey,
+                    suiteName: suite.manifest.name,
+                    // Kept apart from the qualified `suiteId` above: the panel id is built
+                    // from the two raw halves, exactly as the panel builds it.
+                    sourceId: suite.sourceId,
+                    rawSuiteId: suite.id,
+                    ...(suiteRoot === undefined ? {} : { suiteRoot }),
+                    ...(suiteData === undefined ? {} : { suiteData })
+                });
+            }
+        }
+        for (const [key, disposer] of [...this.live]) {
+            if (!wanted.has(key)) {
+                disposer();
+                this.live.delete(key);
+                this.fingerprints.delete(key);
+                this.releaseName(key);
+            }
+        }
+        const host = this.ctx;
+        const commands = host.commands;
+        if (typeof commands?.register !== 'function') {
+            if (wanted.size > 0)
+                diagnostics.push({ suiteId: '', command: '', reason: 'ctx.commands is not available in this profile' });
+            return diagnostics;
+        }
+        for (const [key, { suite, ...spec }] of wanted) {
+            const fingerprint = JSON.stringify(spec);
+            if (this.live.has(key) && this.fingerprints.get(key) === fingerprint)
+                continue;
+            this.live.get(key)?.();
+            this.live.delete(key);
+            this.fingerprints.delete(key);
+            this.releaseName(key);
+            // A name the layer already holds — a sibling suite flattening to the
+            // same call name, a host built-in such as /compact, or a leftover
+            // registration — is the one case the host refuses outright, and a
+            // refused definition is what the slash menu drops. Allocating the name
+            // first turns that collision into a suffix instead of a disappearance.
+            const attempt = registerWithAllocatedName(this.names, spec.name, name => commands.register({
+                name,
+                description: `[${spec.suiteName}] ${spec.description}`,
+                ...(spec.hint === undefined ? {} : { input: { hint: spec.hint } }),
+                handler: async (invocation) => {
+                    const agent = invocation.agent;
+                    const workdir = agent.session?.header?.cwd;
+                    // The template rides the agent verbatim apart from the placeholders
+                    // its author wrote: a decorator line naming this plugin or the
+                    // suite would be text the command author never wrote, and the
+                    // follow-up's `source` already records provenance.
+                    let authoredBody = spec.body;
+                    if (this.selectionPolicy) {
+                        if (this.selectionPolicy(suite, spec.resourceName) !== true)
+                            return { kind: 'error', text: this.t('commandNotSelected', { command: name }) };
+                        try {
+                            const resource = !this.allowDisabled || spec.resource.file === suite.manifest.path ? spec.resource : { name: spec.resource.name, file: spec.resource.file };
+                            const fresh = parseCommandResource(resource, await resourceText(resource), { includeDisabled: this.allowDisabled });
+                            if (!fresh || this.selectionPolicy(suite, spec.resourceName) !== true)
+                                return { kind: 'error', text: this.t('commandNotSelected', { command: name }) };
+                            authoredBody = fresh.body;
+                        }
+                        catch {
+                            return { kind: 'error', text: this.t('commandNotSelected', { command: name }) };
+                        }
+                    }
+                    const body = expandPluginPaths(authoredBody, {
+                        ...(spec.suiteRoot === undefined ? {} : { root: spec.suiteRoot }),
+                        ...(spec.suiteData === undefined ? {} : { data: spec.suiteData }),
+                        ...(workdir === undefined ? {} : { projectDir: workdir })
+                    }).replaceAll('$ARGUMENTS', invocation.rawInput.trim());
+                    if (this.selectionPolicy?.(suite, spec.resourceName) === false) {
+                        return { kind: 'error', text: this.t('commandNotSelected', { command: name }) };
+                    }
+                    const shell = this.shell();
+                    if (shell === undefined) {
+                        agent.followup(createUserMessage({
+                            content: [{ type: 'text', text: body }],
+                            source: pluginMarketSource()
+                        }));
+                        return { kind: 'success', text: this.t('commandAcknowledged', { command: name }) };
+                    }
+                    let text;
+                    try {
+                        text = await injectDynamicContext(body, { shell, ...(workdir === undefined ? {} : { workdir }) });
+                    }
+                    catch (error) {
+                        return { kind: 'error', text: error instanceof Error ? error.message : String(error) };
+                    }
+                    if (this.selectionPolicy?.(suite, spec.resourceName) === false) {
+                        return { kind: 'error', text: this.t('commandNotSelected', { command: name }) };
+                    }
+                    agent.followup(createUserMessage({
+                        content: [{ type: 'text', text }],
+                        source: pluginMarketSource()
+                    }));
+                    return { kind: 'success', text: this.t('commandAcknowledged', { command: name }) };
+                }
+            }));
+            if (attempt.kind === 'failed') {
+                diagnostics.push({ suiteId: spec.suiteId, command: spec.name, reason: messageOf(attempt.error) });
+                continue;
+            }
+            this.live.set(key, attempt.disposer);
+            this.fingerprints.set(key, fingerprint);
+            this.registeredName.set(key, attempt.name);
+            // The panel addresses this document by the resource name it read plus the
+            // suite it belongs to, so the id is built exactly as the panel builds it —
+            // same inputs, same string, one shared cache entry.
+            this.registered.set(key, { name: attempt.name, id: pluginResourceId(spec.sourceId, spec.rawSuiteId, 'commands', spec.resourceName ?? spec.name) });
+            // A renamed command still works, so this is not a failure: it is the
+            // one record that the name a user types is not the name the file
+            // carries, which nothing else in the status surfaces would show.
+            if (attempt.name !== spec.name) {
+                diagnostics.push({
+                    suiteId: spec.suiteId,
+                    command: attempt.name,
+                    reason: `registered as "${attempt.name}" because "${spec.name}" is already taken in this command layer`
+                });
+            }
+        }
+        return diagnostics;
+    }
+    /**
+     * Every command this layer currently holds: the call name the menu row
+     * carries and the panel identity that owns its translation.
+     *
+     * Two files of one suite can flatten to the same call name, so the
+     * registration key (not the name) is what tells those rows apart; each one
+     * keeps its own resource name and therefore its own translation id.
+     * @returns one row per live registration, in registration-key order.
+     */
+    registrations() {
+        return [...this.registered.values()];
+    }
+    /** Dispose every registered command; used at plugin teardown. */
+    disposeAll() {
+        for (const disposer of [...this.live.values()])
+            disposer();
+        for (const key of [...this.registeredName.keys()])
+            this.releaseName(key);
+        this.registered.clear();
+        this.live.clear();
+        this.fingerprints.clear();
+    }
+    /** Free the call name one unmounted key held, so a later claim can reuse it. */
+    releaseName(key) {
+        const name = this.registeredName.get(key);
+        if (name === undefined)
+            return;
+        this.names.forget(name);
+        this.registeredName.delete(key);
+        this.registered.delete(key);
+    }
+}