structured-context 0.9.0

package/dist/integrations/miro/sync.js

@@ -0,0 +1,347 @@
+import { updateSpaceField } from '../../config';
+import { readSpace } from '../../read/read-space';
+import { buildSpaceGraph } from '../../space-graph';
+import { computeMiroCardHash, computeNodeHash, loadCache, saveCache } from './cache';
+import { MiroClient, MiroNotFoundError } from './client';
+import { CARD_WIDTH, layoutNewCards } from './layout';
+import { buildCardDescription, buildCardTitle, getCardColor } from './styles';
+export async function miroSync(context, options) {
+    const token = process.env.MIRO_TOKEN;
+    if (!token) {
+        console.error('MIRO_TOKEN environment variable is required');
+        process.exit(1);
+    }
+    const { space, schema: { metadata }, } = context;
+    // 1. Resolve board
+    if (!space.miroBoardId) {
+        console.error(`No miroBoardId configured for space "${space.name}".`);
+        console.error('Add miroBoardId to the space entry in config.');
+        process.exit(1);
+    }
+    const boardId = space.miroBoardId;
+    // 2. Resolve frame
+    if (!space.miroFrameId && !options.newFrame) {
+        console.error('No miroFrameId in space config. Pass --new-frame "Title" to create one.');
+        process.exit(1);
+    }
+    // 3. Load space nodes (load before creating frame so we can calculate size)
+    let nodes;
+    ({ nodes } = await readSpace(context));
+    if (nodes.length === 0) {
+        console.log('No space nodes found.');
+        return;
+    }
+    // Filter to hierarchy nodes only
+    const levels = metadata.hierarchy?.levels ?? [];
+    const { nonHierarchy, hierarchyTitles: hierarchyNodeTitles } = buildSpaceGraph(nodes, levels);
+    // Filter nodes to only hierarchy nodes
+    nodes = nodes.filter((n) => hierarchyNodeTitles.has(n.title));
+    if (options.verbose && nonHierarchy.length > 0) {
+        console.log(`Excluded ${nonHierarchy.length} non-hierarchy nodes from sync`);
+    }
+    const client = new MiroClient(boardId, token);
+    let frameId;
+    let layoutOffset = null;
+    if (options.newFrame) {
+        // Calculate layout bounds to size the frame appropriately
+        const { bounds } = layoutNewCards(nodes, new Map(), levels);
+        const frameWidth = Math.max(1600, bounds.maxX - bounds.minX);
+        const frameHeight = Math.max(1200, bounds.maxY - bounds.minY);
+        // Miro positions child items relative to the parent frame's top-left corner.
+        // We shift card positions so the layout bounds start at (0, 0) in frame-local space.
+        layoutOffset = {
+            x: -bounds.minX,
+            y: -bounds.minY,
+        };
+        // Add padding around the calculated bounds for visual breathing room
+        const padding = 200;
+        const finalFrameWidth = frameWidth + padding * 2;
+        const finalFrameHeight = frameHeight + padding * 2;
+        if (options.dryRun) {
+            console.log(`[dry-run] Would create frame: "${options.newFrame}" (size: ${finalFrameWidth}x${finalFrameHeight})`);
+            frameId = 'dry-run-frame-id';
+        }
+        else {
+            const frame = await client.createFrame({
+                data: { title: options.newFrame, type: 'freeform' },
+                position: { x: 0, y: 0, origin: 'center' },
+                geometry: { width: finalFrameWidth, height: finalFrameHeight },
+            });
+            frameId = frame.id;
+            console.log(`Created frame "${options.newFrame}" (${frameId}) - size: ${finalFrameWidth}x${finalFrameHeight}`);
+            updateSpaceField(space.name, 'miroFrameId', frameId);
+            console.log(`Saved miroFrameId to config`);
+        }
+    }
+    else {
+        frameId = space.miroFrameId;
+    }
+    // 4. Load cache
+    const cache = loadCache(boardId, frameId);
+    cache.spaceName = space.name;
+    // 5. Verify cache against actual board state (skip for new frames)
+    // Fetch all cards from the frame to build a verified mapping
+    const existingPositions = new Map();
+    const verifiedCardIds = new Map(); // title → cardId (only cards that exist on board)
+    const miroCardData = new Map(); // cardId → actual Miro data
+    const staleCacheEntries = []; // titles with cached card IDs that no longer exist
+    // Skip fetching frame items for new frames (there are no existing cards)
+    if (!options.newFrame) {
+        // Build reverse lookup map (cardId → title) for O(1) cache lookup
+        const cacheByCardId = new Map();
+        for (const [title, cached] of Object.entries(cache.nodes)) {
+            cacheByCardId.set(cached.miroCardId, title);
+        }
+        const frameItems = await client.getItemsInFrame(frameId);
+        const boardCardIds = new Set();
+        for (const item of frameItems) {
+            if (item.type === 'card' && item.position && item.data) {
+                boardCardIds.add(item.id);
+                miroCardData.set(item.id, {
+                    title: item.data.title,
+                    description: item.data.description ?? '',
+                });
+                // Find which cached node this card belongs to using reverse lookup
+                const title = cacheByCardId.get(item.id);
+                if (title) {
+                    existingPositions.set(title, {
+                        x: item.position.x,
+                        y: item.position.y,
+                    });
+                    verifiedCardIds.set(title, item.id);
+                }
+            }
+        }
+        // Detect stale cache entries (cached card IDs not on board)
+        for (const [title, cached] of Object.entries(cache.nodes)) {
+            if (!boardCardIds.has(cached.miroCardId)) {
+                staleCacheEntries.push(title);
+            }
+        }
+        if (staleCacheEntries.length > 0) {
+            if (options.verbose || options.dryRun) {
+                console.log(`Found ${staleCacheEntries.length} stale cache entries (cards deleted from board)`);
+                for (const title of staleCacheEntries) {
+                    console.log(`  - "${title}" (will recreate)`);
+                }
+            }
+        }
+    }
+    // 6. Determine which nodes are new vs updated vs unchanged
+    // Compare actual Miro card content against node (not cached hash)
+    const newNodes = [];
+    const updatedNodes = [];
+    let skippedCount = 0;
+    for (const node of nodes) {
+        const title = node.title;
+        // Compute what we expect to be in Miro (using the same build functions)
+        const expectedTitle = buildCardTitle(node);
+        const expectedDesc = buildCardDescription(node);
+        const expectedHash = computeMiroCardHash(expectedTitle, expectedDesc);
+        // Check if there's a verified card on the board for this node
+        const verifiedCardId = verifiedCardIds.get(title);
+        if (!verifiedCardId) {
+            // No card on board - needs to be created
+            newNodes.push(node);
+        }
+        else {
+            // Card exists - compare actual Miro content against expected node content
+            const miroData = miroCardData.get(verifiedCardId);
+            if (miroData) {
+                const miroHash = computeMiroCardHash(miroData.title, miroData.description);
+                if (miroHash !== expectedHash) {
+                    // Miro content differs from node - needs update
+                    if (options.verbose) {
+                        console.log(`"${title}" differs from Miro:`);
+                        console.log(`  Expected: "${JSON.stringify(expectedTitle)}"`);
+                        console.log(`  Miro has: "${JSON.stringify(miroData.title)}"`);
+                        console.log(`  Expected desc: "${JSON.stringify(expectedDesc)}"`);
+                        console.log(`  Miro desc: "${JSON.stringify(miroData.description)}"`);
+                    }
+                    updatedNodes.push({ node, cardId: verifiedCardId });
+                }
+                else {
+                    skippedCount++;
+                }
+            }
+            else {
+                // Card ID exists but we couldn't fetch data - recreate
+                newNodes.push(node);
+            }
+        }
+    }
+    // Compute positions for new cards
+    const { positions: newPositions } = layoutNewCards(newNodes, existingPositions, levels);
+    // 7. Create new cards
+    let createdCount = 0;
+    for (const node of newNodes) {
+        const title = node.title;
+        const type = node.schemaData.type;
+        let pos = newPositions.get(title) ?? { x: 0, y: 0 };
+        // Apply offset if we created a new frame (to center layout in frame)
+        if (layoutOffset) {
+            pos = { x: pos.x + layoutOffset.x, y: pos.y + layoutOffset.y };
+        }
+        else {
+            // For existing frames without layout offset, place at origin for simplicity
+            // User can manually rearrange or re-sync with --new-frame for better layout
+            pos = { x: 0, y: 0 };
+        }
+        if (options.dryRun) {
+            console.log(`[dry-run] Create card: "${title}" (${type}) at (${pos.x}, ${pos.y})`);
+            // For dry-run, use a fake ID so connectors can be calculated
+            verifiedCardIds.set(title, `dry-run-card-${title}`);
+            createdCount++;
+            continue;
+        }
+        if (options.verbose)
+            console.log(`Creating card: "${title}" (${type}) at (${pos.x}, ${pos.y})`);
+        const card = await client.createCard({
+            data: {
+                title: buildCardTitle(node),
+                description: buildCardDescription(node),
+            },
+            style: { cardTheme: getCardColor(type, levels) },
+            position: { x: pos.x, y: pos.y, origin: 'center' },
+            parent: { id: frameId },
+            geometry: { width: CARD_WIDTH },
+        });
+        cache.nodes[title] = {
+            miroCardId: card.id,
+            contentHash: computeNodeHash(node),
+        };
+        verifiedCardIds.set(title, card.id); // Add to verified set so connectors can use it
+        createdCount++;
+    }
+    // 8. Update changed cards
+    let updatedCount = 0;
+    for (const { node, cardId } of updatedNodes) {
+        const title = node.title;
+        if (options.dryRun) {
+            console.log(`[dry-run] Update card: "${title}"`);
+            updatedCount++;
+            continue;
+        }
+        if (options.verbose)
+            console.log(`Updating card: "${title}"`);
+        try {
+            await client.updateCard(cardId, {
+                data: {
+                    title: buildCardTitle(node),
+                    description: buildCardDescription(node),
+                },
+            });
+            cache.nodes[title] = {
+                miroCardId: cardId,
+                contentHash: computeNodeHash(node),
+            };
+            updatedCount++;
+        }
+        catch (e) {
+            if (e instanceof MiroNotFoundError) {
+                // Card was deleted from Miro — recreate it
+                console.log(`Card "${title}" missing from Miro, recreating...`);
+                const type = node.schemaData.type;
+                const card = await client.createCard({
+                    data: {
+                        title: buildCardTitle(node),
+                        description: buildCardDescription(node),
+                    },
+                    style: { cardTheme: getCardColor(type, levels) },
+                    position: { x: 0, y: 0, origin: 'center' },
+                    parent: { id: frameId },
+                    geometry: { width: CARD_WIDTH },
+                });
+                cache.nodes[title] = {
+                    miroCardId: card.id,
+                    contentHash: computeNodeHash(node),
+                };
+                createdCount++;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    // 9. Sync connectors
+    const prefix = options.dryRun ? '[dry-run] ' : '';
+    let connectorsCreated = 0;
+    let connectorsDeleted = 0;
+    // Build desired parent→child pairs from OST data
+    // Only include edges where both endpoints have verified cards on the board
+    const desiredEdges = new Map();
+    for (const node of nodes) {
+        const childTitle = node.title;
+        for (const { title: parentTitle, source } of node.resolvedParents) {
+            if (source !== 'hierarchy')
+                continue;
+            // Both endpoints must have verified cards on the board
+            if (verifiedCardIds.has(parentTitle) && verifiedCardIds.has(childTitle)) {
+                const key = `${parentTitle}\u2192${childTitle}`;
+                desiredEdges.set(key, { parentTitle, childTitle });
+            }
+        }
+    }
+    // Build cardId → title mapping from VERIFIED cards only
+    const cardIdToTitle = new Map();
+    for (const [title, cardId] of verifiedCardIds.entries()) {
+        cardIdToTitle.set(cardId, title);
+    }
+    // Find existing connectors that we created (from cache)
+    const existingConnectorIds = new Set(Object.values(cache.connectors).map((c) => c.miroConnectorId));
+    // Verify our cached connectors still exist and connect our cards
+    const allConnectors = await client.getConnectors();
+    const validCachedEdges = new Map(); // edge key → connector ID
+    for (const conn of allConnectors) {
+        // Skip connectors not in our cache
+        if (!existingConnectorIds.has(conn.id))
+            continue;
+        // Skip connectors that don't connect two items
+        if (!conn.startItem || !conn.endItem)
+            continue;
+        const startTitle = cardIdToTitle.get(conn.startItem.id);
+        const endTitle = cardIdToTitle.get(conn.endItem.id);
+        if (startTitle && endTitle) {
+            validCachedEdges.set(`${startTitle}\u2192${endTitle}`, conn.id);
+        }
+    }
+    // Create missing connectors
+    for (const [key, { parentTitle, childTitle }] of desiredEdges) {
+        if (!validCachedEdges.has(key)) {
+            if (options.verbose || options.dryRun)
+                console.log(`${prefix}Creating connector: ${parentTitle} -> ${childTitle}`);
+            if (!options.dryRun) {
+                const conn = await client.createConnector(verifiedCardIds.get(parentTitle), verifiedCardIds.get(childTitle));
+                cache.connectors[key] = { miroConnectorId: conn.id };
+            }
+            connectorsCreated++;
+        }
+    }
+    // Delete ONLY connectors we created that are no longer valid
+    for (const [key, cached] of Object.entries(cache.connectors)) {
+        // Skip if this edge is still desired
+        if (desiredEdges.has(key))
+            continue;
+        // Check if the connector still exists in Miro and connects our cards
+        if (validCachedEdges.has(key)) {
+            if (options.verbose || options.dryRun)
+                console.log(`${prefix}Deleting stale connector: ${key}`);
+            if (!options.dryRun) {
+                await client.deleteConnector(cached.miroConnectorId);
+                connectorsDeleted++;
+            }
+        }
+        // Remove from cache regardless (it's either deleted or invalid)
+        if (!options.dryRun) {
+            delete cache.connectors[key];
+        }
+    }
+    // 10. Save cache
+    cache.lastSync = new Date().toISOString();
+    if (!options.dryRun)
+        saveCache(cache);
+    // Summary
+    console.log(`\n${prefix}Sync complete:`);
+    console.log(`  Cards: ${createdCount} created, ${updatedCount} updated, ${skippedCount} unchanged`);
+    console.log(`  Connectors: ${connectorsCreated} created, ${connectorsDeleted} deleted`);
+}

package/dist/plugin-api.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Public API for external structured-context plugins.
+ *
+ * Import from this module to get the types needed to implement a StructuredContextPlugin:
+ *
+ *   import type { StructuredContextPlugin, PluginContext, ParseResult } from 'structured-context/plugin-api';
+ */
+export type { AnySchemaObject, SchemaObject, ValidateFunction } from 'ajv';
+export type { ParseHook, ParseResult, PluginContext, RenderFormat, RenderHook, RenderOptions, StructuredContextPlugin, TemplateSyncHook, TemplateSyncOptions, } from './plugins/util';
+export type { SharedEmbeddingFields } from './schema/metadata-contract';
+export type { SpaceGraph } from './space-graph';
+export type { BaseNode, EdgeDefinition, HierarchyLevel, Relationship, SchemaMetadata, SchemaWithMetadata, SpaceContext, SpaceNode, UnresolvedRef, } from './types';

package/dist/plugin-api.js

@@ -0,0 +1,7 @@
+/**
+ * Public API for external structured-context plugins.
+ *
+ * Import from this module to get the types needed to implement a StructuredContextPlugin:
+ *
+ *   import type { StructuredContextPlugin, PluginContext, ParseResult } from 'structured-context/plugin-api';
+ */

package/dist/plugins/index.d.ts

@@ -0,0 +1,3 @@
+import type { StructuredContextPlugin } from './util';
+/** All built-in plugins, in default load order. */
+export declare const builtinPlugins: StructuredContextPlugin[];

package/dist/plugins/index.js

@@ -0,0 +1,3 @@
+import { markdownPlugin } from './markdown';
+/** All built-in plugins, in default load order. */
+export const builtinPlugins = [markdownPlugin];

package/dist/plugins/loader.d.ts

@@ -0,0 +1,21 @@
+import { type StructuredContextPlugin } from './util';
+export type LoadedPlugin = {
+    plugin: StructuredContextPlugin;
+    pluginConfig: Record<string, unknown>;
+};
+/**
+ * Discover all available plugins: built-ins first, then any config-adjacent plugins found
+ * in {configDir}/plugins/ across all loaded config files. Does not load npm plugins
+ * (those are only declared in space configs).
+ */
+export declare function discoverPlugins(): Promise<StructuredContextPlugin[]>;
+/**
+ * Load plugins for a space.
+ *
+ * Built-in plugins are always included (with config from the map if declared, else {}).
+ * External plugins are loaded from the map and prepended in declaration order.
+ * Resolution order for external plugins: config-adjacent → npm.
+ * Fields annotated with format:'path' in a plugin's configSchema are resolved
+ * relative to configDir.
+ */
+export declare function loadPlugins(pluginMap: Record<string, Record<string, unknown>>, configDir: string): Promise<LoadedPlugin[]>;

package/dist/plugins/loader.js

@@ -0,0 +1,104 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import Ajv, {} from 'ajv';
+import { getConfigSourceFiles } from '../config';
+import { builtinPlugins } from '.';
+import { CONFIG_PLUGINS_DIR, normalizePluginName, PLUGIN_PREFIX } from './util';
+/**
+ * Walk a plugin's configSchema and resolve any string fields annotated with
+ * format:'path' relative to configDir.
+ */
+function resolveConfigPaths(schema, config, configDir) {
+    const props = schema.properties;
+    if (!props)
+        return config;
+    const result = { ...config };
+    for (const [key, propSchema] of Object.entries(props)) {
+        if (propSchema.format === 'path' && typeof result[key] === 'string') {
+            const value = result[key];
+            if (!isAbsolute(value)) {
+                result[key] = resolve(configDir, value);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Resolve an external plugin by canonical name.
+ * Resolution order: config-adjacent ({configDir}/plugins/{name}) → npm (import(name)).
+ */
+async function resolveExternalPlugin(name, configDir) {
+    const localPath = resolve(join(configDir, CONFIG_PLUGINS_DIR, name));
+    const module = existsSync(localPath) || existsSync(`${localPath}.ts`) ? await import(localPath) : await import(name);
+    const plugin = module.default ?? module;
+    if (!plugin || typeof plugin.name !== 'string') {
+        throw new Error(`Plugin "${name}" must export a StructuredContextPlugin as its default export`);
+    }
+    return plugin;
+}
+/**
+ * Discover all available plugins: built-ins first, then any config-adjacent plugins found
+ * in {configDir}/plugins/ across all loaded config files. Does not load npm plugins
+ * (those are only declared in space configs).
+ */
+export async function discoverPlugins() {
+    // Convert the Set of files into a Set of dirs
+    const configDirs = [...new Set(Array.from(getConfigSourceFiles()).map((f) => dirname(f)))];
+    const plugins = [...builtinPlugins];
+    const seenNames = new Set(builtinPlugins.map((p) => p.name));
+    for (const configDir of configDirs) {
+        const pluginsDir = join(configDir, CONFIG_PLUGINS_DIR);
+        if (existsSync(pluginsDir)) {
+            const entries = readdirSync(pluginsDir).filter((e) => e.startsWith(PLUGIN_PREFIX));
+            for (const entry of entries) {
+                if (!seenNames.has(entry)) {
+                    plugins.push(await resolveExternalPlugin(entry, configDir));
+                    seenNames.add(entry);
+                }
+            }
+        }
+    }
+    return plugins;
+}
+/**
+ * Load plugins for a space.
+ *
+ * Built-in plugins are always included (with config from the map if declared, else {}).
+ * External plugins are loaded from the map and prepended in declaration order.
+ * Resolution order for external plugins: config-adjacent → npm.
+ * Fields annotated with format:'path' in a plugin's configSchema are resolved
+ * relative to configDir.
+ */
+export async function loadPlugins(pluginMap, configDir) {
+    const builtinsByName = new Map(builtinPlugins.map((p) => [p.name, p]));
+    const ajv = new Ajv();
+    ajv.addFormat('path', (value) => value.length > 0 && !value.includes('\0'));
+    const loaded = [];
+    // External plugins: entries in the map that are not built-in names
+    for (const [rawName, rawConfig] of Object.entries(pluginMap)) {
+        const name = normalizePluginName(rawName);
+        if (builtinsByName.has(name))
+            continue;
+        if (!name.startsWith(PLUGIN_PREFIX)) {
+            throw new Error(`Plugin name must start with "${PLUGIN_PREFIX}" (got "${rawName}")`);
+        }
+        const plugin = await resolveExternalPlugin(name, configDir);
+        const pluginConfig = resolveConfigPaths(plugin.configSchema, rawConfig, configDir);
+        const validate = ajv.compile(plugin.configSchema);
+        if (!validate(pluginConfig)) {
+            throw new Error(`Invalid config for plugin "${name}": ${JSON.stringify(validate.errors)}`);
+        }
+        loaded.push({ plugin, pluginConfig });
+    }
+    // Built-in plugins: always loaded, config taken from map if declared (with or without prefix)
+    for (const builtin of builtinPlugins) {
+        const rawConfig = pluginMap[builtin.name] ?? pluginMap[builtin.name.slice(PLUGIN_PREFIX.length)] ?? {};
+        const pluginConfig = resolveConfigPaths(builtin.configSchema, rawConfig, configDir);
+        const validate = ajv.compile(builtin.configSchema);
+        if (!validate(pluginConfig)) {
+            throw new Error(`Invalid config for plugin "${builtin.name}": ${JSON.stringify(validate.errors)}`);
+        }
+        loaded.push({ plugin: builtin, pluginConfig });
+    }
+    return loaded;
+}

package/dist/plugins/markdown/index.d.ts

@@ -0,0 +1,48 @@
+import type { StructuredContextPlugin } from '../util';
+export type TypeInferenceConfig = {
+    mode?: 'folder-name' | 'off';
+    folderMap?: Record<string, string>;
+};
+export type MarkdownPluginConfig = {
+    templateDir?: string;
+    fieldMap?: Record<string, string>;
+    templatePrefix?: string;
+    typeInference?: TypeInferenceConfig;
+};
+export declare const MARKDOWN_CONFIG_SCHEMA: {
+    type: string;
+    properties: {
+        templateDir: {
+            type: string;
+            format: string;
+        };
+        fieldMap: {
+            type: string;
+            additionalProperties: {
+                type: string;
+            };
+        };
+        templatePrefix: {
+            type: string;
+        };
+        typeInference: {
+            type: string;
+            properties: {
+                mode: {
+                    type: string;
+                    enum: string[];
+                };
+                folderMap: {
+                    type: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+            };
+            additionalProperties: boolean;
+        };
+    };
+    additionalProperties: boolean;
+};
+export declare function getMarkdownConfig(plugins?: Record<string, Record<string, unknown>>): MarkdownPluginConfig;
+export declare const markdownPlugin: StructuredContextPlugin;

package/dist/plugins/markdown/index.js

@@ -0,0 +1,51 @@
+import { statSync } from 'node:fs';
+import { PLUGIN_PREFIX } from '../util';
+import { readSpaceDirectory, readSpaceOnAPage } from './read-space';
+import { renderBullets } from './render-bullets';
+import { renderMermaid } from './render-mermaid';
+import { templateSync } from './template-sync';
+export const MARKDOWN_CONFIG_SCHEMA = {
+    type: 'object',
+    properties: {
+        templateDir: { type: 'string', format: 'path' }, // format is hint to config loader to resolve relative directories
+        fieldMap: { type: 'object', additionalProperties: { type: 'string' } },
+        templatePrefix: { type: 'string' },
+        typeInference: {
+            type: 'object',
+            properties: {
+                mode: { type: 'string', enum: ['folder-name', 'off'] },
+                folderMap: { type: 'object', additionalProperties: { type: 'string' } },
+            },
+            additionalProperties: false,
+        },
+    },
+    additionalProperties: false,
+};
+export function getMarkdownConfig(plugins) {
+    return (plugins?.[`${PLUGIN_PREFIX}markdown`] ?? {});
+}
+async function parse(context) {
+    if (statSync(context.space.path).isFile()) {
+        return readSpaceOnAPage(context);
+    }
+    return await readSpaceDirectory(context);
+}
+export const markdownPlugin = {
+    name: `${PLUGIN_PREFIX}markdown`,
+    configSchema: MARKDOWN_CONFIG_SCHEMA,
+    parse,
+    templateSync,
+    render: {
+        formats: [
+            { name: 'bullets', description: 'Indented bullet list' },
+            { name: 'mermaid', description: 'Mermaid graph TD diagram' },
+        ],
+        render(_context, graph, { format }) {
+            if (format === 'bullets')
+                return renderBullets(graph);
+            if (format === 'mermaid')
+                return renderMermaid(graph);
+            throw new Error(`Unknown markdown render format: "${format}"`);
+        },
+    },
+};