structured-context 0.12.0 → 0.13.0

package/dist/judge/provider/openai-decisions.js

@@ -0,0 +1,84 @@
+export const RECOMMENDED_OPENAI_DECISIONS_MODEL = 'gpt-6-luna';
+export const OPENAI_DECISIONS_ENDPOINT = 'https://api.openai.com/v1/decisions';
+/**
+ * Judge provider for OpenAI's Decisions API (https://developers.openai.com/api/docs/guides/decisions).
+ *
+ * Each node is sent once as the `input` text, with one `choice` question per semantic rule whose
+ * choices are the rule's closed verdict set. The API returns the chosen value with per-choice
+ * probabilities and a confidence, but no prose, so `evidence` is a summary of the distribution.
+ */
+export class OpenAIDecisionsJudgeProvider {
+    name = 'openai-decisions';
+    apiKey;
+    model;
+    endpoint;
+    constructor(options) {
+        this.apiKey = options.apiKey ?? '';
+        this.model = options.model || RECOMMENDED_OPENAI_DECISIONS_MODEL;
+        this.endpoint = options.endpoint || OPENAI_DECISIONS_ENDPOINT;
+    }
+    async evaluate(input) {
+        const { node, rules } = input;
+        const stateLines = [
+            `Title: ${node.title}`,
+            `Type: ${node.resolvedType}`,
+            ...(node.resolvedParents?.length ? [`Parents: ${node.resolvedParents.map((p) => p.title).join(', ')}`] : []),
+            ...fieldLines(node.schemaData ?? {}),
+            ...(input.related ?? []).flatMap((r) => [
+                '',
+                `Related node (${r.relations.join(', ')}): ${r.title}`,
+                `Type: ${r.type}`,
+                ...fieldLines(r.data),
+            ]),
+        ];
+        const res = await fetch(this.endpoint, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', authorization: `Bearer ${this.apiKey}` },
+            body: JSON.stringify({
+                model: this.model,
+                input: stateLines.join('\n'),
+                questions: rules.map((rule) => ({
+                    type: 'choice',
+                    name: rule.id,
+                    instructions: rule.rubric || rule.description,
+                    choices: Object.entries(rule.verdicts).map(([value, description]) => ({ value, description })),
+                })),
+            }),
+        });
+        if (!res.ok) {
+            const errorText = await res.text().catch(() => '');
+            throw new Error(`OpenAI Decisions API error (${res.status}): ${errorText}`);
+        }
+        const data = (await res.json());
+        const answers = new Map((data.answers ?? []).filter((a) => a.name).map((a) => [a.name, a]));
+        const results = {};
+        for (const rule of rules) {
+            const answer = answers.get(rule.id);
+            if (!answer || answer.type === 'refusal' || !answer.choice || !(answer.choice in rule.verdicts)) {
+                results[rule.id] = { error: `OpenAI Decisions returned no valid verdict for rule "${rule.id}"` };
+                continue;
+            }
+            const probabilities = Object.fromEntries((answer.probabilities ?? []).map((p) => [p.value, p.probability]));
+            results[rule.id] = {
+                verdict: answer.choice,
+                confidence: answer.confidence,
+                probabilities,
+                evidence: describeDistribution(answer.choice, answer.confidence, probabilities),
+            };
+        }
+        return results;
+    }
+}
+function fieldLines(data) {
+    return Object.entries(data)
+        .filter(([field]) => field !== 'title' && field !== 'type')
+        .map(([field, value]) => `${field}: ${JSON.stringify(value) ?? String(value)}`);
+}
+function describeDistribution(choice, confidence, probabilities) {
+    const parts = Object.entries(probabilities)
+        .sort(([, a], [, b]) => b - a)
+        .map(([verdict, p]) => `${verdict} ${p.toFixed(2)}`);
+    const conf = confidence !== undefined ? `confidence ${confidence.toFixed(2)}` : undefined;
+    const detail = [conf, ...parts].filter(Boolean).join('; ');
+    return `OpenAI Decisions chose "${choice}"${detail ? ` (${detail})` : ''}`;
+}

package/dist/judge/provider/openai.d.ts

@@ -0,0 +1,20 @@
+import type { HydratedProvider, SemanticJudgeInput, SemanticJudgeResult, SemanticRuleSpec } from '../types';
+import { PerRuleJudgeProvider } from './per-rule';
+export interface OpenAIJudgeProviderOptions extends HydratedProvider {
+    /** Optional: local OpenAI-compatible servers need no key. */
+    apiKey?: string;
+}
+export declare const RECOMMENDED_OPENAI_MODEL = "gpt-6-luna";
+export declare const OPENAI_COMPLETIONS_ENDPOINT = "https://api.openai.com/v1";
+/**
+ * Judge provider for the OpenAI-compatible Chat Completions API (OpenAI, Ollama, vLLM, ...).
+ * Reads no environment: it takes hydrated values.
+ */
+export declare class OpenAIJudgeProvider extends PerRuleJudgeProvider {
+    readonly name = "openai";
+    private apiKey?;
+    private model;
+    private endpoint;
+    constructor(options: OpenAIJudgeProviderOptions);
+    protected judgeRule(input: SemanticJudgeInput, rule: SemanticRuleSpec): Promise<SemanticJudgeResult>;
+}

package/dist/judge/provider/openai.js

@@ -0,0 +1,53 @@
+import { buildJudgeSystemPrompt, buildJudgeUserPrompt, parseJudgeResponse } from '../prompt';
+import { PerRuleJudgeProvider } from './per-rule';
+export const RECOMMENDED_OPENAI_MODEL = 'gpt-6-luna';
+export const OPENAI_COMPLETIONS_ENDPOINT = 'https://api.openai.com/v1';
+/**
+ * Judge provider for the OpenAI-compatible Chat Completions API (OpenAI, Ollama, vLLM, ...).
+ * Reads no environment: it takes hydrated values.
+ */
+export class OpenAIJudgeProvider extends PerRuleJudgeProvider {
+    name = 'openai';
+    apiKey;
+    model;
+    endpoint;
+    constructor(options) {
+        super();
+        this.apiKey = options.apiKey;
+        this.model = options.model || RECOMMENDED_OPENAI_MODEL;
+        const base = options.endpoint || OPENAI_COMPLETIONS_ENDPOINT;
+        this.endpoint = base.endsWith('/chat/completions') ? base : `${base.replace(/\/+$/, '')}/chat/completions`;
+    }
+    async judgeRule(input, rule) {
+        const systemPrompt = buildJudgeSystemPrompt();
+        const userPrompt = buildJudgeUserPrompt(input, rule);
+        const headers = {
+            'content-type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers.authorization = `Bearer ${this.apiKey}`;
+        }
+        const res = await fetch(this.endpoint, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                model: this.model,
+                response_format: { type: 'json_object' },
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: userPrompt },
+                ],
+            }),
+        });
+        if (!res.ok) {
+            const errorText = await res.text().catch(() => '');
+            throw new Error(`OpenAI API error (${res.status}): ${errorText}`);
+        }
+        const data = (await res.json());
+        const content = data.choices?.[0]?.message?.content;
+        if (!content) {
+            throw new Error('OpenAI API returned empty or missing message content in response.');
+        }
+        return parseJudgeResponse(content, Object.keys(rule.verdicts));
+    }
+}

package/dist/judge/provider/per-rule.d.ts

@@ -0,0 +1,10 @@
+import type { SemanticJudgeInput, SemanticJudgeProvider, SemanticJudgeResult, SemanticRuleSpec } from '../types';
+/**
+ * Base for providers that can only judge one rule per request (chat LLMs). `evaluate` makes one call
+ * per rule; a failure on one rule is reported for that rule and does not affect the others.
+ */
+export declare abstract class PerRuleJudgeProvider implements SemanticJudgeProvider {
+    abstract readonly name: string;
+    protected abstract judgeRule(input: SemanticJudgeInput, rule: SemanticRuleSpec): Promise<SemanticJudgeResult>;
+    evaluate(input: SemanticJudgeInput): Promise<Record<string, SemanticJudgeResult>>;
+}

package/dist/judge/provider/per-rule.js

@@ -0,0 +1,18 @@
+/**
+ * Base for providers that can only judge one rule per request (chat LLMs). `evaluate` makes one call
+ * per rule; a failure on one rule is reported for that rule and does not affect the others.
+ */
+export class PerRuleJudgeProvider {
+    async evaluate(input) {
+        const results = {};
+        for (const rule of input.rules) {
+            try {
+                results[rule.id] = await this.judgeRule(input, rule);
+            }
+            catch (err) {
+                results[rule.id] = { error: err instanceof Error ? err.message : String(err) };
+            }
+        }
+        return results;
+    }
+}

package/dist/judge/trim.d.ts

@@ -0,0 +1,27 @@
+import type { SemanticJudgeInput } from '../types.js';
+/** The per-node input cap: estimated tokens of one node's input (the node and its related nodes), the same for every provider. */
+export declare const PER_NODE_INPUT_CAP_TOKENS = 32000;
+/** Estimated tokens of a value: its JSON length divided by 4. Provider-independent, and roughly right is enough. */
+export declare const estimateTokens: (value: unknown) => number;
+/** The placeholder that ends a body cut to fit the per-node input cap. `removed` is the number of characters cut. */
+export declare const trimMarker: (removed: number) => string;
+/** The part of a judge input that the per-node input cap measures. */
+export type NodeInput = Pick<SemanticJudgeInput, 'node' | 'related'>;
+/**
+ * Cut `body` to at most `limit` characters, ending at the last whitespace before the limit, and end it with the
+ * trim marker. A body within the limit is returned whole.
+ */
+export declare function cutBody(body: string, limit: number): string;
+/**
+ * Fit a node's input under the per-node input cap by cutting bodies only: related bodies to one shared ceiling
+ * first, then the evaluated node's body. Undefined when the input does not fit even with every body cut.
+ */
+export declare function trimToCap(input: NodeInput, cap?: number): {
+    input: NodeInput;
+    trimmed: boolean;
+} | undefined;
+/** What a run trimmed: the nodes (by label) and the rules whose input had a body cut. */
+export interface TrimReport {
+    nodes: Set<string>;
+    ruleIds: Set<string>;
+}

package/dist/judge/trim.js

@@ -0,0 +1,62 @@
+/** The per-node input cap: estimated tokens of one node's input (the node and its related nodes), the same for every provider. */
+export const PER_NODE_INPUT_CAP_TOKENS = 32_000;
+/** Estimated tokens of a value: its JSON length divided by 4. Provider-independent, and roughly right is enough. */
+export const estimateTokens = (value) => Math.ceil(JSON.stringify(value).length / 4);
+/** The placeholder that ends a body cut to fit the per-node input cap. `removed` is the number of characters cut. */
+export const trimMarker = (removed) => `[RULE_EVALUATION_CONTENT_TRIMMED ${removed} chars]`;
+/**
+ * Cut `body` to at most `limit` characters, ending at the last whitespace before the limit, and end it with the
+ * trim marker. A body within the limit is returned whole.
+ */
+export function cutBody(body, limit) {
+    if (body.length <= limit)
+        return body;
+    let head = body.slice(0, limit);
+    if (!/\s/.test(body.charAt(limit))) {
+        const lastSpace = head.search(/\s\S*$/);
+        head = lastSpace < 0 ? '' : head.slice(0, lastSpace);
+    }
+    head = head.trimEnd();
+    const marker = trimMarker(body.length - head.length);
+    return head ? `${head} ${marker}` : marker;
+}
+function limitBodies(input, relatedLimit, nodeLimit) {
+    const cut = (data, limit) => typeof data.content === 'string' ? { ...data, content: cutBody(data.content, limit) } : data;
+    return {
+        node: { ...input.node, schemaData: cut(input.node.schemaData, nodeLimit) },
+        ...(input.related && { related: input.related.map((r) => ({ ...r, data: cut(r.data, relatedLimit) })) }),
+    };
+}
+const bodyLength = (data) => (typeof data.content === 'string' ? data.content.length : 0);
+/** The largest limit in `[0, max]` for which `fits` holds, or -1 when even 0 does not fit. `fits` shrinks as the limit falls. */
+function largestFitting(max, fits) {
+    if (!fits(0))
+        return -1;
+    let low = 0;
+    let high = max;
+    while (low < high) {
+        const mid = Math.ceil((low + high) / 2);
+        if (fits(mid))
+            low = mid;
+        else
+            high = mid - 1;
+    }
+    return low;
+}
+/**
+ * Fit a node's input under the per-node input cap by cutting bodies only: related bodies to one shared ceiling
+ * first, then the evaluated node's body. Undefined when the input does not fit even with every body cut.
+ */
+export function trimToCap(input, cap = PER_NODE_INPUT_CAP_TOKENS) {
+    if (estimateTokens(input) <= cap)
+        return { input, trimmed: false };
+    const nodeLength = bodyLength(input.node.schemaData);
+    const relatedMax = Math.max(0, ...(input.related ?? []).map((r) => bodyLength(r.data)));
+    const fitsRelated = (limit) => estimateTokens(limitBodies(input, limit, nodeLength)) <= cap;
+    const relatedLimit = largestFitting(relatedMax, fitsRelated);
+    if (relatedLimit >= 0)
+        return { input: limitBodies(input, relatedLimit, nodeLength), trimmed: true };
+    const fitsNode = (limit) => estimateTokens(limitBodies(input, 0, limit)) <= cap;
+    const nodeLimit = largestFitting(nodeLength, fitsNode);
+    return nodeLimit >= 0 ? { input: limitBodies(input, 0, nodeLimit), trimmed: true } : undefined;
+}

package/dist/judge/types.d.ts

@@ -0,0 +1,92 @@
+import type { RuleCategory, SpaceNode } from '../types';
+/** A semantic rule as presented to a judge: the closed verdict set it must choose from. */
+export interface SemanticRuleSpec {
+    id: string;
+    description: string;
+    rubric?: string;
+    category: RuleCategory | string;
+    /** Allowed verdicts, each with a description of when it applies. */
+    verdicts: Record<string, string>;
+}
+/**
+ * A node related to the evaluated node by its rules' `scope`. It carries all the node's schema data; the body
+ * (`data.content`) is present only when the rules' `includeContent` asks for it.
+ */
+export interface RelatedNode {
+    /** How it relates to the evaluated node. A node can have several. */
+    relations: Array<'parent' | 'sibling' | 'child' | 'ancestor' | 'descendant'>;
+    title: string;
+    type: string;
+    /** Schema data without `title` and `type`. */
+    data: Record<string, unknown>;
+}
+/**
+ * One node and the semantic rules to judge on it, which share one context: the same related nodes and the same
+ * bodies. Judges may answer all rules in a single call.
+ */
+export interface SemanticJudgeInput {
+    /** The evaluated node. Its body is in `schemaData.content` only when the rules' `includeContent` asks for it. */
+    node: Pick<SpaceNode, 'label' | 'title' | 'type' | 'resolvedType' | 'schemaData' | 'resolvedParents'>;
+    /** Nodes the rules' `scope` adds, as a flat list. Absent when the scope is empty. */
+    related?: RelatedNode[];
+    rules: SemanticRuleSpec[];
+}
+/** A judge's answer for one rule: a verdict from the rule's closed set. */
+export interface SemanticJudgeVerdict {
+    verdict: string;
+    /** 0-1, when the judge reports one. */
+    confidence?: number;
+    /** Probability per verdict, when the judge reports a distribution. */
+    probabilities?: Record<string, number>;
+    /** Free-text reasoning; decision models may not provide it. */
+    evidence?: string;
+}
+/** A judge's answer for one rule: a verdict, or an error that applies to that rule only. */
+export type SemanticJudgeResult = SemanticJudgeVerdict | {
+    error: string;
+};
+/** Judge interface. Results are keyed by rule id; a missing key is treated as an error. */
+export interface SemanticJudgeProvider {
+    readonly name: string;
+    evaluate(input: SemanticJudgeInput): Promise<Record<string, SemanticJudgeResult>>;
+    /**
+     * Optional: judge many nodes in one call, so a provider can fold them into fewer model calls. Returns one
+     * result map per input, in order. A failure that affects only some inputs is reported as `{ error }`
+     * results for those inputs' rules; throw only when nothing could be judged.
+     */
+    evaluateNodes?(inputs: SemanticJudgeInput[]): Promise<Array<Record<string, SemanticJudgeResult>>>;
+}
+/** Wire APIs a provider can speak. Names the request shape, never the vendor or model. */
+export declare const MODEL_PROVIDER_APIS: readonly ["openai-completions", "openai-decisions", "anthropic-messages", "openrouter-decisions", "typesafe-systemone", "fake"];
+export type ModelProviderApi = (typeof MODEL_PROVIDER_APIS)[number];
+/** How to reach a model: a bundled provider or config `modelProviders.<name>`, before hydration. */
+export interface ModelProviderConfig {
+    /** The wire API to speak. */
+    api: ModelProviderApi;
+    /** Fixed model override. Beats `modelEnv` and the bundled default. */
+    model?: string;
+    /** Environment variable that holds the model override. */
+    modelEnv?: string;
+    /** Fixed endpoint override. Beats `endpointEnv` and the bundled default. */
+    endpoint?: string;
+    /** Environment variable that holds the endpoint override. */
+    endpointEnv?: string;
+    /** Prefer `apiKeyEnv`: keys do not belong in config files. */
+    apiKey?: string;
+    /** Environment variable holding the key. */
+    apiKeyEnv?: string;
+}
+/** A provider after hydration: every field is a concrete value; the implementation reads no environment. */
+export interface HydratedProvider {
+    api: ModelProviderApi;
+    model?: string;
+    endpoint?: string;
+    apiKey?: string;
+    /** The environment variable the key was read from, when one was named or defaulted. */
+    keyEnv?: string;
+}
+/** Which model provider evaluates semantic rules: config `semantic`, at the top level or on a space. */
+export interface JudgeConfig {
+    /** Name of an entry in `modelProviders`, or a bundled provider. */
+    provider?: string;
+}

package/dist/judge/types.js

@@ -0,0 +1,9 @@
+/** Wire APIs a provider can speak. Names the request shape, never the vendor or model. */
+export const MODEL_PROVIDER_APIS = [
+    'openai-completions',
+    'openai-decisions',
+    'anthropic-messages',
+    'openrouter-decisions',
+    'typesafe-systemone',
+    'fake',
+];

package/dist/judge/verdicts.d.ts

@@ -0,0 +1,24 @@
+import type { Rule, RuleSeverity } from '../types';
+import type { SemanticJudgeResult, SemanticRuleSpec } from '../types.js';
+/** Verdicts for a semantic rule that declares none. */
+export declare const DEFAULT_VERDICTS: Record<string, string>;
+/** A semantic rule resolved for evaluation: what the judge sees, and what each verdict means for the user. */
+export interface ResolvedSemanticRule {
+    /** What the judge sees: the closed verdict set. */
+    spec: SemanticRuleSpec;
+    /** Severity of each verdict that fails the rule. A verdict absent here passes (including `ignore`d ones). */
+    severities: Record<string, RuleSeverity>;
+    /** User-facing guidance for verdicts that declare it. */
+    guidance: Record<string, string>;
+}
+/**
+ * Resolve a semantic rule: apply verdict defaults, split each verdict into its judge description and user guidance,
+ * and work out which verdicts fail at what severity. Throws on an inconsistent rule.
+ */
+export declare function resolveSemanticRule(rule: Rule): ResolvedSemanticRule;
+/** The judge-facing spec for a semantic rule. */
+export declare function semanticRuleSpec(rule: Rule): SemanticRuleSpec;
+/** Whether a judge result is an error rather than a verdict. */
+export declare function isJudgeError(result: SemanticJudgeResult): result is {
+    error: string;
+};

package/dist/judge/verdicts.js

@@ -0,0 +1,82 @@
+import { RESERVED_VERDICTS } from '../schema/metadata-contract';
+import { ruleSemantic, ruleSeverity } from '../schema/rule-severity';
+import { ruleContext } from './context';
+/** Verdicts for a semantic rule that declares none. */
+export const DEFAULT_VERDICTS = {
+    pass: 'The node meets the rubric.',
+    fail: 'The node does not meet the rubric.',
+};
+/** The reserved verdict a rule with related nodes or bodies offers, for input a trim marker shows was cut. */
+const MISSING_CONTEXT_VERDICT = 'missing-context';
+const MISSING_CONTEXT_DESCRIPTION = 'Content needed to judge the rule was cut: a [RULE_EVALUATION_CONTENT_TRIMMED n chars] marker shows where. Choose this only when such a marker is present and the cut content is needed. Never choose it when no marker appears.';
+/**
+ * Resolve a semantic rule: apply verdict defaults, split each verdict into its judge description and user guidance,
+ * and work out which verdicts fail at what severity. Throws on an inconsistent rule.
+ */
+export function resolveSemanticRule(rule) {
+    const semantic = ruleSemantic(rule);
+    if (!semantic)
+        throw new Error(`Rule "${rule.id}" has no semantic part.`);
+    const declared = semantic.verdicts ?? DEFAULT_VERDICTS;
+    const verdicts = {};
+    const guidance = {};
+    for (const [name, value] of Object.entries(declared)) {
+        if (typeof value === 'string') {
+            verdicts[name] = value;
+        }
+        else {
+            verdicts[name] = value.description;
+            if (value.guidance)
+                guidance[name] = value.guidance;
+        }
+    }
+    let mapping;
+    if (semantic.verdicts) {
+        if (!semantic.severity) {
+            throw new Error(`Semantic rule "${rule.id}" declares verdicts, so semantic.severity must map the failing verdicts, e.g. { "${Object.keys(verdicts)[0]}": "warning" }.`);
+        }
+        mapping = semantic.severity;
+    }
+    else {
+        mapping = { ...semantic.severity, fail: ruleSeverity(rule) };
+    }
+    const reserved = RESERVED_VERDICTS;
+    const unknown = Object.keys(mapping).filter((v) => !(v in verdicts) && !reserved.includes(v));
+    if (unknown.length > 0) {
+        throw new Error(`Semantic rule "${rule.id}" has semantic.severity for verdicts not in its verdicts: ${unknown.join(', ')}.`);
+    }
+    const severities = {};
+    for (const [verdict, severity] of Object.entries(mapping)) {
+        if (severity !== 'ignore')
+            severities[verdict] = severity;
+    }
+    if (Object.keys(severities).filter((v) => v in verdicts).length >= Object.keys(verdicts).length) {
+        throw new Error(`Semantic rule "${rule.id}" has no passing verdict: every verdict has a severity.`);
+    }
+    // A warning by default.
+    const context = ruleContext(rule);
+    if (context.scope.length > 0 || context.content !== 'none') {
+        verdicts[MISSING_CONTEXT_VERDICT] = MISSING_CONTEXT_DESCRIPTION;
+        if (!(MISSING_CONTEXT_VERDICT in mapping))
+            severities[MISSING_CONTEXT_VERDICT] = 'warning';
+    }
+    return {
+        spec: {
+            id: rule.id,
+            description: rule.description,
+            rubric: semantic.rubric,
+            category: rule.category,
+            verdicts,
+        },
+        severities,
+        guidance,
+    };
+}
+/** The judge-facing spec for a semantic rule. */
+export function semanticRuleSpec(rule) {
+    return resolveSemanticRule(rule).spec;
+}
+/** Whether a judge result is an error rather than a verdict. */
+export function isJudgeError(result) {
+    return 'error' in result;
+}

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

@@ -1,6 +1,6 @@
-import type { Config } from './config';
-import { type SpaceGraph } from './space-graph';
-import type { ReadSpaceResult, SpaceContext } from './types';
+import type { Config } from './config.js';
+import { type SpaceGraph } from './space-graph.js';
+import type { ReadSpaceResult, SpaceContext } from './types.js';
 export interface AssembleSpaceGraphOptions {
     /** Named view (resolved via space.views) or a raw filter DSL expression. */
     filter?: string;

package/dist/load-space-graph.js

@@ -1,7 +1,7 @@
-import { filterNodes } from './filter/filter-nodes';
-import { readSpace } from './read/read-space';
-import { createSpaceContext } from './space-context';
-import { buildSpaceGraph } from './space-graph';
+import { filterNodes } from './filter/filter-nodes.js';
+import { readSpace } from './read/read-space.js';
+import { createSpaceContext } from './space-context.js';
+import { buildSpaceGraph } from './space-graph.js';
 /**
  * Assemble a SpaceGraph from a space context: read the space, drop nodes that
  * fail schema validation, build the graph for the selected hierarchy (the main

package/dist/plugins/loader.js

@@ -2,7 +2,7 @@ import { existsSync, readdirSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import Ajv2020 from 'ajv/dist/2020';
 import { getConfigSourceFiles } from '../config';
-import { builtinPlugins } from '.';
+import { builtinPlugins } from '../index.js';
 import { CONFIG_PLUGINS_DIR, normalizePluginName, PLUGIN_PREFIX, shortenPluginName, } from './util';
 /**
  * Walk a plugin's configSchema and resolve any string fields annotated with

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

@@ -8,6 +8,8 @@ type StackEntry = {
     nodeType: string;
     /** Preferred wikilink key used when this heading acts as a parent. */
     refTarget: string;
+    /** Node whose section this heading opens; absent for untyped placeholders and the page's own entry. */
+    node?: BaseNode;
 };
 /** Detect a bare wikilink `[[...]]` and return the inner target, or undefined. */
 export declare function isWikilink(text: string): string | undefined;