@lapidist/dtif-parser 0.2.0

package/dist/plugins/types.d.ts

@@ -0,0 +1,48 @@
+import type { Diagnostic } from '../types.js';
+import type { JsonPointer, RawDocument, SourceSpan } from '../types.js';
+import type { ResolvedToken } from '../resolver/index.js';
+export interface ExtensionHandlerInput {
+    readonly namespace: string;
+    readonly pointer: JsonPointer;
+    readonly span?: SourceSpan;
+    readonly value: unknown;
+    readonly document: RawDocument;
+}
+export interface ExtensionHandlerResult {
+    readonly normalized?: unknown;
+    readonly diagnostics?: readonly Diagnostic[];
+}
+export type ExtensionHandler = (input: ExtensionHandlerInput) => ExtensionHandlerResult | void;
+export interface ExtensionEvaluation {
+    readonly plugin: string;
+    readonly namespace: string;
+    readonly pointer: JsonPointer;
+    readonly span?: SourceSpan;
+    readonly value: unknown;
+    readonly normalized?: unknown;
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface ResolvedTokenTransformContext {
+    readonly document: RawDocument;
+}
+export interface ResolvedTokenTransformResult {
+    readonly data?: unknown;
+    readonly diagnostics?: readonly Diagnostic[];
+}
+export type ResolvedTokenTransform = (token: ResolvedToken, context: ResolvedTokenTransformContext) => ResolvedTokenTransformResult | void;
+export interface ResolvedTokenTransformEvaluation {
+    readonly plugin: string;
+    readonly pointer: JsonPointer;
+    readonly data?: unknown;
+    readonly diagnostics: readonly Diagnostic[];
+}
+export interface ParserPlugin {
+    readonly name: string;
+    readonly extensions?: ReadonlyMap<string, ExtensionHandler> | Readonly<Record<string, ExtensionHandler>>;
+    readonly transformResolvedToken?: ResolvedTokenTransform;
+}
+export interface ResolvedTokenTransformEntry {
+    readonly plugin: string;
+    readonly transform: ResolvedTokenTransform;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/plugins/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/plugins/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;CAChC;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CAC9C;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,qBAAqB,KAAK,sBAAsB,GAAG,IAAI,CAAC;AAE/F,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;CAChC;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CAC9C;AAED,MAAM,MAAM,sBAAsB,GAAG,CACnC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE,6BAA6B,KACnC,4BAA4B,GAAG,IAAI,CAAC;AAEzC,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,CAAC,EAChB,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,GACrC,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC;IAC/C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CAC1D;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;CAC5C"}

package/dist/plugins/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/plugins/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/plugins/types.ts"],"names":[],"mappings":""}

package/dist/resolver/document-resolver.d.ts

@@ -0,0 +1,29 @@
+import type { JsonPointer } from '../types.js';
+import type { DocumentGraph } from '../graph/nodes.js';
+import type { DocumentResolverOptions, ResolutionResult } from './types.js';
+export declare class DocumentResolver {
+    private readonly graph;
+    private readonly context;
+    private readonly overrides;
+    private readonly maxDepth;
+    private readonly document?;
+    private readonly transforms;
+    private readonly cache;
+    private readonly pending;
+    constructor(graph: DocumentGraph, options?: DocumentResolverOptions);
+    resolve(pointer: JsonPointer): ResolutionResult;
+    private resolveInternal;
+    private resolveBaseNode;
+    private resolveTokenNode;
+    private resolveAliasNode;
+    private applyOverrides;
+    private evaluateOverride;
+    private doesOverrideApply;
+    private resolveOverrideRef;
+    private resolveOverrideValue;
+    private resolveFallbackChain;
+    private resolveFallbackEntry;
+    private applyTransforms;
+}
+export declare function createDocumentResolver(graph: DocumentGraph, options?: DocumentResolverOptions): DocumentResolver;
+//# sourceMappingURL=document-resolver.d.ts.map

package/dist/resolver/document-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-resolver.d.ts","sourceRoot":"","sources":["../../src/resolver/document-resolver.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,WAAW,EAAe,MAAM,aAAa,CAAC;AACxE,OAAO,KAAK,EACV,aAAa,EAOd,MAAM,mBAAmB,CAAC;AA4B3B,OAAO,KAAK,EACV,uBAAuB,EACvB,gBAAgB,EAOjB,MAAM,YAAY,CAAC;AA+BpB,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+B;IACvD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyD;IACnF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAc;IACxC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyC;IACpE,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2C;IACjE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;gBAEtC,KAAK,EAAE,aAAa,EAAE,OAAO,GAAE,uBAA4B;IASvE,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,gBAAgB;IAkC/C,OAAO,CAAC,eAAe;IAoEvB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,gBAAgB;IAgCxB,OAAO,CAAC,gBAAgB;IAwExB,OAAO,CAAC,cAAc;IA2CtB,OAAO,CAAC,gBAAgB;IAmExB,OAAO,CAAC,iBAAiB;IAmBzB,OAAO,CAAC,kBAAkB;IAiF1B,OAAO,CAAC,oBAAoB;IA4B5B,OAAO,CAAC,oBAAoB;IA0C5B,OAAO,CAAC,oBAAoB;IA4H5B,OAAO,CAAC,eAAe;CAsCxB;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,aAAa,EACpB,OAAO,GAAE,uBAA4B,GACpC,gBAAgB,CAElB"}

package/dist/resolver/document-resolver.js

@@ -0,0 +1,551 @@
+import { DiagnosticCodes } from '../diagnostics/codes.js';
+import { DiagnosticBag } from '../diagnostics/bag.js';
+import { JSON_POINTER_ROOT, normalizeJsonPointer } from '../utils/json-pointer.js';
+import { EMPTY_DIAGNOSTICS, EMPTY_OVERRIDES, EMPTY_TRACE, EMPTY_WARNINGS, EMPTY_TRANSFORM_EVALUATIONS, EMPTY_TRANSFORM_ENTRIES, DEFAULT_MAX_DEPTH } from './internal/constants.js';
+import { finalizeResolution, freezeResultDiagnostics, createTransformFailureDiagnostic, createTraceStep, createFieldSource, createTargetSource, mergeDiagnostics, conditionMatches } from './internal/helpers.js';
+import { normalizeContext, normalizeMaxDepth, indexOverrides, normalizeTransforms } from './internal/context.js';
+import { ResolvedTokenImpl } from './internal/resolved-token.js';
+export class DocumentResolver {
+    graph;
+    context;
+    overrides;
+    maxDepth;
+    document;
+    transforms;
+    cache = new Map();
+    pending = new Set();
+    constructor(graph, options = {}) {
+        this.graph = graph;
+        this.context = normalizeContext(options.context);
+        this.overrides = indexOverrides(graph.overrides);
+        this.maxDepth = normalizeMaxDepth(options.maxDepth);
+        this.document = options.document;
+        this.transforms = normalizeTransforms(options.transforms);
+    }
+    resolve(pointer) {
+        const diagnostics = new DiagnosticBag();
+        try {
+            const normalized = normalizeJsonPointer(pointer);
+            const state = this.resolveInternal(normalized, diagnostics, 0);
+            if (!state) {
+                return finalizeResolution(undefined, diagnostics);
+            }
+            const token = new ResolvedTokenImpl({
+                pointer: normalized,
+                uri: this.graph.uri,
+                type: state.type,
+                value: state.value,
+                source: state.source,
+                overrides: state.overrides,
+                warnings: state.warnings,
+                trace: state.trace
+            });
+            const transforms = this.applyTransforms(token, diagnostics);
+            return finalizeResolution(token, diagnostics, transforms);
+        }
+        catch (error) {
+            diagnostics.add({
+                code: DiagnosticCodes.resolver.FAILED,
+                message: error instanceof Error ? error.message : 'Failed to resolve token.',
+                severity: 'error',
+                pointer
+            });
+            return finalizeResolution(undefined, diagnostics);
+        }
+    }
+    resolveInternal(pointer, diagnostics, depth) {
+        if (this.cache.has(pointer)) {
+            return this.cache.get(pointer);
+        }
+        if (this.pending.has(pointer)) {
+            diagnostics.add({
+                code: DiagnosticCodes.resolver.CYCLE_DETECTED,
+                message: `Circular reference detected while resolving "${pointer}".`,
+                severity: 'error',
+                pointer
+            });
+            return undefined;
+        }
+        if (depth > this.maxDepth) {
+            diagnostics.add({
+                code: DiagnosticCodes.resolver.MAX_DEPTH_EXCEEDED,
+                message: `Resolution depth exceeded maximum of ${this.maxDepth} while resolving "${pointer}".`,
+                severity: 'error',
+                pointer
+            });
+            return undefined;
+        }
+        const node = this.graph.nodes.get(pointer);
+        if (!node) {
+            diagnostics.add({
+                code: DiagnosticCodes.resolver.UNKNOWN_POINTER,
+                message: `No token exists at pointer "${pointer}".`,
+                severity: 'error',
+                pointer
+            });
+            return undefined;
+        }
+        if (node.kind === 'collection') {
+            diagnostics.add({
+                code: DiagnosticCodes.resolver.INVALID_NODE_KIND,
+                message: `Cannot resolve collection node at pointer "${pointer}".`,
+                severity: 'error',
+                pointer,
+                span: node.span
+            });
+            return undefined;
+        }
+        this.pending.add(pointer);
+        try {
+            const base = this.resolveBaseNode(node, diagnostics, depth);
+            if (!base) {
+                return undefined;
+            }
+            const withOverrides = this.applyOverrides(node.pointer, base, diagnostics, depth);
+            this.cache.set(pointer, withOverrides);
+            return withOverrides;
+        }
+        finally {
+            this.pending.delete(pointer);
+        }
+    }
+    resolveBaseNode(node, diagnostics, depth) {
+        switch (node.kind) {
+            case 'token':
+                return this.resolveTokenNode(node, diagnostics);
+            case 'alias':
+                return this.resolveAliasNode(node, diagnostics, depth);
+            default:
+                return undefined;
+        }
+    }
+    resolveTokenNode(node, diagnostics) {
+        const trace = Object.freeze([createTraceStep(node.pointer, 'token', node.span)]);
+        const valueField = node.value;
+        const warnings = [];
+        let source;
+        let value;
+        if (valueField) {
+            value = valueField.value;
+            source = createFieldSource(valueField, this.graph.uri);
+        }
+        else {
+            diagnostics.add({
+                code: DiagnosticCodes.resolver.MISSING_BASE_VALUE,
+                message: `Token "${node.pointer}" does not declare a $value.`,
+                severity: 'error',
+                pointer: node.pointer,
+                span: node.span
+            });
+            value = undefined;
+        }
+        return {
+            pointer: node.pointer,
+            type: node.type?.value,
+            value,
+            source,
+            overrides: EMPTY_OVERRIDES,
+            warnings: warnings.length === 0 ? EMPTY_WARNINGS : Object.freeze(warnings),
+            trace
+        };
+    }
+    resolveAliasNode(node, diagnostics, depth) {
+        const tracePrefix = createTraceStep(node.pointer, 'alias', node.span);
+        const target = node.ref.value;
+        if (target.external) {
+            diagnostics.add({
+                code: DiagnosticCodes.resolver.EXTERNAL_REFERENCE,
+                message: `Alias "${node.pointer}" references external pointer "${target.uri.href}${target.pointer}" which is not yet supported.`,
+                severity: 'error',
+                pointer: node.pointer,
+                span: node.ref.span
+            });
+            return {
+                pointer: node.pointer,
+                type: node.type.value,
+                value: undefined,
+                source: undefined,
+                overrides: EMPTY_OVERRIDES,
+                warnings: EMPTY_WARNINGS,
+                trace: Object.freeze([tracePrefix])
+            };
+        }
+        const targetState = this.resolveInternal(target.pointer, diagnostics, depth + 1);
+        if (!targetState) {
+            return {
+                pointer: node.pointer,
+                type: node.type.value,
+                value: undefined,
+                source: undefined,
+                overrides: EMPTY_OVERRIDES,
+                warnings: EMPTY_WARNINGS,
+                trace: Object.freeze([tracePrefix])
+            };
+        }
+        const type = node.type.value ?? targetState.type;
+        if (type && targetState.type && type !== targetState.type) {
+            diagnostics.add({
+                code: DiagnosticCodes.resolver.TARGET_TYPE_MISMATCH,
+                message: `Alias "${node.pointer}" expects type "${type}" but target "${target.pointer}" resolved to type "${targetState.type}".`,
+                severity: 'error',
+                pointer: node.ref.pointer,
+                span: node.ref.span,
+                related: [
+                    {
+                        message: 'Target token resolved here.',
+                        pointer: target.pointer,
+                        span: targetState.source?.span
+                    }
+                ]
+            });
+        }
+        const trace = Object.freeze([tracePrefix, ...targetState.trace]);
+        return {
+            pointer: node.pointer,
+            type,
+            value: targetState.value,
+            source: targetState.source,
+            overrides: targetState.overrides,
+            warnings: targetState.warnings,
+            trace
+        };
+    }
+    applyOverrides(pointer, base, diagnostics, depth) {
+        const overrides = this.overrides.get(pointer);
+        if (!overrides || overrides.length === 0) {
+            return base;
+        }
+        let matchedState;
+        for (const override of overrides) {
+            const evaluation = this.evaluateOverride(override, base, diagnostics, depth);
+            for (const diagnostic of evaluation.diagnostics) {
+                diagnostics.add(diagnostic);
+            }
+            if (evaluation.matched && evaluation.state) {
+                matchedState = evaluation.state;
+            }
+        }
+        if (!matchedState) {
+            return base;
+        }
+        const prefix = base.trace.length > 0 ? base.trace[0] : createTraceStep(pointer, 'token');
+        const trace = Object.freeze([prefix, ...matchedState.trace]);
+        const type = base.type ?? matchedState.type;
+        const warnings = mergeDiagnostics(base.warnings, matchedState.warnings);
+        return {
+            pointer: base.pointer,
+            type,
+            value: matchedState.value,
+            source: matchedState.source ?? base.source,
+            overrides: matchedState.overrides,
+            warnings,
+            trace
+        };
+    }
+    evaluateOverride(override, base, diagnostics, depth) {
+        if (!this.doesOverrideApply(override)) {
+            return { matched: false, diagnostics: EMPTY_DIAGNOSTICS };
+        }
+        if (override.token.value.external) {
+            return {
+                matched: true,
+                diagnostics: [
+                    {
+                        code: DiagnosticCodes.resolver.EXTERNAL_REFERENCE,
+                        message: `Override "$token" target "${override.token.value.uri.href}${override.token.value.pointer}" is external and not yet supported.`,
+                        severity: 'error',
+                        pointer: override.pointer,
+                        span: override.token.span
+                    }
+                ]
+            };
+        }
+        const traceSteps = [
+            createTraceStep(override.pointer, 'override', override.span)
+        ];
+        const diagnosticsList = [];
+        let state;
+        if (override.ref) {
+            state = this.resolveOverrideRef(override, base, diagnosticsList, traceSteps, depth);
+        }
+        if (!state && override.value) {
+            state = this.resolveOverrideValue(override, traceSteps);
+        }
+        if (!state && override.fallback) {
+            state = this.resolveFallbackChain(override.fallback, base, diagnosticsList, 1, traceSteps, depth + 1);
+        }
+        if (!state) {
+            diagnosticsList.push({
+                code: DiagnosticCodes.resolver.OVERRIDE_FAILED,
+                message: `Override "${override.pointer}" matched the current context but did not resolve to a value.`,
+                severity: 'error',
+                pointer: override.pointer,
+                span: override.span
+            });
+        }
+        return {
+            matched: true,
+            state,
+            diagnostics: diagnosticsList.length === 0 ? EMPTY_DIAGNOSTICS : Object.freeze(diagnosticsList)
+        };
+    }
+    doesOverrideApply(override) {
+        const conditions = override.when.value;
+        let recognized = false;
+        for (const [key, expected] of Object.entries(conditions)) {
+            if (!this.context.has(key)) {
+                return false;
+            }
+            recognized = true;
+            const actual = this.context.get(key);
+            if (!conditionMatches(expected, actual)) {
+                return false;
+            }
+        }
+        return recognized;
+    }
+    resolveOverrideRef(override, base, diagnostics, trace, depth) {
+        const ref = override.ref;
+        const target = ref.value;
+        if (target.external) {
+            diagnostics.push({
+                code: DiagnosticCodes.resolver.EXTERNAL_REFERENCE,
+                message: `Override "${override.pointer}" references external pointer "${target.uri.href}${target.pointer}" which is not yet supported.`,
+                severity: 'error',
+                pointer: ref.pointer,
+                span: ref.span
+            });
+            return undefined;
+        }
+        const targetDiagnostics = new DiagnosticBag();
+        const targetState = this.resolveInternal(target.pointer, targetDiagnostics, depth + 1);
+        const targetMessages = targetDiagnostics.toArray();
+        if (targetMessages.length > 0) {
+            diagnostics.push(...targetMessages);
+        }
+        if (!targetState) {
+            diagnostics.push({
+                code: DiagnosticCodes.resolver.OVERRIDE_FAILED,
+                message: `Override "${override.pointer}" could not resolve target "${target.pointer}".`,
+                severity: 'error',
+                pointer: ref.pointer,
+                span: ref.span
+            });
+            return undefined;
+        }
+        const type = base.type ?? targetState.type;
+        if (base.type && targetState.type && base.type !== targetState.type) {
+            diagnostics.push({
+                code: DiagnosticCodes.resolver.TARGET_TYPE_MISMATCH,
+                message: `Override "${override.pointer}" expects type "${base.type}" but target "${target.pointer}" resolved to type "${targetState.type}".`,
+                severity: 'error',
+                pointer: ref.pointer,
+                span: ref.span,
+                related: [
+                    {
+                        message: 'Target token resolved here.',
+                        pointer: target.pointer,
+                        span: targetState.source?.span
+                    }
+                ]
+            });
+        }
+        const source = targetState.source ?? createTargetSource(target, ref.span);
+        const overrides = Object.freeze([
+            ...targetState.overrides,
+            Object.freeze({
+                pointer: override.pointer,
+                span: override.span,
+                kind: 'override-ref',
+                depth: 0,
+                source
+            })
+        ]);
+        const warnings = mergeDiagnostics(targetState.warnings, []);
+        const traceSteps = Object.freeze([...trace, ...targetState.trace]);
+        return {
+            type,
+            value: targetState.value,
+            source,
+            overrides,
+            warnings,
+            trace: traceSteps
+        };
+    }
+    resolveOverrideValue(override, trace) {
+        const valueField = override.value;
+        const source = createFieldSource(valueField, this.graph.uri);
+        const overrides = Object.freeze([
+            Object.freeze({
+                pointer: override.pointer,
+                span: override.span,
+                kind: 'override-value',
+                depth: 0,
+                source
+            })
+        ]);
+        const traceSteps = Object.freeze([...trace]);
+        return {
+            value: valueField.value,
+            source,
+            overrides,
+            warnings: EMPTY_WARNINGS,
+            trace: traceSteps
+        };
+    }
+    resolveFallbackChain(chain, base, diagnostics, depth, trace, resolutionDepth) {
+        if (resolutionDepth > this.maxDepth) {
+            diagnostics.push({
+                code: DiagnosticCodes.resolver.MAX_DEPTH_EXCEEDED,
+                message: `Resolution depth exceeded maximum of ${this.maxDepth} while evaluating fallback chain for "${chain[0]?.pointer ?? base.pointer}".`,
+                severity: 'error',
+                pointer: chain[0]?.pointer ?? base.pointer
+            });
+            return undefined;
+        }
+        for (const entry of chain) {
+            const result = this.resolveFallbackEntry(entry, base, diagnostics, depth, trace, resolutionDepth);
+            if (result) {
+                return result;
+            }
+        }
+        diagnostics.push({
+            code: DiagnosticCodes.resolver.FALLBACK_EXHAUSTED,
+            message: 'Override fallback chain exhausted without producing a value.',
+            severity: 'error',
+            pointer: chain[0]?.pointer ?? JSON_POINTER_ROOT
+        });
+        return undefined;
+    }
+    resolveFallbackEntry(entry, base, diagnostics, depth, trace, resolutionDepth) {
+        if (resolutionDepth > this.maxDepth) {
+            diagnostics.push({
+                code: DiagnosticCodes.resolver.MAX_DEPTH_EXCEEDED,
+                message: `Resolution depth exceeded maximum of ${this.maxDepth} while evaluating fallback entry "${entry.pointer}".`,
+                severity: 'error',
+                pointer: entry.pointer,
+                span: entry.span
+            });
+            return undefined;
+        }
+        const fallbackTrace = [...trace, createTraceStep(entry.pointer, 'fallback', entry.span)];
+        if (entry.ref) {
+            const target = entry.ref.value;
+            if (target.external) {
+                diagnostics.push({
+                    code: DiagnosticCodes.resolver.EXTERNAL_REFERENCE,
+                    message: `Fallback entry "${entry.pointer}" references external pointer "${target.uri.href}${target.pointer}" which is not yet supported.`,
+                    severity: 'error',
+                    pointer: entry.ref.pointer,
+                    span: entry.ref.span
+                });
+            }
+            else {
+                const targetDiagnostics = new DiagnosticBag();
+                const targetState = this.resolveInternal(target.pointer, targetDiagnostics, resolutionDepth + 1);
+                const targetMessages = targetDiagnostics.toArray();
+                if (targetMessages.length > 0) {
+                    diagnostics.push(...targetMessages);
+                }
+                if (targetState) {
+                    const type = base.type ?? targetState.type;
+                    if (base.type && targetState.type && base.type !== targetState.type) {
+                        diagnostics.push({
+                            code: DiagnosticCodes.resolver.TARGET_TYPE_MISMATCH,
+                            message: `Fallback entry "${entry.pointer}" expects type "${base.type}" but target "${target.pointer}" resolved to type "${targetState.type}".`,
+                            severity: 'error',
+                            pointer: entry.ref.pointer,
+                            span: entry.ref.span,
+                            related: [
+                                {
+                                    message: 'Target token resolved here.',
+                                    pointer: target.pointer,
+                                    span: targetState.source?.span
+                                }
+                            ]
+                        });
+                    }
+                    const source = targetState.source ?? createTargetSource(target, entry.ref.span);
+                    const overrides = Object.freeze([
+                        ...targetState.overrides,
+                        Object.freeze({
+                            pointer: entry.pointer,
+                            span: entry.span,
+                            kind: 'fallback-ref',
+                            depth,
+                            source
+                        })
+                    ]);
+                    const warnings = mergeDiagnostics(targetState.warnings, []);
+                    const traceSteps = Object.freeze([...fallbackTrace, ...targetState.trace]);
+                    return {
+                        type,
+                        value: targetState.value,
+                        source,
+                        overrides,
+                        warnings,
+                        trace: traceSteps
+                    };
+                }
+            }
+        }
+        if (entry.value) {
+            const source = createFieldSource(entry.value, this.graph.uri);
+            const overrides = Object.freeze([
+                Object.freeze({
+                    pointer: entry.pointer,
+                    span: entry.span,
+                    kind: 'fallback-value',
+                    depth,
+                    source
+                })
+            ]);
+            const traceSteps = Object.freeze([...fallbackTrace]);
+            return {
+                value: entry.value.value,
+                source,
+                overrides,
+                warnings: EMPTY_WARNINGS,
+                trace: traceSteps
+            };
+        }
+        if (entry.fallback && entry.fallback.length > 0) {
+            return this.resolveFallbackChain(entry.fallback, base, diagnostics, depth + 1, fallbackTrace, resolutionDepth + 1);
+        }
+        return undefined;
+    }
+    applyTransforms(token, diagnostics) {
+        if (this.transforms.length === 0 || !this.document) {
+            return EMPTY_TRANSFORM_EVALUATIONS;
+        }
+        const evaluations = [];
+        for (const entry of this.transforms) {
+            try {
+                const result = entry.transform(token, { document: this.document });
+                const transformDiagnostics = freezeResultDiagnostics(result?.diagnostics);
+                if (transformDiagnostics.length > 0) {
+                    for (const diagnostic of transformDiagnostics) {
+                        diagnostics.add(diagnostic);
+                    }
+                }
+                evaluations.push(Object.freeze({
+                    plugin: entry.plugin,
+                    pointer: token.pointer,
+                    data: result?.data,
+                    diagnostics: transformDiagnostics
+                }));
+            }
+            catch (error) {
+                diagnostics.add(createTransformFailureDiagnostic(entry.plugin, token.pointer, error));
+            }
+        }
+        if (evaluations.length === 0) {
+            return EMPTY_TRANSFORM_EVALUATIONS;
+        }
+        return Object.freeze(evaluations);
+    }
+}
+export function createDocumentResolver(graph, options = {}) {
+    return new DocumentResolver(graph, options);
+}
+//# sourceMappingURL=document-resolver.js.map