structured-context 0.9.3 → 0.11.0

package/dist/config.d.ts

@@ -2,14 +2,18 @@ export type SpaceConfig = {
     name: string;
     path: string;
     schema?: string;
-    miroBoardId?: string;
-    miroFrameId?: string;
     /** Plugin name → plugin config map. Overrides top-level plugins when set. */
     plugins?: Record<string, Record<string, unknown>>;
     /** Named filter views for this space. Keys are view names; values contain the filter expression. */
     views?: Record<string, {
         expression: string;
     }>;
+    /**
+     * Directory of the config file that defined this space, used to anchor relative plugin-config
+     * paths. Set by loadConfig; absent for a hand-assembled Config, whose callers must pass an
+     * explicit configDir to createSpaceContext. Not persisted by updateSpaceField.
+     */
+    sourceDir?: string;
 };
 export type Config = {
     spaces: SpaceConfig[];
@@ -20,19 +24,11 @@ export type Config = {
 export declare function setConfigPath(path: string | undefined): void;
 /** Get all config file paths that were loaded (main config + included configs). */
 export declare function getConfigSourceFiles(): Set<string>;
-/**
- * Get the directory of the config file that defines a given space.
- */
-export declare function getSpaceConfigDir(spaceName: string): string;
 export declare function configPath(): string;
 export declare function loadConfig(): Config;
 /** Get the full space config entry by name. Throws if not found. */
 export declare function getSpaceConfig(name: string, config: Config): SpaceConfig;
 /** Resolve schema path: CLI arg > space-level config > global config. Throws if none configured. */
 export declare function resolveSchema(config: Config, space?: SpaceConfig): string;
-type StringFields<T> = {
-    [K in keyof T]: T[K] extends string | undefined ? K : never;
-}[keyof T];
-/** Update a string field on a space entry and persist config. */
-export declare function updateSpaceField(spaceName: string, field: StringFields<SpaceConfig>, value: string): void;
-export {};
+/** Update a string field on a space entry and persist config. When `plugin` is given, updates that field inside `space.plugins[plugin]` instead. */
+export declare function updateSpaceField(spaceName: string, field: string, value: string, plugin?: string): void;

package/dist/config.js

@@ -2,9 +2,9 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import Ajv from 'ajv';
-import { JSON5 } from 'bun';
+import JSON5 from 'json5';
 import { ENV_CONFIG_VAR, XDG_CONFIG_DIR } from './constants';
-import { normalizePluginName } from './plugins/util';
+import { normalizePluginName, shortenPluginName } from './plugins/util';
 import { bundledSchemasDir } from './schema/schema';
 const CONFIG_SCHEMA = {
     type: 'object',
@@ -17,8 +17,6 @@ const CONFIG_SCHEMA = {
                     name: { type: 'string', pattern: '^[a-z0-9_-]+$' },
                     path: { type: 'string' },
                     schema: { type: 'string' },
-                    miroBoardId: { type: 'string' },
-                    miroFrameId: { type: 'string' },
                     plugins: { type: 'object', additionalProperties: { type: 'object' } },
                     views: {
                         type: 'object',
@@ -37,7 +35,7 @@ const CONFIG_SCHEMA = {
         schema: { type: 'string' },
         includeSpacesFrom: { type: 'array', items: { type: 'string' } },
     },
-    required: ['spaces'],
+    anyOf: [{ required: ['spaces'] }, { required: ['includeSpacesFrom'] }],
     additionalProperties: false,
 };
 let _configPathOverride;
@@ -54,18 +52,6 @@ export function getConfigSourceFiles() {
     }
     return new Set(_spaceSourceFiles.values());
 }
-/**
- * Get the directory of the config file that defines a given space.
- */
-export function getSpaceConfigDir(spaceName) {
-    if (_spaceSourceFiles.size === 0) {
-        loadConfig();
-    }
-    const spaceConfigPath = _spaceSourceFiles.get(spaceName);
-    if (!spaceConfigPath)
-        throw new Error('Space config path not found');
-    return dirname(spaceConfigPath);
-}
 export function configPath() {
     if (_configPathOverride) {
         return _configPathOverride;
@@ -130,6 +116,8 @@ function _loadConfig(path) {
     if (!validate(config)) {
         throw new Error(`Invalid config in ${path}: ${JSON.stringify(validate.errors)}`);
     }
+    if (!config.spaces)
+        config.spaces = [];
     return config;
 }
 export function loadConfig() {
@@ -141,8 +129,10 @@ export function loadConfig() {
     const config = _loadConfig(path);
     _spaceSourceFiles.clear();
     // Track which spaces come from the main config file
+    const mainSourceDir = dirname(resolve(path));
     for (const space of config.spaces) {
         _spaceSourceFiles.set(space.name, path);
+        space.sourceDir = mainSourceDir;
     }
     // Load includeSpacesFrom configs and merge their spaces in, with later entries taking precedence over earlier ones
     if (config.includeSpacesFrom) {
@@ -154,8 +144,10 @@ export function loadConfig() {
                 throw new Error(`Included config contains spaces with duplicate names: ${resolvedIncludePath}`);
             }
             // Track which spaces come from this included config file
+            const includeSourceDir = dirname(resolvedIncludePath);
             for (const space of includedConfig.spaces) {
                 _spaceSourceFiles.set(space.name, resolvedIncludePath);
+                space.sourceDir = includeSourceDir;
             }
             config.spaces.push(...includedConfig.spaces);
         }
@@ -178,17 +170,27 @@ export function resolveSchema(config, space) {
     }
     return schema;
 }
-/** Update a string field on a space entry and persist config. */
-export function updateSpaceField(spaceName, field, value) {
+/** Update a string field on a space entry and persist config. When `plugin` is given, updates that field inside `space.plugins[plugin]` instead. */
+export function updateSpaceField(spaceName, field, value, plugin) {
     const sourcePath = _spaceSourceFiles.get(spaceName);
-    if (!sourcePath) {
+    if (!sourcePath)
         throw new Error(`Space "${spaceName}" not found in any config file`);
-    }
     const config = _loadConfig(sourcePath);
     const space = config.spaces?.find((s) => s.name === spaceName);
-    if (!space) {
+    if (!space)
         throw new Error(`Unknown space config: "${spaceName}". Check config.`);
+    if (plugin !== undefined) {
+        if (!space.plugins)
+            space.plugins = {};
+        const normalized = normalizePluginName(plugin);
+        const shortName = shortenPluginName(normalized);
+        const existingKey = Object.keys(space.plugins).find((k) => k === normalized || k === shortName) ?? normalized;
+        if (!space.plugins[existingKey])
+            space.plugins[existingKey] = {};
+        space.plugins[existingKey][field] = value;
+    }
+    else {
+        space[field] = value;
     }
-    space[field] = value;
     writeFileSync(sourcePath, `${JSON5.stringify(config, null, 2)}\n`);
 }

package/dist/index.js

@@ -4,6 +4,7 @@ import { Command } from 'commander';
 import { diagram } from './commands/diagram';
 import { docs } from './commands/docs';
 import { dump } from './commands/dump';
+import { miroSyncCommand } from './commands/miro-sync';
 import { listPlugins } from './commands/plugins';
 import { render, renderList } from './commands/render';
 import { listSchemas, showSchema } from './commands/schemas';
@@ -11,30 +12,21 @@ import { show } from './commands/show';
 import { listSpaces } from './commands/spaces';
 import { templateSync } from './commands/template-sync';
 import { validate, watchValidate } from './commands/validate';
-import { validateFile } from './commands/validate-file';
-import { getSpaceConfigDir, loadConfig, resolveSchema, setConfigPath } from './config';
+import { validateFileCommand } from './commands/validate-file';
+import { loadConfig, setConfigPath } from './config';
 import { CLI_NAME } from './constants';
-import { miroSync } from './integrations/miro/sync';
-import { loadSchema } from './schema/schema';
+import { createSpaceContext, SpaceNotFoundError } from './space-context';
 export function buildSpaceContext(spaceName) {
-    const config = loadConfig();
-    const space = config.spaces.find((s) => s.name === spaceName);
-    if (!space) {
-        console.error(`Error: Unknown space "${spaceName}"`);
-        process.exit(1);
+    try {
+        return createSpaceContext(spaceName, loadConfig());
+    }
+    catch (err) {
+        if (err instanceof SpaceNotFoundError) {
+            console.error(`Error: ${err.message}`);
+            process.exit(1);
+        }
+        throw err;
     }
-    const resolvedSchemaPath = resolveSchema(config, space);
-    const { schema, schemaRefRegistry, schemaValidator } = loadSchema(resolvedSchemaPath);
-    const configDir = getSpaceConfigDir(space.name);
-    return {
-        space,
-        config,
-        resolvedSchemaPath,
-        schema,
-        schemaRefRegistry,
-        schemaValidator,
-        configDir,
-    };
 }
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
@@ -53,7 +45,7 @@ program
     .argument('<path>', 'Path to the file to validate')
     .option('--json', 'Output results as JSON (machine-readable, for hooks)')
     .action(async (filePath, options) => {
-    const exitCode = await validateFile(filePath, { json: options.json });
+    const exitCode = await validateFileCommand(filePath, { json: options.json });
     process.exit(exitCode);
 });
 program
@@ -97,7 +89,7 @@ program
     .option('--new-frame <title>', 'Create a new frame on the board and sync into it')
     .option('--dry-run', 'Show what would change without touching Miro')
     .option('-v, --verbose', 'Detailed output')
-    .action((spaceName, options) => miroSync(buildSpaceContext(spaceName), options));
+    .action((spaceName, options) => miroSyncCommand(buildSpaceContext(spaceName), options));
 program
     .command('template-sync')
     .description('Sync schema examples to templates')

package/dist/load-space-graph.d.ts

@@ -0,0 +1,40 @@
+import type { Config } from './config';
+import { type SpaceGraph } from './space-graph';
+import type { ReadSpaceResult, SpaceContext } from './types';
+export interface AssembleSpaceGraphOptions {
+    /** Named view (resolved via space.views) or a raw filter DSL expression. */
+    filter?: string;
+    /** Pre-loaded read result to assemble from, avoiding a re-read of the space. */
+    readResult?: ReadSpaceResult;
+}
+/**
+ * Assemble a SpaceGraph from a space context: read the space, drop nodes that
+ * fail schema validation, build the hierarchy graph, and apply an optional
+ * view/filter expression.
+ *
+ * Nodes that fail schema validation are silently excluded so the graph is
+ * well-formed enough to render and traverse. This is NOT a validation pass —
+ * schema-valid nodes may still have broken references, rule violations, or
+ * duplicates. Use validateSpace for a full validation report.
+ *
+ * Shared by the render pipeline and the public loadSpaceGraph API so their
+ * graph-assembly behaviour cannot drift.
+ */
+export declare function assembleSpaceGraph(context: SpaceContext, options?: AssembleSpaceGraphOptions): Promise<SpaceGraph>;
+export interface LoadSpaceGraphOptions extends AssembleSpaceGraphOptions {
+    /**
+     * Directory to anchor relative plugin paths against. Required when config is
+     * hand-assembled (has no source file); see {@link createSpaceContext}.
+     */
+    configDir?: string;
+}
+/**
+ * Load a named space and return its assembled, filtered SpaceGraph.
+ *
+ * Convenience entry point over createSpaceContext + assembleSpaceGraph: pass a
+ * space name, config, and optional filter. Pass options.readResult to reuse an
+ * already-loaded read (e.g. when also calling validateSpace) and skip re-reading.
+ * When you already hold a SpaceContext, call assembleSpaceGraph directly to avoid
+ * rebuilding (and recompiling the schema for) the context.
+ */
+export declare function loadSpaceGraph(spaceName: string, config: Config, options?: LoadSpaceGraphOptions): Promise<SpaceGraph>;

package/dist/load-space-graph.js

@@ -0,0 +1,42 @@
+import { filterNodes } from './filter/filter-nodes';
+import { readSpace } from './read/read-space';
+import { createSpaceContext } from './space-context';
+import { buildSpaceGraph } from './space-graph';
+/**
+ * Assemble a SpaceGraph from a space context: read the space, drop nodes that
+ * fail schema validation, build the hierarchy graph, and apply an optional
+ * view/filter expression.
+ *
+ * Nodes that fail schema validation are silently excluded so the graph is
+ * well-formed enough to render and traverse. This is NOT a validation pass —
+ * schema-valid nodes may still have broken references, rule violations, or
+ * duplicates. Use validateSpace for a full validation report.
+ *
+ * Shared by the render pipeline and the public loadSpaceGraph API so their
+ * graph-assembly behaviour cannot drift.
+ */
+export async function assembleSpaceGraph(context, options = {}) {
+    const { nodes: allNodes } = options.readResult ?? (await readSpace(context));
+    const { schemaValidator } = context;
+    const validNodes = allNodes.filter((node) => schemaValidator(node.schemaData));
+    const levels = context.schema.metadata.hierarchy?.levels ?? [];
+    let graph = buildSpaceGraph(validNodes, levels);
+    if (options.filter) {
+        const expression = context.space.views?.[options.filter]?.expression ?? options.filter;
+        graph = await filterNodes(expression, graph);
+    }
+    return graph;
+}
+/**
+ * Load a named space and return its assembled, filtered SpaceGraph.
+ *
+ * Convenience entry point over createSpaceContext + assembleSpaceGraph: pass a
+ * space name, config, and optional filter. Pass options.readResult to reuse an
+ * already-loaded read (e.g. when also calling validateSpace) and skip re-reading.
+ * When you already hold a SpaceContext, call assembleSpaceGraph directly to avoid
+ * rebuilding (and recompiling the schema for) the context.
+ */
+export async function loadSpaceGraph(spaceName, config, options = {}) {
+    const context = createSpaceContext(spaceName, config, { configDir: options.configDir });
+    return assembleSpaceGraph(context, options);
+}

package/dist/plugins/index.js

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

package/dist/plugins/loader.js

@@ -3,7 +3,7 @@ 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';
+import { CONFIG_PLUGINS_DIR, normalizePluginName, PLUGIN_PREFIX, shortenPluginName, } from './util';
 /**
  * Walk a plugin's configSchema and resolve any string fields annotated with
  * format:'path' relative to configDir.
@@ -92,7 +92,7 @@ export async function loadPlugins(pluginMap, configDir) {
     }
     // 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 rawConfig = pluginMap[builtin.name] ?? pluginMap[shortenPluginName(builtin.name)] ?? {};
         const pluginConfig = resolveConfigPaths(builtin.configSchema, rawConfig, configDir);
         const validate = ajv.compile(builtin.configSchema);
         if (!validate(pluginConfig)) {

package/dist/plugins/markdown/extract-content-links.d.ts

@@ -0,0 +1,23 @@
+import type { Node } from 'mdast';
+import type { ContentLink, SchemaMetadata } from '../../types';
+/**
+ * Recursively walk an mdast subtree and collect all links.
+ * Handles standard markdown link/image nodes and scans text nodes for wikilinks.
+ */
+export declare function extractLinksFromAstNode(node: Node): ContentLink[];
+/**
+ * Extract all links from a raw markdown body string.
+ * Parses the full document and collects links from every node in the tree.
+ */
+export declare function extractLinksFromBody(body: string): ContentLink[];
+/**
+ * Build the set of field names that serve as graph edges (hierarchy + relationship fields).
+ * Used to exclude edge fields from frontmatter link extraction.
+ */
+export declare function getEdgeFieldNames(metadata: SchemaMetadata): Set<string>;
+/**
+ * Extract links from frontmatter data fields, excluding known graph edge fields.
+ * Parses each string value as markdown (via mdast) to keep link extraction consistent
+ * with body content parsing — handles wikilinks, markdown links, images, and bare URLs.
+ */
+export declare function extractLinksFromFrontmatter(data: Record<string, unknown>, edgeFields: Set<string>): ContentLink[];

package/dist/plugins/markdown/extract-content-links.js

@@ -0,0 +1,144 @@
+import { toString as mdastToString } from 'mdast-util-to-string';
+import remarkGfm from 'remark-gfm';
+import remarkParse from 'remark-parse';
+import { unified } from 'unified';
+/**
+ * Parse an Obsidian wikilink inner string into its components.
+ * Handles: [[target]], [[target#anchor]], [[target|alias]], [[target#anchor|alias]]
+ */
+function parseWikilinkInner(inner) {
+    // Alias: [[target|alias]] or [[target#anchor|alias]]
+    const pipeIdx = inner.indexOf('|');
+    let core = inner;
+    let displayText;
+    if (pipeIdx >= 0) {
+        core = inner.slice(0, pipeIdx);
+        const alias = inner.slice(pipeIdx + 1).trim();
+        if (alias)
+            displayText = alias;
+    }
+    // Anchor: [[target#anchor]] or [[target#^block]]
+    const hashIdx = core.indexOf('#');
+    if (hashIdx >= 0) {
+        const target = core.slice(0, hashIdx).trim();
+        const anchor = core.slice(hashIdx + 1).trim() || undefined;
+        return { target, anchor, displayText };
+    }
+    return { target: core.trim(), displayText };
+}
+/**
+ * Extract wikilinks (and Obsidian embed wikilinks) from a plain text string.
+ * Matches [[target]], ![[target]], [[target#anchor]], [[target|alias]], etc.
+ */
+function extractWikilinksFromText(text) {
+    const links = [];
+    for (const match of text.matchAll(/(!?)\[\[([^\]]+)\]\]/g)) {
+        const isEmbed = match[1] === '!';
+        const inner = match[2];
+        const { target, anchor, displayText } = parseWikilinkInner(inner);
+        if (!target)
+            continue;
+        links.push({
+            text: displayText ?? target,
+            target,
+            action: isEmbed ? 'embed' : 'link',
+            ...(anchor !== undefined ? { anchor } : {}),
+            linkSyntax: 'wikilink',
+        });
+    }
+    return links;
+}
+/**
+ * Recursively walk an mdast subtree and collect all links.
+ * Handles standard markdown link/image nodes and scans text nodes for wikilinks.
+ */
+export function extractLinksFromAstNode(node) {
+    const links = [];
+    function walk(n) {
+        switch (n.type) {
+            case 'link': {
+                const linkNode = n;
+                links.push({
+                    text: mdastToString(linkNode),
+                    target: linkNode.url,
+                    action: 'link',
+                    linkSyntax: 'markdown',
+                });
+                // Don't recurse into children — they are display text, not link targets
+                break;
+            }
+            case 'image': {
+                const imgNode = n;
+                links.push({
+                    text: imgNode.alt ?? '',
+                    target: imgNode.url,
+                    action: 'embed',
+                    linkSyntax: 'markdown',
+                });
+                break;
+            }
+            case 'text': {
+                // Remark does not parse wikilinks natively; scan text nodes for [[...]] patterns
+                links.push(...extractWikilinksFromText(n.value));
+                break;
+            }
+            default: {
+                if ('children' in n) {
+                    for (const child of n.children) {
+                        walk(child);
+                    }
+                }
+                break;
+            }
+        }
+    }
+    walk(node);
+    return links;
+}
+/**
+ * Extract all links from a raw markdown body string.
+ * Parses the full document and collects links from every node in the tree.
+ */
+export function extractLinksFromBody(body) {
+    const tree = unified().use(remarkParse).use(remarkGfm).parse(body);
+    return extractLinksFromAstNode(tree);
+}
+/**
+ * Build the set of field names that serve as graph edges (hierarchy + relationship fields).
+ * Used to exclude edge fields from frontmatter link extraction.
+ */
+export function getEdgeFieldNames(metadata) {
+    const fields = new Set();
+    for (const level of metadata.hierarchy?.levels ?? []) {
+        fields.add(level.field);
+        if (level.selfRefField)
+            fields.add(level.selfRefField);
+    }
+    for (const rel of metadata.relationships ?? []) {
+        fields.add(rel.field);
+    }
+    return fields;
+}
+/**
+ * Extract links from frontmatter data fields, excluding known graph edge fields.
+ * Parses each string value as markdown (via mdast) to keep link extraction consistent
+ * with body content parsing — handles wikilinks, markdown links, images, and bare URLs.
+ */
+export function extractLinksFromFrontmatter(data, edgeFields) {
+    const links = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (edgeFields.has(key))
+            continue;
+        if (typeof value === 'string') {
+            links.push(...extractLinksFromBody(value));
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                if (typeof item === 'string') {
+                    links.push(...extractLinksFromBody(item));
+                }
+            }
+        }
+    }
+    return links;
+}

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

@@ -1,48 +1,58 @@
+import type { FromSchema } from 'json-schema-to-ts';
 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;
+declare const TYPE_INFERENCE_CONFIG_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly mode: {
+            readonly type: "string";
+            readonly enum: readonly ["folder-name", "off"];
+        };
+        readonly folderMap: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly additionalProperties: false;
 };
 export declare const MARKDOWN_CONFIG_SCHEMA: {
-    type: string;
-    properties: {
-        templateDir: {
-            type: string;
-            format: string;
+    readonly type: "object";
+    readonly properties: {
+        readonly templateDir: {
+            readonly type: "string";
+            readonly format: "path";
         };
-        fieldMap: {
-            type: string;
-            additionalProperties: {
-                type: string;
+        readonly fieldMap: {
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
             };
         };
-        templatePrefix: {
-            type: string;
+        readonly templatePrefix: {
+            readonly type: "string";
         };
-        typeInference: {
-            type: string;
-            properties: {
-                mode: {
-                    type: string;
-                    enum: string[];
+        readonly typeInference: {
+            readonly type: "object";
+            readonly properties: {
+                readonly mode: {
+                    readonly type: "string";
+                    readonly enum: readonly ["folder-name", "off"];
                 };
-                folderMap: {
-                    type: string;
-                    additionalProperties: {
-                        type: string;
+                readonly folderMap: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
                     };
                 };
             };
-            additionalProperties: boolean;
+            readonly additionalProperties: false;
         };
     };
-    additionalProperties: boolean;
+    readonly additionalProperties: false;
 };
+export type MarkdownPluginConfig = FromSchema<typeof MARKDOWN_CONFIG_SCHEMA>;
+export type TypeInferenceConfig = FromSchema<typeof TYPE_INFERENCE_CONFIG_SCHEMA>;
 export declare function getMarkdownConfig(plugins?: Record<string, Record<string, unknown>>): MarkdownPluginConfig;
 export declare const markdownPlugin: StructuredContextPlugin;
+export {};

package/dist/plugins/markdown/index.js

@@ -2,22 +2,22 @@ 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';
+const TYPE_INFERENCE_CONFIG_SCHEMA = {
+    type: 'object',
+    properties: {
+        mode: { type: 'string', enum: ['folder-name', 'off'] },
+        folderMap: { type: 'object', additionalProperties: { type: 'string' } },
+    },
+    additionalProperties: false,
+};
 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,
-        },
+        typeInference: TYPE_INFERENCE_CONFIG_SCHEMA,
     },
     additionalProperties: false,
 };
@@ -36,15 +36,10 @@ export const markdownPlugin = {
     parse,
     templateSync,
     render: {
-        formats: [
-            { name: 'bullets', description: 'Indented bullet list' },
-            { name: 'mermaid', description: 'Mermaid graph TD diagram' },
-        ],
+        formats: [{ name: 'bullets', description: 'Indented bullet list' }],
         render(_context, graph, { format }) {
             if (format === 'bullets')
                 return renderBullets(graph);
-            if (format === 'mermaid')
-                return renderMermaid(graph);
             throw new Error(`Unknown markdown render format: "${format}"`);
         },
     },

package/dist/plugins/markdown/parse-embedded.d.ts

@@ -1,4 +1,4 @@
-import type { BaseNode, Relationship, SchemaMetadata } from '../../plugin-api';
+import type { BaseNode, Relationship, SchemaMetadata } from '../../api';
 /** Type values that identify a space_on_a_page container (not themselves space nodes). */
 export declare const ON_A_PAGE_TYPES: string[];
 type StackEntry = {