@fps-games/editor 0.2.1-beta.3 → 0.2.1-beta.4

package/node_modules/@fps-games/editor-browser/dist/local-editor-command-center.js

@@ -0,0 +1,650 @@
+import {} from '@fps-games/editor-protocol';
+export function listLocalEditorCommandMenuEntries(entries) {
+    return entries.flatMap(entry => {
+        const menu = entry.manifest.presentation?.menu;
+        return menu?.path.length ? [{
+                entry,
+                path: [...menu.path],
+                ...(menu.group ? { group: menu.group } : {}),
+                order: menu.order ?? 0,
+            }] : [];
+    }).sort((left, right) => (left.path[0].localeCompare(right.path[0])
+        || (left.group ?? '').localeCompare(right.group ?? '')
+        || left.order - right.order
+        || left.path.join('/').localeCompare(right.path.join('/'))
+        || left.entry.manifest.id.localeCompare(right.entry.manifest.id)));
+}
+export function matchesLocalEditorCommandShortcut(shortcut, event) {
+    if (!shortcut?.trim())
+        return false;
+    return shortcut.split(/\s*\/\s*/).some(alternative => {
+        const tokens = alternative.split('+').map(token => token.trim().toLocaleLowerCase()).filter(Boolean);
+        const key = tokens[tokens.length - 1];
+        if (!key)
+            return false;
+        const modifiers = new Set(tokens.slice(0, -1));
+        const hasMod = modifiers.has('mod');
+        const requiresCtrl = modifiers.has('ctrl');
+        const requiresMeta = modifiers.has('meta') || modifiers.has('cmd');
+        if (hasMod ? !(event.metaKey || event.ctrlKey) : (!!event.ctrlKey !== requiresCtrl || !!event.metaKey !== requiresMeta))
+            return false;
+        if (!!event.shiftKey !== modifiers.has('shift'))
+            return false;
+        if (!!event.altKey !== modifiers.has('alt'))
+            return false;
+        return event.key.toLocaleLowerCase() === key;
+    });
+}
+export function createLocalEditorCommandPresentationCatalog(loadEntries) {
+    let disposed = false;
+    let generation = 0;
+    let entries = new Map();
+    let pendingRefresh = null;
+    const catalog = Object.freeze({
+        get(commandId) {
+            return entries.get(commandId);
+        },
+        refresh() {
+            if (disposed)
+                return Promise.resolve(false);
+            if (pendingRefresh)
+                return pendingRefresh;
+            const refreshGeneration = generation;
+            const refresh = (async () => {
+                try {
+                    const loadedEntries = await loadEntries();
+                    if (disposed || refreshGeneration !== generation)
+                        return false;
+                    entries = new Map(loadedEntries.map(entry => [entry.manifest.id, entry]));
+                    return true;
+                }
+                catch {
+                    // Keep the last complete catalog for future shortcut matching, but
+                    // fail this attempt closed because availability could be stale.
+                    return false;
+                }
+            })();
+            pendingRefresh = refresh;
+            void refresh.finally(() => {
+                if (pendingRefresh === refresh)
+                    pendingRefresh = null;
+            });
+            return refresh;
+        },
+        queueShortcut(commandId, event, canInvoke, invoke) {
+            if (disposed)
+                return false;
+            const currentEntry = entries.get(commandId);
+            if (!currentEntry) {
+                // An empty cache may be the result of a transient initial failure.
+                // Recover without guessing a literal shortcut or consuming the event.
+                void catalog.refresh();
+                return false;
+            }
+            if (!matchesLocalEditorCommandShortcut(currentEntry.manifest.presentation?.shortcut, event)) {
+                return false;
+            }
+            event.preventDefault();
+            const shortcutEvent = {
+                key: event.key,
+                metaKey: event.metaKey,
+                ctrlKey: event.ctrlKey,
+                shiftKey: event.shiftKey,
+                altKey: event.altKey,
+            };
+            void catalog.refresh().then((refreshed) => {
+                if (!refreshed
+                    || disposed
+                    || !canInvoke()) {
+                    return;
+                }
+                const refreshedEntry = entries.get(commandId);
+                if (refreshedEntry?.availability.available === true
+                    && matchesLocalEditorCommandShortcut(refreshedEntry.manifest.presentation?.shortcut, shortcutEvent)) {
+                    invoke();
+                }
+            });
+            return true;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            generation += 1;
+            entries.clear();
+        },
+    });
+    return catalog;
+}
+export function applyLocalEditorCommandSelection(manifest, input, selection) {
+    const result = { ...input };
+    const binding = manifest.presentation?.selectionBinding;
+    if (binding?.selectedIds && selection.selectedIds.length)
+        result[binding.selectedIds] = [...selection.selectedIds];
+    if (binding?.activeId && selection.activeId)
+        result[binding.activeId] = selection.activeId;
+    return result;
+}
+export function formatLocalEditorCommandMetadata(manifest) {
+    const shortcut = manifest.presentation?.shortcut;
+    const menuPath = manifest.presentation?.menu?.path.join(' / ');
+    return `${manifest.presentation?.category ?? 'General'} · ${manifest.target} · ${manifest.access} · ${manifest.effects.persistence}${menuPath ? ` · ${menuPath}` : ''}${shortcut ? ` · ${shortcut}` : ''}`;
+}
+const HISTORY_LIMIT = 50;
+export function parseLocalEditorCommandConsole(input) {
+    const source = input.trim();
+    if (!source)
+        throw new Error('Command Console input is empty.');
+    const firstSpace = source.search(/\s/);
+    const command = firstSpace < 0 ? source : source.slice(0, firstSpace);
+    const remainder = firstSpace < 0 ? '' : source.slice(firstSpace).trim();
+    if (command === 'help')
+        return { kind: 'help', ...(remainder ? { commandId: remainder } : {}) };
+    if (command === 'search') {
+        if (!remainder)
+            throw new Error('search requires a query.');
+        return { kind: 'search', query: remainder };
+    }
+    if (command === 'history') {
+        if (remainder)
+            throw new Error('history does not accept arguments.');
+        return { kind: 'history' };
+    }
+    if (command === 'rerun') {
+        const index = Number(remainder);
+        if (!Number.isSafeInteger(index) || index < 1)
+            throw new Error('rerun requires a positive history index.');
+        return { kind: 'rerun', index };
+    }
+    let parsed = {};
+    if (remainder) {
+        try {
+            parsed = JSON.parse(remainder);
+        }
+        catch (error) {
+            throw new Error(`Command input must be JSON: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { kind: 'invoke', commandId: command, input: toJsonValue(parsed) };
+}
+export function createLocalEditorCommandCenter(options) {
+    const doc = options.document;
+    const storageKey = `fps-editor-command-center:${options.client.serviceInstanceId}`;
+    const history = readHistory(doc, `${storageKey}:history`);
+    const favorites = new Set(readStringList(doc, `${storageKey}:favorites`));
+    let disposed = false;
+    let open = false;
+    let searchGeneration = 0;
+    let selectedIndex = 0;
+    let entries = [];
+    const root = doc.createElement('div');
+    root.className = 'fps-editor-ui-command-center';
+    root.dataset.editorCommandCenter = 'true';
+    root.dataset.editorWorkbenchRegion = 'modal';
+    root.style.cssText = [
+        'position:fixed', 'inset:0', 'z-index:2147483643', 'display:none',
+        'align-items:flex-start', 'justify-content:center', 'padding:10vh 24px 24px',
+        'background:rgba(0,0,0,.42)', 'font-family:var(--fps-editor-font)',
+        'color:var(--fps-editor-text)', 'pointer-events:auto',
+    ].join(';');
+    const panel = doc.createElement('section');
+    panel.setAttribute('role', 'dialog');
+    panel.setAttribute('aria-modal', 'true');
+    panel.setAttribute('aria-label', 'Command Center');
+    panel.style.cssText = [
+        'width:min(760px,calc(100vw - 48px))', 'max-height:78vh', 'display:flex',
+        'flex-direction:column', 'overflow:hidden', 'border:1px solid var(--fps-editor-border)',
+        'border-radius:6px', 'background:var(--fps-editor-panel)',
+        'box-shadow:var(--fps-editor-shadow-modal)',
+    ].join(';');
+    const search = doc.createElement('input');
+    search.type = 'search';
+    search.placeholder = '搜索命令，或按 Tab 打开 Console';
+    search.setAttribute('aria-label', '搜索编辑器命令');
+    search.style.cssText = [
+        'height:42px', 'padding:0 14px', 'border:0',
+        'border-bottom:1px solid var(--fps-editor-border)', 'outline:none',
+        'background:var(--fps-editor-field)', 'color:var(--fps-editor-text-strong)',
+        'font:inherit',
+    ].join(';');
+    const tabs = doc.createElement('div');
+    tabs.style.cssText = 'display:flex;gap:4px;padding:6px 8px;border-bottom:1px solid var(--fps-editor-border-soft);background:var(--fps-editor-panel-soft)';
+    const paletteTab = button('Palette');
+    const menuTab = button('Menus');
+    const consoleTab = button('Console');
+    tabs.append(paletteTab, menuTab, consoleTab);
+    const list = doc.createElement('div');
+    list.setAttribute('role', 'listbox');
+    list.style.cssText = 'min-height:160px;overflow:auto;padding:6px';
+    const menuSurface = doc.createElement('div');
+    menuSurface.setAttribute('role', 'menu');
+    menuSurface.style.cssText = 'display:none;min-height:160px;overflow:auto;padding:8px';
+    const consoleSurface = doc.createElement('div');
+    consoleSurface.style.cssText = 'display:none;flex-direction:column;gap:8px;padding:10px';
+    const consoleInput = doc.createElement('textarea');
+    consoleInput.rows = 4;
+    consoleInput.placeholder = '<command-id> [JSON] · help · search · history · rerun';
+    consoleInput.setAttribute('aria-label', 'Command Console input');
+    consoleInput.style.cssText = [
+        'width:100%', 'box-sizing:border-box', 'resize:vertical', 'padding:9px',
+        'border:1px solid var(--fps-editor-editable-border)', 'border-radius:3px',
+        'background:var(--fps-editor-editable-bg)', 'color:var(--fps-editor-text)',
+        'font:12px/1.5 var(--fps-editor-mono-font,monospace)',
+    ].join(';');
+    const consoleActions = doc.createElement('div');
+    consoleActions.style.cssText = 'display:flex;gap:6px;justify-content:flex-end';
+    const useSelectionButton = button('使用当前 Selection');
+    const runButton = button('运行');
+    consoleActions.append(useSelectionButton, runButton);
+    const output = doc.createElement('pre');
+    output.dataset.editorCommandOutput = 'true';
+    output.style.cssText = [
+        'min-height:90px', 'max-height:240px', 'overflow:auto', 'margin:0', 'padding:9px',
+        'border:1px solid var(--fps-editor-readonly-border)', 'border-radius:3px',
+        'background:var(--fps-editor-readonly-bg)', 'color:var(--fps-editor-readonly-text)',
+        'font:11px/1.45 var(--fps-editor-mono-font,monospace)', 'white-space:pre-wrap',
+    ].join(';');
+    consoleSurface.append(consoleInput, consoleActions, output);
+    const footer = doc.createElement('div');
+    footer.style.cssText = 'display:flex;justify-content:space-between;padding:6px 10px;border-top:1px solid var(--fps-editor-border-soft);color:var(--fps-editor-muted);font-size:11px';
+    footer.textContent = '↑↓ 选择 · Enter 运行 · Tab Console · Esc 关闭';
+    panel.append(search, tabs, list, menuSurface, consoleSurface, footer);
+    root.appendChild(panel);
+    options.host.appendChild(root);
+    const onGlobalKeyDown = (event) => {
+        const key = event.key.toLocaleLowerCase();
+        if (!open && (event.metaKey || event.ctrlKey) && event.shiftKey && key === 'p') {
+            event.preventDefault();
+            void controller.open();
+            return;
+        }
+        if (!open)
+            return;
+        if (key === 'escape') {
+            event.preventDefault();
+            controller.close();
+            return;
+        }
+        if (key === 'tab') {
+            event.preventDefault();
+            showConsole(consoleSurface.style.display === 'none');
+            return;
+        }
+        if (consoleSurface.style.display !== 'none') {
+            if ((event.metaKey || event.ctrlKey) && key === 'enter') {
+                event.preventDefault();
+                void runConsole();
+            }
+            return;
+        }
+        if (menuSurface.style.display !== 'none')
+            return;
+        if (key === 'arrowdown' || key === 'arrowup') {
+            event.preventDefault();
+            if (entries.length)
+                selectedIndex = (selectedIndex + (key === 'arrowdown' ? 1 : -1) + entries.length) % entries.length;
+            renderEntries();
+            return;
+        }
+        if (key === 'enter') {
+            event.preventDefault();
+            const entry = entries[selectedIndex];
+            if (entry)
+                void activateEntry(entry);
+        }
+    };
+    const onSearchInput = () => { void refresh(search.value); };
+    const onRootClick = (event) => { if (event.target === root)
+        controller.close(); };
+    const onPaletteTab = () => showConsole(false);
+    const onMenuTab = () => showMenu();
+    const onConsoleTab = () => showConsole(true);
+    const onRun = () => { void runConsole(); };
+    const onUseSelection = () => { void injectSelection(); };
+    doc.addEventListener('keydown', onGlobalKeyDown);
+    search.addEventListener('input', onSearchInput);
+    root.addEventListener('click', onRootClick);
+    paletteTab.addEventListener('click', onPaletteTab);
+    menuTab.addEventListener('click', onMenuTab);
+    consoleTab.addEventListener('click', onConsoleTab);
+    runButton.addEventListener('click', onRun);
+    useSelectionButton.addEventListener('click', onUseSelection);
+    const controller = Object.freeze({
+        root,
+        async open(query = '') {
+            if (disposed)
+                throw new Error('Command Center is disposed.');
+            open = true;
+            root.style.display = 'flex';
+            options.onOpenChange?.(true);
+            search.value = query;
+            showConsole(false);
+            await refresh(query);
+            search.focus();
+        },
+        close() {
+            if (!open)
+                return;
+            open = false;
+            root.style.display = 'none';
+            options.onOpenChange?.(false);
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            controller.close();
+            doc.removeEventListener('keydown', onGlobalKeyDown);
+            search.removeEventListener('input', onSearchInput);
+            root.removeEventListener('click', onRootClick);
+            paletteTab.removeEventListener('click', onPaletteTab);
+            menuTab.removeEventListener('click', onMenuTab);
+            consoleTab.removeEventListener('click', onConsoleTab);
+            runButton.removeEventListener('click', onRun);
+            useSelectionButton.removeEventListener('click', onUseSelection);
+            root.remove();
+        },
+    });
+    return controller;
+    async function refresh(query) {
+        const generation = ++searchGeneration;
+        const response = await options.client.request(query.trim()
+            ? { kind: 'commands.search', query: query.trim(), limit: 100 }
+            : { kind: 'commands.list', limit: 100 });
+        if (generation !== searchGeneration || disposed || !response.ok || response.kind !== 'commands')
+            return;
+        entries = [...response.page.commands].sort((left, right) => {
+            const leftFavorite = favorites.has(left.manifest.id) ? 1 : 0;
+            const rightFavorite = favorites.has(right.manifest.id) ? 1 : 0;
+            return rightFavorite - leftFavorite || left.manifest.id.localeCompare(right.manifest.id);
+        });
+        selectedIndex = Math.min(selectedIndex, Math.max(0, entries.length - 1));
+        renderEntries();
+        renderMenus();
+    }
+    function renderMenus() {
+        menuSurface.replaceChildren();
+        let currentSection = '';
+        let section = null;
+        for (const item of listLocalEditorCommandMenuEntries(entries)) {
+            const sectionName = item.path[0];
+            if (sectionName !== currentSection) {
+                currentSection = sectionName;
+                section = doc.createElement('section');
+                section.style.cssText = 'display:flex;flex-direction:column;gap:3px;margin-bottom:10px';
+                const heading = doc.createElement('h3');
+                heading.textContent = sectionName;
+                heading.style.cssText = 'margin:0 0 3px;padding:0 6px;color:var(--fps-editor-muted-strong);font-size:11px;font-weight:800';
+                section.appendChild(heading);
+                menuSurface.appendChild(section);
+            }
+            const menuButton = button(item.path.slice(1).join(' / ') || item.entry.manifest.title);
+            menuButton.setAttribute('role', 'menuitem');
+            menuButton.disabled = !item.entry.availability.available;
+            menuButton.style.cssText += [
+                'width:100%',
+                'justify-content:space-between',
+                'text-align:left',
+                `opacity:${item.entry.availability.available ? '1' : '.45'}`,
+            ].join(';');
+            const shortcut = item.entry.manifest.presentation?.shortcut;
+            if (shortcut) {
+                const shortcutLabel = doc.createElement('span');
+                shortcutLabel.textContent = shortcut;
+                shortcutLabel.style.cssText = 'margin-left:auto;color:var(--fps-editor-muted);font-size:10px';
+                menuButton.appendChild(shortcutLabel);
+            }
+            if (!item.entry.availability.available) {
+                menuButton.title = item.entry.availability.reasons.map(reason => reason.message).join('; ');
+            }
+            menuButton.addEventListener('click', () => { void activateEntry(item.entry); });
+            section?.appendChild(menuButton);
+        }
+    }
+    function renderEntries() {
+        list.replaceChildren();
+        entries.forEach((entry, index) => {
+            const row = doc.createElement('button');
+            row.type = 'button';
+            row.setAttribute('role', 'option');
+            row.setAttribute('aria-selected', index === selectedIndex ? 'true' : 'false');
+            row.disabled = !entry.availability.available;
+            row.style.cssText = [
+                'width:100%', 'display:grid', 'grid-template-columns:minmax(0,1fr) auto', 'gap:8px',
+                'padding:8px 10px', 'border:0', 'border-radius:3px', 'text-align:left',
+                `background:${index === selectedIndex ? 'var(--fps-editor-row-selected)' : 'transparent'}`,
+                `color:${index === selectedIndex ? 'var(--fps-editor-row-selected-text)' : 'var(--fps-editor-text)'}`,
+                `opacity:${entry.availability.available ? '1' : '.45'}`,
+                `cursor:${entry.availability.available ? 'pointer' : 'not-allowed'}`,
+            ].join(';');
+            const main = doc.createElement('span');
+            main.style.cssText = 'min-width:0;display:flex;flex-direction:column;gap:2px';
+            const title = doc.createElement('strong');
+            title.textContent = `${favorites.has(entry.manifest.id) ? '★ ' : ''}${entry.manifest.title}`;
+            const id = doc.createElement('span');
+            id.textContent = entry.manifest.id;
+            id.style.cssText = 'color:var(--fps-editor-muted);font:11px var(--fps-editor-mono-font,monospace);overflow:hidden;text-overflow:ellipsis';
+            main.append(title, id);
+            if (!entry.availability.available) {
+                const reasonText = doc.createElement('span');
+                reasonText.textContent = entry.availability.reasons.map(item => item.message).join('; ');
+                reasonText.style.cssText = 'color:var(--fps-editor-disabled-text);font-size:10px';
+                main.append(reasonText);
+            }
+            const meta = doc.createElement('span');
+            meta.textContent = formatLocalEditorCommandMetadata(entry.manifest);
+            meta.style.cssText = 'align-self:center;color:var(--fps-editor-muted-strong);font-size:10px;white-space:nowrap';
+            row.append(main, meta);
+            if (!entry.availability.available) {
+                const reason = entry.availability.reasons.map(item => item.message).join('; ');
+                row.title = reason;
+                row.setAttribute('aria-description', reason);
+            }
+            row.addEventListener('pointerenter', () => { selectedIndex = index; }, { once: true });
+            row.addEventListener('click', () => { selectedIndex = index; void activateEntry(entry); });
+            row.addEventListener('contextmenu', (event) => {
+                event.preventDefault();
+                if (favorites.has(entry.manifest.id))
+                    favorites.delete(entry.manifest.id);
+                else
+                    favorites.add(entry.manifest.id);
+                writeStringList(doc, `${storageKey}:favorites`, [...favorites]);
+                void refresh(search.value);
+            });
+            list.appendChild(row);
+        });
+    }
+    async function activateEntry(entry) {
+        if (!entry.availability.available)
+            return;
+        if (canInvokeWithoutInput(entry.manifest)) {
+            await invoke(entry.manifest, {});
+            return;
+        }
+        showConsole(true);
+        consoleInput.value = `${entry.manifest.id} ${JSON.stringify(createSchemaInputTemplate(entry.manifest.inputSchema), null, 2)}`;
+        consoleInput.focus();
+    }
+    function showConsole(value) {
+        consoleSurface.style.display = value ? 'flex' : 'none';
+        menuSurface.style.display = 'none';
+        list.style.display = value ? 'none' : 'block';
+        search.style.display = value ? 'none' : 'block';
+        paletteTab.style.background = value ? 'var(--fps-editor-button)' : 'var(--fps-editor-button-active)';
+        menuTab.style.background = 'var(--fps-editor-button)';
+        consoleTab.style.background = value ? 'var(--fps-editor-button-active)' : 'var(--fps-editor-button)';
+        if (value)
+            consoleInput.focus();
+        else
+            search.focus();
+    }
+    function showMenu() {
+        consoleSurface.style.display = 'none';
+        list.style.display = 'none';
+        menuSurface.style.display = 'block';
+        search.style.display = 'none';
+        paletteTab.style.background = 'var(--fps-editor-button)';
+        menuTab.style.background = 'var(--fps-editor-button-active)';
+        consoleTab.style.background = 'var(--fps-editor-button)';
+    }
+    async function runConsole() {
+        try {
+            const instruction = parseLocalEditorCommandConsole(consoleInput.value);
+            if (instruction.kind === 'help') {
+                if (!instruction.commandId) {
+                    output.textContent = '语法: <command-id> [JSON] | help [id] | search <query> | history | rerun <index>';
+                    return;
+                }
+                output.textContent = format(await options.client.request({ kind: 'commands.describe', commandId: instruction.commandId }));
+                return;
+            }
+            if (instruction.kind === 'search') {
+                showConsole(false);
+                search.value = instruction.query;
+                await refresh(instruction.query);
+                return;
+            }
+            if (instruction.kind === 'history') {
+                output.textContent = format(history.map((entry, index) => ({ index: index + 1, commandId: entry.commandId, input: entry.input, status: entry.operation?.status, timestamp: entry.timestamp })));
+                return;
+            }
+            if (instruction.kind === 'rerun') {
+                const previous = history[instruction.index - 1];
+                if (!previous)
+                    throw new Error(`History entry does not exist: ${instruction.index}`);
+                const manifest = await describe(previous.commandId);
+                await invoke(manifest, previous.input);
+                return;
+            }
+            const manifest = await describe(instruction.commandId);
+            await invoke(manifest, instruction.input);
+        }
+        catch (error) {
+            output.textContent = format({ ok: false, error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    async function describe(commandId) {
+        const response = await options.client.request({ kind: 'commands.describe', commandId });
+        if (!response.ok || response.kind !== 'command' || !response.command)
+            throw new Error(`Command is not registered: ${commandId}`);
+        if (!response.command.availability.available)
+            throw new Error(response.command.availability.reasons.map(reason => reason.message).join('; ') || `Command is unavailable: ${commandId}`);
+        return response.command.manifest;
+    }
+    async function invoke(manifest, input) {
+        const requestId = createId();
+        let expectedServiceRevision;
+        let expectedServiceInstanceId;
+        if (manifest.access === 'write') {
+            const status = await options.client.request({ kind: 'status' });
+            if (!status.ok || status.kind !== 'status')
+                throw new Error('Editor Service status is unavailable.');
+            expectedServiceRevision = status.status.documentRevision;
+            expectedServiceInstanceId = status.status.serviceInstanceId;
+        }
+        const invocation = {
+            commandId: manifest.id,
+            input,
+            requestId,
+            ...(manifest.access === 'write' ? { idempotencyKey: createId() } : {}),
+            ...(expectedServiceRevision !== undefined ? {
+                expectedRevision: {
+                    serviceInstanceId: expectedServiceInstanceId,
+                    document: expectedServiceRevision,
+                },
+            } : {}),
+            principal: { type: 'human' },
+            source: 'browser-ui',
+            ...(options.clientId ? { clientId: options.clientId } : {}),
+        };
+        const response = await options.client.request({ kind: 'command.invoke', invocation, timeoutMs: 10000 });
+        const operation = response.ok && response.kind === 'operation' ? response.operation : null;
+        history.unshift({ commandId: manifest.id, input, operation, timestamp: Date.now() });
+        history.splice(HISTORY_LIMIT);
+        writeHistory(doc, `${storageKey}:history`, history);
+        output.textContent = format(response);
+        showConsole(true);
+    }
+    async function injectSelection() {
+        const selection = options.getSelectionIds?.();
+        if (!selection)
+            return;
+        let instruction;
+        try {
+            instruction = parseLocalEditorCommandConsole(consoleInput.value);
+        }
+        catch {
+            return;
+        }
+        if (instruction.kind !== 'invoke' || !instruction.input || typeof instruction.input !== 'object' || Array.isArray(instruction.input))
+            return;
+        const manifest = await describe(instruction.commandId);
+        const input = applyLocalEditorCommandSelection(manifest, instruction.input, selection);
+        consoleInput.value = `${instruction.commandId} ${JSON.stringify(input, null, 2)}`;
+    }
+    function button(label) {
+        const element = doc.createElement('button');
+        element.type = 'button';
+        element.textContent = label;
+        element.style.cssText = 'padding:5px 9px;border:1px solid var(--fps-editor-border);border-radius:3px;background:var(--fps-editor-button);color:var(--fps-editor-text);font:inherit;cursor:pointer';
+        return element;
+    }
+}
+function canInvokeWithoutInput(manifest) {
+    const required = manifest.inputSchema.required;
+    return manifest.presentation?.inputMode === 'none' || !Array.isArray(required) || required.length === 0;
+}
+function createSchemaInputTemplate(schema) {
+    const result = {};
+    const properties = schema.properties;
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    if (!properties || typeof properties !== 'object' || Array.isArray(properties))
+        return result;
+    for (const key of required) {
+        if (typeof key !== 'string')
+            continue;
+        const property = properties[key];
+        result[key] = property?.default ?? (property?.type === 'array' ? [] : property?.type === 'number' ? 0 : property?.type === 'boolean' ? false : property?.type === 'object' ? {} : '');
+    }
+    return result;
+}
+function readHistory(doc, key) {
+    try {
+        const value = JSON.parse(doc.defaultView?.localStorage.getItem(key) ?? '[]');
+        return Array.isArray(value) ? value.slice(0, HISTORY_LIMIT) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeHistory(doc, key, history) {
+    try {
+        doc.defaultView?.localStorage.setItem(key, JSON.stringify(history));
+    }
+    catch { /* client-local storage is optional */ }
+}
+function readStringList(doc, key) {
+    try {
+        const value = JSON.parse(doc.defaultView?.localStorage.getItem(key) ?? '[]');
+        return Array.isArray(value) ? value.filter(entry => typeof entry === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeStringList(doc, key, value) {
+    try {
+        doc.defaultView?.localStorage.setItem(key, JSON.stringify(value));
+    }
+    catch { /* client-local storage is optional */ }
+}
+function format(value) {
+    return JSON.stringify(value, null, 2);
+}
+function createId() {
+    return globalThis.crypto?.randomUUID?.() ?? `command-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function toJsonValue(value) {
+    return JSON.parse(JSON.stringify(value ?? null));
+}
+//# sourceMappingURL=local-editor-command-center.js.map