structured-context 0.11.0 → 0.13.0

package/dist/plugins/markdown/render-directory.js

@@ -0,0 +1,130 @@
+import { posix } from 'node:path';
+import matter from 'gray-matter';
+import { getMarkdownConfig } from '../../index.js';
+import { invertFieldMap, MATTER_OPTIONS } from './util';
+/**
+ * Sanitize a node title into a valid filesystem filename.
+ * Strips Obsidian/OS forbidden characters: \ / : * ? " < > | # ^ [ ]
+ */
+export function sanitizeFilename(title) {
+    const sanitized = title
+        .replace(/[\\/:*?"<>|#^[\]]/g, '-')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/^[-.]+/, '')
+        .replace(/[-.]+$/, '');
+    return sanitized || 'untitled';
+}
+const PREFERRED_FIELD_ORDER = ['type', 'title', 'status', 'summary', 'status_tweet'];
+const EDGE_FIELDS = new Set(['parent', 'dependsOn', 'flowsTo', 'anchors', 'pipelineOf']);
+/**
+ * Format frontmatter object with preferred key ordering for Obsidian notes.
+ */
+function sortFrontmatterKeys(data) {
+    const keys = Object.keys(data);
+    const preferred = [];
+    const edge = [];
+    const middle = [];
+    for (const k of PREFERRED_FIELD_ORDER) {
+        if (keys.includes(k))
+            preferred.push(k);
+    }
+    for (const k of keys) {
+        if (EDGE_FIELDS.has(k)) {
+            edge.push(k);
+        }
+        else if (!PREFERRED_FIELD_ORDER.includes(k)) {
+            middle.push(k);
+        }
+    }
+    const sorted = {};
+    for (const k of [...preferred, ...middle, ...edge]) {
+        sorted[k] = data[k];
+    }
+    return sorted;
+}
+/**
+ * Render a space graph as a markdown directory with one file per node.
+ */
+export function renderMarkdownDirectory(context, graph, options) {
+    const markdownConfig = getMarkdownConfig(context.space?.plugins);
+    const reverseFieldMap = markdownConfig.fieldMap ? invertFieldMap(markdownConfig.fieldMap) : {};
+    const foldersOption = options.data?.folders;
+    let useFolders = false;
+    if (foldersOption === 'type') {
+        useFolders = true;
+    }
+    else if (foldersOption === 'flat') {
+        useFolders = false;
+    }
+    else if (markdownConfig.typeInference?.folderMap) {
+        useFolders = true;
+    }
+    // Build type-to-folder mapping from typeInference.folderMap if available
+    const folderMap = markdownConfig.typeInference?.folderMap;
+    const typeToFolder = new Map();
+    if (folderMap) {
+        for (const [folderPath, mappedType] of Object.entries(folderMap)) {
+            const cleanFolder = folderPath.replace(/\\/g, '/').replace(/\/+$/, '');
+            typeToFolder.set(mappedType.toLowerCase(), cleanFolder);
+        }
+    }
+    const files = [];
+    const usedPaths = new Set();
+    for (const node of graph.nodes.values()) {
+        const baseName = sanitizeFilename(node.title);
+        let folder = '';
+        if (useFolders) {
+            const typeKey = (node.resolvedType || node.type || '').toLowerCase();
+            folder = typeToFolder.get(typeKey) ?? (node.resolvedType || node.type || 'other');
+        }
+        let candidateName = `${baseName}.md`;
+        let counter = 2;
+        let relPath = folder ? posix.join(folder, candidateName) : candidateName;
+        while (usedPaths.has(relPath)) {
+            candidateName = `${baseName}-${counter}.md`;
+            relPath = folder ? posix.join(folder, candidateName) : candidateName;
+            counter++;
+        }
+        usedPaths.add(relPath);
+        const finalBase = candidateName.slice(0, -3);
+        // Prepare frontmatter data from schemaData with reverse fieldMap
+        const rawData = node.schemaData ?? {};
+        const frontmatterData = {};
+        for (const [key, value] of Object.entries(rawData)) {
+            // Body content is not written to frontmatter
+            if (key === 'content')
+                continue;
+            // Omit title only if it matches the final filename base
+            if (key === 'title' && finalBase === node.title)
+                continue;
+            const fileKey = reverseFieldMap[key] ?? key;
+            frontmatterData[fileKey] = value;
+        }
+        // Preserve exact title if final filename differed or disambiguation occurred
+        if (finalBase !== node.title && !frontmatterData.title) {
+            const titleKey = reverseFieldMap.title ?? 'title';
+            frontmatterData[titleKey] = node.title;
+        }
+        // Ensure type is in frontmatter
+        const nodeType = node.type || node.resolvedType;
+        if (nodeType && !frontmatterData.type) {
+            const typeKey = reverseFieldMap.type ?? 'type';
+            frontmatterData[typeKey] = nodeType;
+        }
+        const sortedData = sortFrontmatterKeys(frontmatterData);
+        const body = (node.content ?? '').trim();
+        let fileContent;
+        if (Object.keys(sortedData).length > 0) {
+            fileContent = matter.stringify(body ? `\n${body}\n` : '', sortedData, MATTER_OPTIONS);
+        }
+        else {
+            fileContent = body ? `${body}\n` : '';
+        }
+        files.push({
+            path: relPath,
+            content: fileContent,
+        });
+    }
+    return { files };
+}

package/dist/plugins/markdown/template-sync.js

@@ -2,9 +2,8 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import fg from 'fast-glob';
 import matter from 'gray-matter';
-import yaml from 'js-yaml';
 import { mergeVariantProperties, resolveRef } from '../../schema/schema-refs';
-import { invertFieldMap } from './util';
+import { dumpYaml, invertFieldMap, MATTER_OPTIONS } from './util';
 // Fields derived from the filesystem — present at validation time but not written to frontmatter
 const DERIVED_FIELDS = new Set(['title', 'content']);
 function enumPlaceholder(def) {
@@ -76,7 +75,7 @@ export function generateNewContent(nodeType, variant, schema, schemaRefRegistry,
     const toCanonicalKey = (k) => fieldMap[k] ?? k;
     const exampleWithPlaceholders = withEnumPlaceholders(example, properties, schema, schemaRefRegistry);
     const remappedExample = Object.fromEntries(Object.entries(exampleWithPlaceholders).map(([k, v]) => [toFileKey(k), v]));
-    let frontmatterYaml = yaml.dump(remappedExample, { lineWidth: -1 }).trim();
+    let frontmatterYaml = dumpYaml(remappedExample, { lineWidth: -1 }).trim();
     // Append property descriptions as comments
     // YAML lines use file field names; look up properties using canonical key.
     const lines = frontmatterYaml.split('\n');
@@ -206,7 +205,7 @@ export async function templateSync(context, options) {
             continue;
         }
         const body = content.slice(fmMatch[0].length);
-        const parsed = matter(content);
+        const parsed = matter(content, MATTER_OPTIONS);
         const nodeType = parsed.data.type;
         if (!nodeType) {
             continue;

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

@@ -1,11 +1,32 @@
-import type { TypeInferenceConfig } from '.';
+import { type DumpOptions, type Schema } from 'js-yaml';
+import type { TypeInferenceConfig } from '../../index.js';
 export declare function inferTypeFromPath(filePath: string, config: TypeInferenceConfig, knownTypes: Set<string>, typeAliases: Record<string, string> | undefined): string | undefined;
 /**
- * Coerce Date objects in frontmatter/YAML data to ISO date strings (YYYY-MM-DD).
- * gray-matter and js-yaml parse unquoted ISO dates (e.g. `date: 2026-03-31`) as
- * JavaScript Date objects, which are not valid JSON and fail string type validation.
+ * YAML schema for frontmatter and embedded YAML blocks: YAML 1.2 Core schema extended with
+ * YAML 1.1 merge keys (`<<`), collections (binary, omap, pairs, set), and custom Date scalar
+ * handling that avoids js-yaml's timestamp type. Dates and datetimes stay as the strings
+ * written (e.g. `2026-03-31`, `2026-06-20T22:53:05+10:00`) rather than becoming Date objects,
+ * which lose precision and offset and are not valid JSON.
  */
-export declare function coerceDates(data: Record<string, unknown>): Record<string, unknown>;
+export declare const YAML_SCHEMA: Schema;
+export declare function parseYaml(text: string): unknown;
+export type DumpYamlOptions = DumpOptions & {
+    replacer?: (key: string, value: unknown) => unknown;
+};
+/** Dumps with YAML_SCHEMA. Date values (e.g. from non-markdown plugins) are written as ISO 8601 strings. */
+export declare function dumpYaml(data: unknown, options?: DumpYamlOptions): string;
+/**
+ * gray-matter options using YAML_SCHEMA. Passing options also bypasses gray-matter's parse cache,
+ * which is corrupted by a caught parse error (https://github.com/jonschlinkert/gray-matter/issues/166).
+ */
+export declare const MATTER_OPTIONS: {
+    engines: {
+        yaml: {
+            parse: (text: string) => object;
+            stringify: (data: object) => string;
+        };
+    };
+};
 /**
  * Apply field remapping to a data object.
  * Renames keys according to fieldMap (file field name → canonical field name).

package/dist/plugins/markdown/util.js

@@ -1,4 +1,5 @@
 import { posix } from 'node:path';
+import { binaryTag, CORE_SCHEMA, defineScalarTag, dump, load, mergeTag, omapTag, pairsTag, setTag, visit, } from 'js-yaml';
 export function inferTypeFromPath(filePath, config, knownTypes, typeAliases) {
     if (config.mode === 'off')
         return undefined;
@@ -37,26 +38,66 @@ export function inferTypeFromPath(filePath, config, knownTypes, typeAliases) {
     }
     return undefined;
 }
+const dateTag = defineScalarTag('tag:yaml.org,2002:timestamp', {
+    identify: (data) => data instanceof Date,
+    represent: (data) => data.toISOString(),
+    resolve: (source) => source,
+});
 /**
- * Coerce Date objects in frontmatter/YAML data to ISO date strings (YYYY-MM-DD).
- * gray-matter and js-yaml parse unquoted ISO dates (e.g. `date: 2026-03-31`) as
- * JavaScript Date objects, which are not valid JSON and fail string type validation.
+ * YAML schema for frontmatter and embedded YAML blocks: YAML 1.2 Core schema extended with
+ * YAML 1.1 merge keys (`<<`), collections (binary, omap, pairs, set), and custom Date scalar
+ * handling that avoids js-yaml's timestamp type. Dates and datetimes stay as the strings
+ * written (e.g. `2026-03-31`, `2026-06-20T22:53:05+10:00`) rather than becoming Date objects,
+ * which lose precision and offset and are not valid JSON.
  */
-export function coerceDates(data) {
-    const result = {};
-    for (const [key, value] of Object.entries(data)) {
-        if (value instanceof Date) {
-            result[key] = value.toISOString().slice(0, 10);
-        }
-        else if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-            result[key] = coerceDates(value);
-        }
-        else {
-            result[key] = value;
+export const YAML_SCHEMA = CORE_SCHEMA.withTags(mergeTag, binaryTag, omapTag, pairsTag, setTag, dateTag);
+export function parseYaml(text) {
+    return load(text, { schema: YAML_SCHEMA });
+}
+function applyReplacer(key, value, replacer) {
+    const replaced = replacer(key, value);
+    if (Array.isArray(replaced)) {
+        return replaced.map((item, index) => applyReplacer(String(index), item, replacer));
+    }
+    if (replaced !== null && typeof replaced === 'object' && Object.getPrototypeOf(replaced) === Object.prototype) {
+        const res = {};
+        for (const [k, v] of Object.entries(replaced)) {
+            const vReplaced = applyReplacer(k, v, replacer);
+            if (vReplaced !== undefined) {
+                res[k] = vReplaced;
+            }
         }
+        return res;
     }
-    return result;
+    return replaced;
+}
+/** Dumps with YAML_SCHEMA. Date values (e.g. from non-markdown plugins) are written as ISO 8601 strings. */
+export function dumpYaml(data, options) {
+    const input = options?.replacer ? applyReplacer('', data, options.replacer) : data;
+    const { replacer: _ignored, transform, ...dumpOpts } = options ?? {};
+    return dump(input, {
+        ...dumpOpts,
+        schema: YAML_SCHEMA,
+        transform: (docs) => {
+            visit(docs, (node) => {
+                if (node.kind === 'scalar' && (node.tag === '!!timestamp' || node.tag === 'tag:yaml.org,2002:timestamp')) {
+                    node.tagged = false;
+                    node.tag = 'tag:yaml.org,2002:str';
+                }
+            });
+            transform?.(docs);
+        },
+    });
 }
+/**
+ * gray-matter options using YAML_SCHEMA. Passing options also bypasses gray-matter's parse cache,
+ * which is corrupted by a caught parse error (https://github.com/jonschlinkert/gray-matter/issues/166).
+ */
+export const MATTER_OPTIONS = {
+    engines: {
+        yaml: { parse: (text) => parseYaml(text), stringify: (data) => dumpYaml(data) },
+    },
+};
 /**
  * Apply field remapping to a data object.
  * Renames keys according to fieldMap (file field name → canonical field name).

package/dist/plugins/mermaid/render-mermaid.js

@@ -15,7 +15,8 @@ function safeNodeId(id) {
     return id.replace(/[^a-zA-Z0-9_-]/g, '_');
 }
 export function renderMermaid(graph) {
-    const { hierarchyRoots, orphans, hierarchyChildren: children, hierarchyTitles: hierarchyNodeSet, levels } = graph;
+    const { hierarchyRoots, orphans, hierarchyChildren: children, hierarchyTitles: hierarchyNodeSet } = graph;
+    const levels = graph.hierarchy?.levels ?? [];
     let mmd = 'graph TD\n';
     for (let i = 0; i < levels.length; i++) {
         const level = levels[i];

package/dist/plugins/miro/sync.js

@@ -16,6 +16,7 @@ export async function miroSync(context, graph, options) {
     if (!configuredFrameId && !options.newFrame)
         throw new Error('No frameId in miro plugin config. Pass --new-frame "Title" to create one.');
     // 3. Filter to hierarchy nodes only (graph already built by caller)
+    const levels = graph.hierarchy?.levels ?? [];
     const nodes = [...graph.nodes.values()].filter((n) => graph.hierarchyTitles.has(n.title));
     if (nodes.length === 0) {
         return 'No space nodes found.';
@@ -28,7 +29,7 @@ export async function miroSync(context, graph, options) {
     let layoutOffset = null;
     if (options.newFrame) {
         // Calculate layout bounds to size the frame appropriately
-        const { bounds } = layoutNewCards(nodes, new Map(), graph.levels);
+        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.
@@ -155,7 +156,7 @@ export async function miroSync(context, graph, options) {
         }
     }
     // Compute positions for new cards
-    const { positions: newPositions } = layoutNewCards(newNodes, existingPositions, graph.levels);
+    const { positions: newPositions } = layoutNewCards(newNodes, existingPositions, levels);
     // 7. Create new cards
     let createdCount = 0;
     for (const node of newNodes) {
@@ -185,7 +186,7 @@ export async function miroSync(context, graph, options) {
                 title: buildCardTitle(node),
                 description: buildCardDescription(node),
             },
-            style: { cardTheme: getCardColor(type, graph.levels) },
+            style: { cardTheme: getCardColor(type, levels) },
             position: { x: pos.x, y: pos.y, origin: 'center' },
             parent: { id: frameId },
             geometry: { width: CARD_WIDTH },
@@ -231,7 +232,7 @@ export async function miroSync(context, graph, options) {
                         title: buildCardTitle(node),
                         description: buildCardDescription(node),
                     },
-                    style: { cardTheme: getCardColor(type, graph.levels) },
+                    style: { cardTheme: getCardColor(type, levels) },
                     position: { x: 0, y: 0, origin: 'center' },
                     parent: { id: frameId },
                     geometry: { width: CARD_WIDTH },
@@ -256,8 +257,8 @@ export async function miroSync(context, graph, options) {
     const desiredEdges = new Map();
     for (const node of nodes) {
         const childTitle = node.title;
-        for (const { title: parentTitle, source } of node.resolvedParents) {
-            if (source !== 'hierarchy')
+        for (const { title: parentTitle, source, hierarchy } of node.resolvedParents) {
+            if (source !== 'hierarchy' || hierarchy !== graph.hierarchy?.name)
                 continue;
             // Both endpoints must have verified cards on the board
             if (verifiedCardIds.has(parentTitle) && verifiedCardIds.has(childTitle)) {

package/dist/plugins/util.d.ts

@@ -1,4 +1,6 @@
 import type { AnySchemaObject } from 'ajv';
+import type { Config, SpaceConfig } from '../config';
+import type { PluginSchemaSource } from '../schema/schema';
 import type { SpaceGraph } from '../space-graph';
 import type { BaseNode, ParseIssue, SpaceContext } from '../types';
 export declare const PLUGIN_PREFIX = "sctx-";
@@ -43,6 +45,21 @@ export type RenderOptions = {
     /** Plugin-specific extra data (e.g. CLI flags forwarded by a convenience command). */
     data?: Record<string, unknown>;
 };
+/** A single file generated as part of a multi-file render output. */
+export type RenderFileOutput = {
+    /** Relative path of the file within the destination directory (e.g. 'goals/My Goal.md'). */
+    path: string;
+    /** File content to write. */
+    content: string;
+};
+/** Multi-file render output generated by a render hook. */
+export type RenderMultiFileOutput = {
+    files: RenderFileOutput[];
+};
+/** Render hook output: either a single string (stdout/single file) or multiple files. */
+export type RenderResult = string | RenderMultiFileOutput;
+/** Type guard for multi-file render result. */
+export declare function isRenderMultiFileOutput(result: RenderResult): result is RenderMultiFileOutput;
 /**
  * The render hook on a plugin: declares available formats and handles rendering.
  * Unlike parse/templateSync (first-responder), render hooks are additive —
@@ -50,7 +67,7 @@ export type RenderOptions = {
  */
 export type RenderHook = {
     formats: RenderFormat[];
-    render: (context: PluginContext, graph: SpaceGraph, options: RenderOptions) => Promise<string> | string;
+    render: (context: PluginContext, graph: SpaceGraph, options: RenderOptions) => Promise<RenderResult> | RenderResult;
 };
 /**
  * Plugin contract:
@@ -63,7 +80,28 @@ export type StructuredContextPlugin = {
     /** JSON Schema used to validate the plugin's config block. Fields with `format: 'path'`
      * are resolved relative to the config directory by `resolveConfigPaths` in the loader. */
     configSchema: AnySchemaObject;
+    /** Optional directory containing JSON schemas contributed by this plugin. */
+    schemasDir?: string;
     parse?: ParseHook;
     templateSync?: TemplateSyncHook;
     render?: RenderHook;
 };
+/**
+ * Synchronously locate the root directory of an external plugin.
+ * Resolution order:
+ * 1. Config-adjacent: {configDir}/plugins/{name} or {configDir}/plugins/sctx-{name}
+ * 2. Node module: resolve from configDir using standard module resolution
+ */
+export declare function resolvePluginDir(pluginName: string, configDir: string): string | undefined;
+/**
+ * Synchronously locate the schemas directory for a plugin.
+ * Convention:
+ * 1. package.json "sctx": { "schemas": "..." }
+ * 2. Convention: <pluginDir>/schemas
+ * 3. Fallback for test fixtures: {configDir}/plugins/schemas
+ */
+export declare function resolvePluginSchemasDir(pluginName: string, configDir: string): string | undefined;
+/**
+ * Synchronously collect all plugin schema sources available to a space.
+ */
+export declare function resolveSpacePluginSchemas(space: SpaceConfig | undefined, config: Config, configDir: string): PluginSchemaSource[];

package/dist/plugins/util.js

@@ -1,3 +1,6 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { PLUGIN_PREFIX as _PLUGIN_PREFIX } from '../constants';
 export const PLUGIN_PREFIX = _PLUGIN_PREFIX;
 export const CONFIG_PLUGINS_DIR = 'plugins';
@@ -9,3 +12,139 @@ export function normalizePluginName(name) {
 export function shortenPluginName(name) {
     return name.startsWith(PLUGIN_PREFIX) ? name.slice(PLUGIN_PREFIX.length) : name;
 }
+/** Type guard for multi-file render result. */
+export function isRenderMultiFileOutput(result) {
+    return typeof result === 'object' && result !== null && Array.isArray(result.files);
+}
+/**
+ * Synchronously locate the root directory of an external plugin.
+ * Resolution order:
+ * 1. Config-adjacent: {configDir}/plugins/{name} or {configDir}/plugins/sctx-{name}
+ * 2. Node module: resolve from configDir using standard module resolution
+ */
+export function resolvePluginDir(pluginName, configDir) {
+    const normalized = normalizePluginName(pluginName);
+    const short = shortenPluginName(pluginName);
+    for (const candidate of [normalized, short]) {
+        const localDir = resolve(configDir, CONFIG_PLUGINS_DIR, candidate);
+        if (existsSync(localDir)) {
+            try {
+                if (statSync(localDir).isDirectory()) {
+                    return localDir;
+                }
+            }
+            catch { }
+        }
+    }
+    // Node module resolution from configDir
+    for (const candidate of [normalized, short]) {
+        try {
+            const req = createRequire(join(configDir, 'package.json'));
+            const pkgPath = req.resolve(`${candidate}/package.json`);
+            return dirname(pkgPath);
+        }
+        catch {
+            const nmCandidate = resolve(configDir, 'node_modules', candidate);
+            if (existsSync(nmCandidate)) {
+                try {
+                    if (statSync(nmCandidate).isDirectory()) {
+                        return nmCandidate;
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Synchronously locate the schemas directory for a plugin.
+ * Convention:
+ * 1. package.json "sctx": { "schemas": "..." }
+ * 2. Convention: <pluginDir>/schemas
+ * 3. Fallback for test fixtures: {configDir}/plugins/schemas
+ */
+export function resolvePluginSchemasDir(pluginName, configDir) {
+    const dir = resolvePluginDir(pluginName, configDir);
+    if (dir) {
+        // 1. package.json sctx.schemas
+        const pkgJsonPath = join(dir, 'package.json');
+        if (existsSync(pkgJsonPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf8'));
+                if (pkg.sctx?.schemas && typeof pkg.sctx.schemas === 'string') {
+                    const customSchemas = resolve(dir, pkg.sctx.schemas);
+                    if (existsSync(customSchemas) && statSync(customSchemas).isDirectory()) {
+                        return customSchemas;
+                    }
+                }
+            }
+            catch { }
+        }
+        // 2. Convention: <pluginDir>/schemas
+        const conventionDir = join(dir, 'schemas');
+        if (existsSync(conventionDir)) {
+            try {
+                if (statSync(conventionDir).isDirectory()) {
+                    return conventionDir;
+                }
+            }
+            catch { }
+        }
+    }
+    // 3. Check config-adjacent plugins/schemas as fallback (e.g. test fixtures)
+    const fallbackSchemas = resolve(configDir, CONFIG_PLUGINS_DIR, 'schemas');
+    if (existsSync(fallbackSchemas)) {
+        try {
+            if (statSync(fallbackSchemas).isDirectory()) {
+                return fallbackSchemas;
+            }
+        }
+        catch { }
+    }
+    return undefined;
+}
+/**
+ * Synchronously collect all plugin schema sources available to a space.
+ */
+export function resolveSpacePluginSchemas(space, config, configDir) {
+    const pluginSources = [];
+    const seenPlugins = new Set();
+    const maybeAddPlugin = (name) => {
+        const shortName = shortenPluginName(name);
+        if (seenPlugins.has(shortName))
+            return;
+        seenPlugins.add(shortName);
+        const schemasDir = resolvePluginSchemasDir(name, configDir);
+        if (schemasDir) {
+            pluginSources.push({
+                pluginName: shortName,
+                schemasDir,
+            });
+        }
+    };
+    // 1. Plugin referenced by space.schema prefix if any (e.g. sctx-wardley-mapping/wardley_map.json)
+    const rawSchema = space?.schema ?? config.schema;
+    if (rawSchema && !isAbsolute(rawSchema) && !rawSchema.startsWith('.')) {
+        const normalized = rawSchema.replace(/\\/g, '/');
+        const slashIdx = normalized.indexOf('/');
+        if (slashIdx !== -1) {
+            const prefix = normalized.slice(0, slashIdx);
+            maybeAddPlugin(prefix);
+        }
+    }
+    // 2. Plugins configured on space
+    if (space?.plugins) {
+        for (const name of Object.keys(space.plugins)) {
+            maybeAddPlugin(name);
+        }
+    }
+    // 3. Plugins configured globally
+    const globalPlugins = config.plugins;
+    if (globalPlugins) {
+        for (const name of Object.keys(globalPlugins)) {
+            maybeAddPlugin(name);
+        }
+    }
+    return pluginSources;
+}

package/dist/read/resolve-graph-edges.d.ts

@@ -1,7 +1,7 @@
 import type { BaseNode, SchemaMetadata, SpaceNode, UnresolvedRef } from '../types';
 /**
  * Enrich parsed nodes into SpaceNodes by applying type alias resolution and resolving
- * parent links using the hierarchy levels and relationships from schema metadata.
+ * parent links using the levels of every hierarchy and the relationships from schema metadata.
  *
  * Returns the enriched nodes and any unresolved refs (broken/invalid wikilinks).
  */