mdast-control 0.1.0

package/dist/plugins.js

@@ -0,0 +1,833 @@
+import { parseMarkdown, stringifyAst } from './markdown.js';
+import { MDAST_REQUEST_METHODS } from './lsp-methods.js';
+import { queryAst } from './query.js';
+import { tableToDelimited } from './table.js';
+export class PluginOperationError extends Error {
+    code;
+    plugin;
+    operation;
+    details;
+    constructor(shape) {
+        super(shape.message);
+        this.name = 'PluginOperationError';
+        this.code = shape.code;
+        this.plugin = shape.plugin;
+        this.operation = shape.operation;
+        this.details = shape.details;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            plugin: this.plugin,
+            operation: this.operation,
+            message: this.message,
+            ...(this.details === undefined ? {} : { details: structuredClone(this.details) }),
+        };
+    }
+}
+const CORE_CAPABILITIES = {
+    queryOperators: ['=', '*=', '^=', '$=', '!=', '~=', '>', '>=', '<', '<='],
+    genericOperations: ['query', 'insert', 'delete', 'replace', 'wrap', 'unwrap', 'move', 'copy'],
+    customRequests: Object.values(MDAST_REQUEST_METHODS),
+};
+const BUILTIN_PLUGINS = [
+    {
+        id: 'table',
+        version: '0.1.0',
+        elementKinds: ['table', 'tableRow', 'tableCell'],
+        title: 'Table Tools',
+        description: 'Table-oriented query, edit, and CSV/TSV conversion capabilities.',
+        availability: 'available',
+        queryExtensions: [
+            {
+                kind: 'pseudo-field',
+                name: 'rowIndex',
+                targetKinds: ['tableRow', 'tableCell'],
+                valueType: 'number',
+                operators: ['=', '!=', '>', '>=', '<', '<='],
+                description: 'Matches the zero-based body row index for table rows and cells.',
+                availability: 'available',
+            },
+            {
+                kind: 'pseudo-field',
+                name: 'cellText',
+                targetKinds: ['tableCell'],
+                valueType: 'string',
+                operators: ['=', '*=', '^=', '$=', '!=', '~='],
+                description: 'Matches flattened cell text.',
+                availability: 'available',
+            },
+            {
+                kind: 'pseudo-field',
+                name: 'columnIndex',
+                targetKinds: ['tableCell'],
+                valueType: 'number',
+                operators: ['=', '!=', '>', '>=', '<', '<='],
+                description: 'Matches the zero-based column index for a table cell.',
+                availability: 'available',
+            },
+            {
+                kind: 'pseudo-field',
+                name: 'headerText',
+                targetKinds: ['tableCell'],
+                valueType: 'string',
+                operators: ['=', '*=', '^=', '$=', '!=', '~='],
+                description: 'Matches the header text for a cell column.',
+                availability: 'available',
+            },
+            {
+                kind: 'pseudo-field',
+                name: 'rowCount',
+                targetKinds: ['table'],
+                valueType: 'number',
+                operators: ['=', '!=', '>', '>=', '<', '<='],
+                description: 'Matches the number of body rows in a normalized table.',
+                availability: 'available',
+            },
+            {
+                kind: 'pseudo-field',
+                name: 'columnCount',
+                targetKinds: ['table'],
+                valueType: 'number',
+                operators: ['=', '!=', '>', '>=', '<', '<='],
+                description: 'Matches the normalized logical width of a table.',
+                availability: 'available',
+            },
+        ],
+        operations: [
+            {
+                name: 'updateCell',
+                title: 'Update Table Cell',
+                description: 'Replace the content of matched table cells.',
+                targetKinds: ['tableCell'],
+                targetCardinality: 'zero-or-more',
+                category: 'edit',
+                params: [
+                    {
+                        name: 'markdown',
+                        type: 'string',
+                        required: true,
+                        description: 'Replacement markdown for the target cell.',
+                    },
+                ],
+                result: {
+                    type: 'mutation',
+                    shapeDescription: 'Updated markdown plus changed count.',
+                },
+                availability: 'available',
+                stability: 'experimental',
+            },
+            {
+                name: 'exportDelimited',
+                title: 'Export Delimited Table',
+                description: 'Convert a matched table into CSV or TSV text.',
+                targetKinds: ['table'],
+                targetCardinality: 'exactly-one',
+                category: 'convert',
+                params: [
+                    {
+                        name: 'format',
+                        type: 'enum',
+                        required: true,
+                        description: 'Delimited output format.',
+                        enumValues: ['csv', 'tsv'],
+                    },
+                    {
+                        name: 'includeHeader',
+                        type: 'boolean',
+                        required: false,
+                        description: 'Include the header row; defaults to true.',
+                        defaultValue: true,
+                    },
+                    {
+                        name: 'lineTerminator',
+                        type: 'enum',
+                        required: false,
+                        description: 'Output record separator.',
+                        enumValues: ['lf', 'crlf'],
+                        defaultValue: 'lf',
+                    },
+                    {
+                        name: 'quoteMode',
+                        type: 'enum',
+                        required: false,
+                        description: 'Quote only required fields or every field.',
+                        enumValues: ['minimal', 'always'],
+                        defaultValue: 'minimal',
+                    },
+                ],
+                result: {
+                    type: 'text',
+                    shapeDescription: 'Delimited text for the matched table.',
+                },
+                availability: 'available',
+                stability: 'experimental',
+            },
+        ],
+        converters: [
+            {
+                name: 'markdownTableToCsv',
+                sourceFormat: 'markdown-table',
+                targetFormat: 'csv',
+                description: 'Converts a markdown table to CSV.',
+                params: [],
+                availability: 'available',
+            },
+            {
+                name: 'markdownTableToTsv',
+                sourceFormat: 'markdown-table',
+                targetFormat: 'tsv',
+                description: 'Converts a markdown table to TSV.',
+                params: [],
+                availability: 'available',
+            },
+        ],
+        handlers: {
+            updateCell: ({ markdown, query, args }) => {
+                const tree = parseMarkdown(markdown);
+                const matches = queryAst(tree, query);
+                const replacement = parseTableCellChildren(readRequiredStringArg(args, 'markdown'));
+                for (const match of matches) {
+                    if (match.node.type !== 'tableCell') {
+                        throw new Error(`Operation "table/updateCell" requires tableCell matches, received "${match.node.type}"`);
+                    }
+                    match.node.children = replacement.map((child) => structuredClone(child));
+                }
+                return {
+                    kind: 'mutation',
+                    changed: matches.length,
+                    markdown: stringifyAst(tree),
+                };
+            },
+            exportDelimited: ({ markdown, query, args }) => {
+                const format = readRequiredEnumArg(args, 'format', ['csv', 'tsv']);
+                const lineTerminator = readOptionalEnumArg(args, 'lineTerminator', ['lf', 'crlf']) ?? 'lf';
+                const quoteMode = readOptionalEnumArg(args, 'quoteMode', ['minimal', 'always']) ?? 'minimal';
+                return {
+                    kind: 'text',
+                    text: tableToDelimited(markdown, query, format, {
+                        includeHeader: readOptionalBooleanArg(args, 'includeHeader') ?? true,
+                        lineTerminator: lineTerminator === 'crlf' ? '\r\n' : '\n',
+                        quoteMode: quoteMode,
+                    }),
+                };
+            },
+        },
+    },
+    {
+        id: 'codeBlock',
+        version: '0.1.0',
+        elementKinds: ['code'],
+        title: 'Code Block Tools',
+        description: 'Code-block-specific edit, analyze, and conversion capabilities.',
+        availability: 'available',
+        operations: [
+            {
+                name: 'setLanguage',
+                title: 'Set Code Block Language',
+                description: 'Set or clear the language token on matched code blocks.',
+                targetKinds: ['code'],
+                targetCardinality: 'one-or-more',
+                category: 'edit',
+                params: [
+                    {
+                        name: 'language',
+                        type: 'string',
+                        required: true,
+                        description: 'Fence language token; an empty string clears it.',
+                    },
+                ],
+                result: {
+                    type: 'mutation',
+                    shapeDescription: 'Updated markdown plus changed count.',
+                },
+                availability: 'available',
+                stability: 'experimental',
+            },
+            {
+                name: 'replaceContent',
+                title: 'Replace Code Block Content',
+                description: 'Replace the literal content of matched code blocks.',
+                targetKinds: ['code'],
+                targetCardinality: 'one-or-more',
+                category: 'edit',
+                params: [
+                    {
+                        name: 'text',
+                        type: 'string',
+                        required: true,
+                        description: 'Literal replacement content.',
+                    },
+                ],
+                result: {
+                    type: 'mutation',
+                    shapeDescription: 'Updated markdown plus changed count.',
+                },
+                availability: 'available',
+                stability: 'experimental',
+            },
+            {
+                name: 'appendContent',
+                title: 'Append Code Block Content',
+                description: 'Append literal content to matched code blocks without an implicit separator.',
+                targetKinds: ['code'],
+                targetCardinality: 'one-or-more',
+                category: 'edit',
+                params: [
+                    {
+                        name: 'text',
+                        type: 'string',
+                        required: true,
+                        description: 'Literal content appended exactly as supplied.',
+                    },
+                ],
+                result: {
+                    type: 'mutation',
+                    shapeDescription: 'Updated markdown plus changed count.',
+                },
+                availability: 'available',
+                stability: 'experimental',
+            },
+            {
+                name: 'extractContent',
+                title: 'Extract Code Block Content',
+                description: 'Return the literal content of exactly one code block.',
+                targetKinds: ['code'],
+                targetCardinality: 'exactly-one',
+                category: 'convert',
+                params: [],
+                result: {
+                    type: 'text',
+                    shapeDescription: 'Literal code block content.',
+                },
+                availability: 'available',
+                stability: 'experimental',
+            },
+            {
+                name: 'validateContent',
+                title: 'Validate Code Block Content',
+                description: 'Validate matched code blocks using a plugin-owned deterministic format validator.',
+                targetKinds: ['code'],
+                targetCardinality: 'one-or-more',
+                category: 'analyze',
+                params: [
+                    {
+                        name: 'format',
+                        type: 'enum',
+                        required: true,
+                        description: 'Validation format.',
+                        enumValues: ['json'],
+                    },
+                ],
+                result: {
+                    type: 'json',
+                    shapeDescription: 'Validation summary with one issue per invalid matched block.',
+                },
+                availability: 'available',
+                stability: 'experimental',
+            },
+            {
+                name: 'formatContent',
+                title: 'Format Code Block Content',
+                description: 'Format matched code blocks using a plugin-owned deterministic formatter.',
+                targetKinds: ['code'],
+                targetCardinality: 'one-or-more',
+                category: 'edit',
+                params: [
+                    {
+                        name: 'format',
+                        type: 'enum',
+                        required: true,
+                        description: 'Formatting language.',
+                        enumValues: ['json'],
+                    },
+                    {
+                        name: 'indent',
+                        type: 'number',
+                        required: false,
+                        description: 'JSON indentation width from 0 through 10.',
+                        defaultValue: 2,
+                    },
+                ],
+                result: {
+                    type: 'mutation',
+                    shapeDescription: 'Updated markdown plus changed count.',
+                },
+                availability: 'available',
+                stability: 'experimental',
+            },
+        ],
+        converters: [
+            {
+                name: 'codeBlockToText',
+                sourceFormat: 'markdown-code-block',
+                targetFormat: 'text',
+                description: 'Extracts literal content from one code block.',
+                params: [],
+                availability: 'available',
+            },
+            {
+                name: 'jsonCodeBlockFormat',
+                sourceFormat: 'json-code-block',
+                targetFormat: 'json-code-block',
+                description: 'Validates and deterministically formats JSON code-block content.',
+                params: [],
+                availability: 'available',
+            },
+        ],
+        handlers: {
+            setLanguage: ({ tree, matches, args }) => {
+                const language = readRequiredStringArg(args, 'language');
+                if (language !== '' && (!/^\S+$/.test(language) || language.includes('`'))) {
+                    throw new Error('Code block language must be empty or a non-whitespace token without backticks');
+                }
+                for (const match of matches) {
+                    match.node.lang = language === '' ? null : language;
+                }
+                return codeMutationResult(tree, matches.length);
+            },
+            replaceContent: ({ tree, matches, args }) => {
+                const text = readRequiredStringArg(args, 'text');
+                for (const match of matches) {
+                    match.node.value = text;
+                }
+                return codeMutationResult(tree, matches.length);
+            },
+            appendContent: ({ tree, matches, args }) => {
+                const text = readRequiredStringArg(args, 'text');
+                for (const match of matches) {
+                    match.node.value = `${typeof match.node.value === 'string' ? match.node.value : ''}${text}`;
+                }
+                return codeMutationResult(tree, matches.length);
+            },
+            extractContent: ({ matches }) => ({
+                kind: 'text',
+                text: readCodeContent(matches[0]),
+            }),
+            validateContent: ({ matches, args }) => {
+                readRequiredEnumArg(args, 'format', ['json']);
+                const issues = matches.flatMap((match) => {
+                    try {
+                        JSON.parse(readCodeContent(match));
+                        return [];
+                    }
+                    catch (error) {
+                        return [{
+                                path: [...match.path],
+                                message: error instanceof Error ? error.message : 'Invalid JSON content',
+                            }];
+                    }
+                });
+                return {
+                    kind: 'json',
+                    value: {
+                        format: 'json',
+                        valid: issues.length === 0,
+                        checked: matches.length,
+                        issues,
+                    },
+                };
+            },
+            formatContent: ({ tree, matches, args }) => {
+                readRequiredEnumArg(args, 'format', ['json']);
+                const indent = readRequiredNumberArg(args, 'indent');
+                if (!Number.isInteger(indent) || indent < 0 || indent > 10) {
+                    throw new Error('JSON indentation must be an integer from 0 through 10');
+                }
+                for (const match of matches) {
+                    match.node.value = JSON.stringify(JSON.parse(readCodeContent(match)), null, indent);
+                }
+                return codeMutationResult(tree, matches.length);
+            },
+        },
+    },
+];
+export class PluginRegistry {
+    core;
+    plugins;
+    byId;
+    byElementKind;
+    constructor(core = CORE_CAPABILITIES, plugins = BUILTIN_PLUGINS) {
+        this.core = cloneCoreCapabilities(core);
+        this.plugins = [];
+        this.byId = new Map();
+        this.byElementKind = new Map();
+        this.registerPlugins(plugins);
+    }
+    registerPlugin(plugin) {
+        if (this.byId.has(plugin.id)) {
+            throw new Error(`Plugin "${plugin.id}" is already registered`);
+        }
+        validatePluginDefinition(plugin, this.plugins);
+        const normalized = cloneRegistryPlugin(plugin);
+        this.plugins.push(normalized);
+        this.byId.set(normalized.id, normalized);
+        for (const kind of normalized.elementKinds) {
+            const plugins = this.byElementKind.get(kind) ?? [];
+            plugins.push(normalized);
+            this.byElementKind.set(kind, plugins);
+        }
+    }
+    registerPlugins(plugins) {
+        for (const plugin of plugins) {
+            this.registerPlugin(plugin);
+        }
+    }
+    getPlugin(id) {
+        const plugin = this.byId.get(id);
+        return plugin ? clonePublicPlugin(plugin) : undefined;
+    }
+    listPlugins() {
+        return this.plugins.map(clonePublicPlugin);
+    }
+    listPluginsForElementKind(kind) {
+        return (this.byElementKind.get(kind) ?? []).map(clonePublicPlugin);
+    }
+    getCapabilities() {
+        return {
+            core: cloneCoreCapabilities(this.core),
+            plugins: this.listPlugins(),
+        };
+    }
+    getPluginCapabilities(pluginId) {
+        return this.getPlugin(pluginId);
+    }
+    getElementCapabilities(elementKind) {
+        return {
+            elementKind,
+            plugins: this.listPluginsForElementKind(elementKind),
+        };
+    }
+    getOperationDescriptor(pluginId, operationName) {
+        const plugin = this.byId.get(pluginId);
+        const operation = plugin?.operations.find((candidate) => candidate.name === operationName);
+        return operation ? cloneOperation(operation) : undefined;
+    }
+    listQueryExtensions() {
+        return this.plugins.flatMap((plugin) => (plugin.queryExtensions ?? []).map(cloneQueryExtension));
+    }
+    runOperation(request) {
+        const plugin = this.byId.get(request.plugin);
+        if (!plugin) {
+            throw pluginError(request, 'unknown-plugin', `Unknown plugin "${request.plugin}"`);
+        }
+        const descriptor = plugin.operations.find((candidate) => candidate.name === request.operation);
+        if (!descriptor) {
+            throw pluginError(request, 'unknown-operation', `Unknown operation "${request.operation}" for plugin "${request.plugin}"`);
+        }
+        if (plugin.availability !== 'available' || descriptor.availability !== 'available') {
+            throw pluginError(request, 'operation-unavailable', `Plugin operation "${request.plugin}/${request.operation}" is not available`);
+        }
+        const args = validateOperationArgs(request, descriptor, request.args ?? {});
+        const handler = plugin.handlers?.[request.operation];
+        if (!handler) {
+            throw pluginError(request, 'operation-unavailable', `Plugin operation "${request.plugin}/${request.operation}" is not implemented`);
+        }
+        let tree;
+        let matches;
+        try {
+            tree = parseMarkdown(request.markdown);
+            matches = queryAst(tree, request.query);
+        }
+        catch (error) {
+            throw pluginError(request, 'invalid-query', `Plugin operation "${request.plugin}/${request.operation}" received an invalid query: ${errorMessage(error)}`);
+        }
+        validateTargetMatches(request, descriptor, matches);
+        try {
+            return handler({
+                markdown: request.markdown,
+                query: request.query,
+                args,
+                descriptor: cloneOperation(descriptor),
+                tree,
+                matches,
+            });
+        }
+        catch (error) {
+            if (error instanceof PluginOperationError) {
+                throw error;
+            }
+            throw pluginError(request, 'semantic-error', `Plugin operation "${request.plugin}/${request.operation}" failed: ${errorMessage(error)}`);
+        }
+    }
+}
+export const defaultPluginRegistry = new PluginRegistry();
+export function getCapabilities() {
+    return defaultPluginRegistry.getCapabilities();
+}
+export function getPluginCapabilities(pluginId) {
+    return defaultPluginRegistry.getPluginCapabilities(pluginId);
+}
+export function getElementCapabilities(elementKind) {
+    return defaultPluginRegistry.getElementCapabilities(elementKind);
+}
+export function getOperationDescriptor(pluginId, operationName) {
+    return defaultPluginRegistry.getOperationDescriptor(pluginId, operationName);
+}
+export function listPlugins() {
+    return defaultPluginRegistry.listPlugins();
+}
+export function listPluginsForElementKind(kind) {
+    return defaultPluginRegistry.listPluginsForElementKind(kind);
+}
+export function listQueryExtensions() {
+    return defaultPluginRegistry.listQueryExtensions();
+}
+export function runPluginOperation(request) {
+    return defaultPluginRegistry.runOperation(request);
+}
+function cloneCoreCapabilities(core) {
+    return {
+        queryOperators: [...core.queryOperators],
+        genericOperations: [...core.genericOperations],
+        customRequests: [...core.customRequests],
+    };
+}
+function cloneRegistryPlugin(plugin) {
+    return {
+        ...plugin,
+        elementKinds: [...plugin.elementKinds],
+        operations: plugin.operations.map(cloneOperation),
+        queryExtensions: plugin.queryExtensions?.map(cloneQueryExtension),
+        converters: plugin.converters?.map(cloneConverter),
+        handlers: plugin.handlers ? { ...plugin.handlers } : undefined,
+    };
+}
+function clonePublicPlugin(plugin) {
+    return {
+        id: plugin.id,
+        version: plugin.version,
+        elementKinds: [...plugin.elementKinds],
+        title: plugin.title,
+        description: plugin.description,
+        availability: plugin.availability,
+        operations: plugin.operations.map(cloneOperation),
+        queryExtensions: plugin.queryExtensions?.map(cloneQueryExtension),
+        converters: plugin.converters?.map(cloneConverter),
+    };
+}
+function cloneOperation(operation) {
+    return {
+        ...operation,
+        targetKinds: [...operation.targetKinds],
+        params: operation.params.map(cloneParam),
+        result: { ...operation.result },
+        examples: operation.examples ? [...operation.examples] : undefined,
+    };
+}
+function cloneQueryExtension(extension) {
+    return {
+        ...extension,
+        targetKinds: [...extension.targetKinds],
+        operators: [...extension.operators],
+    };
+}
+function cloneConverter(converter) {
+    return {
+        ...converter,
+        params: converter.params.map(cloneParam),
+    };
+}
+function cloneParam(param) {
+    return {
+        ...param,
+        enumValues: param.enumValues ? [...param.enumValues] : undefined,
+        ...(param.defaultValue === undefined ? {} : { defaultValue: structuredClone(param.defaultValue) }),
+    };
+}
+function validateOperationArgs(request, descriptor, args) {
+    if (!isRecord(args)) {
+        throw pluginError(request, 'invalid-params', `Operation "${descriptor.name}" requires an object args payload`);
+    }
+    const knownNames = new Set(descriptor.params.map((param) => param.name));
+    const unknownNames = Object.keys(args).filter((name) => !knownNames.has(name));
+    if (unknownNames.length > 0) {
+        throw pluginError(request, 'invalid-params', `Operation "${descriptor.name}" received unknown arg "${unknownNames[0]}"`, { unknownArgs: unknownNames });
+    }
+    const normalized = { ...args };
+    for (const param of descriptor.params) {
+        const value = normalized[param.name];
+        if (value === undefined) {
+            if (param.required) {
+                throw pluginError(request, 'invalid-params', `Operation "${descriptor.name}" requires arg "${param.name}"`, { parameter: param.name });
+            }
+            if (param.defaultValue !== undefined) {
+                normalized[param.name] = structuredClone(param.defaultValue);
+            }
+            continue;
+        }
+        if (!matchesParamType(value, param)) {
+            throw pluginError(request, 'invalid-params', `Operation "${descriptor.name}" received invalid arg "${param.name}"`, { parameter: param.name, expectedType: param.type });
+        }
+    }
+    return normalized;
+}
+function matchesParamType(value, param) {
+    if (param.type === 'json') {
+        return true;
+    }
+    if (param.type === 'enum') {
+        return typeof value === 'string' && (param.enumValues?.includes(value) ?? true);
+    }
+    if (param.type === 'number') {
+        return typeof value === 'number' && Number.isFinite(value);
+    }
+    return typeof value === param.type;
+}
+function validateTargetMatches(request, descriptor, matches) {
+    const count = matches.length;
+    const cardinalityValid = descriptor.targetCardinality === 'zero-or-more'
+        || (descriptor.targetCardinality === 'zero-or-one' && count <= 1)
+        || (descriptor.targetCardinality === 'one-or-more' && count >= 1)
+        || (descriptor.targetCardinality === 'exactly-one' && count === 1);
+    if (!cardinalityValid) {
+        throw pluginError(request, 'target-cardinality', `Operation "${request.plugin}/${request.operation}" requires ${descriptor.targetCardinality} target, found ${String(count)}`, { expected: descriptor.targetCardinality, actual: count });
+    }
+    const unsupported = matches.find((match) => !descriptor.targetKinds.includes(match.node.type));
+    if (unsupported) {
+        throw pluginError(request, 'unsupported-target', `Operation "${request.plugin}/${request.operation}" does not support target kind "${unsupported.node.type}"`, { expectedKinds: [...descriptor.targetKinds], actualKind: unsupported.node.type, path: [...unsupported.path] });
+    }
+}
+function validatePluginDefinition(plugin, registered) {
+    if (!plugin.id.trim()) {
+        throw new Error('Plugin id must not be empty');
+    }
+    if (!plugin.version.trim()) {
+        throw new Error(`Plugin "${plugin.id}" version must not be empty`);
+    }
+    if (plugin.elementKinds.length === 0 || plugin.elementKinds.some((kind) => !kind.trim())) {
+        throw new Error(`Plugin "${plugin.id}" must declare non-empty element kinds`);
+    }
+    assertUnique(plugin.id, 'element kind', plugin.elementKinds);
+    assertUnique(plugin.id, 'operation', plugin.operations.map((operation) => operation.name));
+    assertUnique(plugin.id, 'query extension', (plugin.queryExtensions ?? []).map((extension) => extension.name));
+    const operationNames = new Set(plugin.operations.map((operation) => operation.name));
+    for (const operation of plugin.operations) {
+        if (!operation.name.trim() || operation.targetKinds.length === 0) {
+            throw new Error(`Plugin "${plugin.id}" has an invalid operation descriptor`);
+        }
+        assertUnique(plugin.id, `parameter for operation "${operation.name}"`, operation.params.map((param) => param.name));
+        if (operation.availability === 'available' && !plugin.handlers?.[operation.name]) {
+            throw new Error(`Plugin "${plugin.id}" available operation "${operation.name}" requires a handler`);
+        }
+        if (plugin.availability === 'planned' && operation.availability === 'available') {
+            throw new Error(`Planned plugin "${plugin.id}" cannot expose available operation "${operation.name}"`);
+        }
+        for (const param of operation.params) {
+            if (!param.name.trim()) {
+                throw new Error(`Plugin "${plugin.id}" operation "${operation.name}" has an empty parameter name`);
+            }
+            if (param.type === 'enum' && (!param.enumValues || param.enumValues.length === 0)) {
+                throw new Error(`Plugin "${plugin.id}" operation "${operation.name}" enum "${param.name}" needs values`);
+            }
+            if (param.defaultValue !== undefined && !matchesParamType(param.defaultValue, param)) {
+                throw new Error(`Plugin "${plugin.id}" operation "${operation.name}" has an invalid default for "${param.name}"`);
+            }
+        }
+    }
+    for (const handlerName of Object.keys(plugin.handlers ?? {})) {
+        if (!operationNames.has(handlerName)) {
+            throw new Error(`Plugin "${plugin.id}" has a handler for unknown operation "${handlerName}"`);
+        }
+    }
+    for (const extension of plugin.queryExtensions ?? []) {
+        for (const otherPlugin of registered) {
+            const conflict = (otherPlugin.queryExtensions ?? []).find((candidate) => candidate.name === extension.name
+                && candidate.targetKinds.some((kind) => extension.targetKinds.includes(kind))
+                && (candidate.valueType !== extension.valueType
+                    || !sameStringSet(candidate.operators, extension.operators)));
+            if (conflict) {
+                throw new Error(`Plugin "${plugin.id}" query extension "${extension.name}" conflicts with plugin "${otherPlugin.id}"`);
+            }
+        }
+    }
+}
+function sameStringSet(left, right) {
+    return left.length === right.length && left.every((value) => right.includes(value));
+}
+function assertUnique(pluginId, label, values) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            throw new Error(`Plugin "${pluginId}" declares duplicate ${label} "${value}"`);
+        }
+        seen.add(value);
+    }
+}
+function readRequiredStringArg(args, name) {
+    const value = args[name];
+    if (typeof value !== 'string') {
+        throw new Error(`Operation requires string arg "${name}"`);
+    }
+    return value;
+}
+function readRequiredNumberArg(args, name) {
+    const value = args[name];
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new Error(`Operation requires finite number arg "${name}"`);
+    }
+    return value;
+}
+function readRequiredEnumArg(args, name, values) {
+    const value = args[name];
+    if (typeof value !== 'string' || !values.includes(value)) {
+        throw new Error(`Operation requires enum arg "${name}" in [${values.join(', ')}]`);
+    }
+    return value;
+}
+function readOptionalBooleanArg(args, name) {
+    const value = args[name];
+    if (value === undefined || typeof value === 'boolean') {
+        return value;
+    }
+    throw new Error(`Operation requires boolean arg "${name}"`);
+}
+function readOptionalEnumArg(args, name, values) {
+    const value = args[name];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string' || !values.includes(value)) {
+        throw new Error(`Operation requires enum arg "${name}" in [${values.join(', ')}]`);
+    }
+    return value;
+}
+function parseTableCellChildren(markdown) {
+    const fragment = parseMarkdown(markdown).children ?? [];
+    if (fragment.length === 0) {
+        return [];
+    }
+    if (fragment.length !== 1 || fragment[0].type !== 'paragraph' || !Array.isArray(fragment[0].children)) {
+        throw new Error('Table cell replacement markdown must parse to a single paragraph');
+    }
+    return fragment[0].children;
+}
+function readCodeContent(match) {
+    if (!match || match.node.type !== 'code') {
+        throw new Error('Code-block operation requires a code target');
+    }
+    return typeof match.node.value === 'string' ? match.node.value : '';
+}
+function codeMutationResult(tree, changed) {
+    return {
+        kind: 'mutation',
+        changed,
+        markdown: stringifyAst(tree),
+    };
+}
+function pluginError(request, code, message, details) {
+    return new PluginOperationError({
+        code,
+        plugin: request.plugin,
+        operation: request.operation,
+        message,
+        ...(details === undefined ? {} : { details }),
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+//# sourceMappingURL=plugins.js.map