semantifold 0.1.0

package/build/src/mapping.js

@@ -0,0 +1,1120 @@
+// @ts-check
+import { addSegment, GenMapping, maybeAddSegment, setSourceContent, toEncodedMap } from "@jridgewell/gen-mapping";
+import { eachMapping, originalPositionFor as traceOriginalPositionFor, sourceContentFor, TraceMap } from "@jridgewell/trace-mapping";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { createCoordinateIndex, indexedOffsetAt, indexedPointAt, locationFromOffsets } from "./semantic/location.js";
+import { primaryLocation } from "./semantic/provenance.js";
+/** @typedef {ReturnType<typeof buildMappingIndex>} MappingIndex */
+/** @type {WeakMap<import("./semantic/types.js").SemantifoldMapping, MappingIndex>} */
+const mappingIndexes = new WeakMap();
+/**
+ * Projects an authoritative Semantifold mapping to Source Map v3.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Rich mapping.
+ * @returns {import("@jridgewell/gen-mapping").EncodedSourceMap} Source Map v3.
+ */
+export function toSourceMapV3(mapping) {
+    const index = mappingIndex(mapping);
+    const generated = new GenMapping({ file: mapping.generated.filename });
+    for (const source of mapping.sources)
+        setSourceContent(generated, source.filename, source.content);
+    for (const span of mapping.spans) {
+        const location = primaryLocation(span.origin);
+        const line = span.generated.start.line - 1;
+        const column = span.generated.start.column - 1;
+        if (!location || span.mappingKind == "synthetic") {
+            maybeAddSegment(generated, line, column);
+            continue;
+        }
+        const registered = sourceForOrigin(mapping, span.origin, location, index.sourcesById);
+        if (span.name) {
+            addSegment(generated, line, column, registered.filename, location.start.line - 1, location.start.column - 1, span.name, registered.content);
+        }
+        else {
+            addSegment(generated, line, column, registered.filename, location.start.line - 1, location.start.column - 1, null, registered.content);
+        }
+    }
+    return toEncodedMap(generated);
+}
+/**
+ * Looks up original provenance for one generated UTF-16 position.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Rich mapping.
+ * @param {{offset: number} | {line: number, column: number}} position - Generated position.
+ * @returns {{generatedLocation: import("./semantic/types.js").SourceLocation, location: import("./semantic/types.js").SourceLocation | undefined, mappingKind: import("./semantic/types.js").MappingKind, name: string | undefined, nodeId: string | undefined, role: string | undefined, symbolId: string | undefined}} Lookup result.
+ */
+export function originalPositionFor(mapping, position) {
+    const index = mappingIndex(mapping);
+    const offset = positionOffset(index.generatedCoordinates, position);
+    const span = spanForGenerated(mapping.spans, offset);
+    if (!span)
+        throw new RangeError(`No generated mapping at offset ${offset}.`);
+    return mappingResult(span);
+}
+/**
+ * Looks up every generated span containing one original UTF-16 position.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Rich mapping.
+ * @param {({filename: string} | {sourceId: string}) & ({offset: number} | {line: number, column: number})} position - Original position.
+ * @returns {{generatedLocation: import("./semantic/types.js").SourceLocation, location: import("./semantic/types.js").SourceLocation | undefined, mappingKind: import("./semantic/types.js").MappingKind, name: string | undefined, nodeId: string | undefined, role: string | undefined, symbolId: string | undefined}[]} Generated results.
+ */
+export function generatedPositionFor(mapping, position) {
+    const index = mappingIndex(mapping);
+    const source = "sourceId" in position
+        ? index.sourcesById.get(position.sourceId)
+        : mapping.sources.find((candidate) => candidate.filename == position.filename);
+    if (!source)
+        return [];
+    if (source.content == null && !("offset" in position)) {
+        throw new TypeError(`Source content is required for line/column lookup of ${source.filename}.`);
+    }
+    let offset;
+    if ("offset" in position) {
+        if (source.content == null) {
+            if (!Number.isInteger(position.offset) || position.offset < 0)
+                throw new RangeError(`Invalid source offset: ${position.offset}`);
+        }
+        else
+            indexedPointAt(/** @type {ReturnType<typeof createCoordinateIndex>} */ (index.sourceCoordinates.get(source.id)), position.offset);
+        offset = position.offset;
+    }
+    else {
+        offset = indexedOffsetAt(/** @type {ReturnType<typeof createCoordinateIndex>} */ (index.sourceCoordinates.get(source.id)), position.line, position.column);
+    }
+    const entries = index.originalBySource.get(source.id) ?? [];
+    let low = 0;
+    let high = entries.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (entries[middle].start <= offset)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    /** @type {Set<import("./semantic/types.js").SemantifoldMappingSpan>} */
+    const matches = new Set();
+    for (const span of index.originalPointsBySource.get(source.id)?.get(offset) ?? [])
+        matches.add(span);
+    for (let candidate = low - 1; candidate >= 0 && entries[candidate].prefixEnd > offset; candidate--) {
+        if (entries[candidate].end > offset)
+            matches.add(entries[candidate].span);
+    }
+    return [...matches].sort((left, right) => left.generated.start.offset - right.generated.start.offset).map(mappingResult);
+}
+/**
+ * Returns every generated span associated with one canonical semantic node.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Rich mapping.
+ * @param {string} nodeId - Canonical node identity.
+ * @returns {import("./semantic/types.js").SemantifoldMappingSpan[]} Matching spans.
+ */
+export function spansForNode(mapping, nodeId) {
+    const index = mappingIndex(mapping);
+    if (!index.nodeSpans.has(nodeId))
+        throw new RangeError(`Unknown semantic node: ${nodeId}`);
+    return [...(index.nodeSpans.get(nodeId) ?? [])];
+}
+/**
+ * Returns every generated span associated with one canonical semantic symbol.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Rich mapping.
+ * @param {string} symbolId - Canonical symbol identity.
+ * @returns {import("./semantic/types.js").SemantifoldMappingSpan[]} Matching spans.
+ */
+export function spansForSymbol(mapping, symbolId) {
+    const index = mappingIndex(mapping);
+    if (!index.symbolSpans.has(symbolId))
+        throw new RangeError(`Unknown semantic symbol: ${symbolId}`);
+    return [...(index.symbolSpans.get(symbolId) ?? [])];
+}
+/**
+ * Serializes a validated rich mapping deterministically.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Rich mapping.
+ * @returns {string} Canonical pretty JSON with one trailing LF.
+ */
+export function stringifyMapping(mapping) {
+    mappingIndex(mapping);
+    return `${JSON.stringify(sortJson(mapping), null, 2)}\n`;
+}
+/**
+ * Parses and validates a rich mapping.
+ * @param {string} serialized - Mapping JSON.
+ * @returns {import("./semantic/types.js").SemantifoldMapping} Parsed mapping.
+ */
+export function parseMapping(serialized) {
+    const mapping = /** @type {unknown} */ (JSON.parse(serialized));
+    return finalizeMapping(mapping);
+}
+/**
+ * Composes an outer rich map through an inner rich map.
+ * @param {import("./semantic/types.js").SemantifoldMapping} outer - Final output to intermediate map.
+ * @param {import("./semantic/types.js").SemantifoldMapping} inner - Intermediate to original map.
+ * @returns {import("./semantic/types.js").SemantifoldMapping} Composed rich map.
+ */
+export function composeMappings(outer, inner) {
+    const outerIndex = mappingIndex(outer);
+    mappingIndex(inner);
+    /** @type {import("./semantic/types.js").RegisteredSource[]} */
+    const sources = inner.sources.map((source) => ({ ...source }));
+    const sourceIds = new Set(sources.map((source) => source.id));
+    /** @type {Map<string, string>} */
+    const outerSourceIds = new Map();
+    let nextSourceIndex = 0;
+    for (const source of outer.sources) {
+        if (sourceRepresentsGenerated(source, inner.generated))
+            continue;
+        retainOuterSource(source.id);
+    }
+    const spans = outer.spans.flatMap((span) => {
+        /** @type {ReturnType<typeof traceRelatedOrigin> | undefined} */
+        let trace;
+        for (const related of relatedOriginsForOrigin(span.origin)) {
+            trace = traceRelatedOrigin(related);
+            if (trace?.traced)
+                break;
+        }
+        const location = trace?.related.location;
+        const overlapping = trace?.overlapping ?? [];
+        const traced = trace?.traced;
+        if (!traced) {
+            for (const related of relatedOriginsForOrigin(span.origin)) {
+                const relatedTrace = traceRelatedOrigin(related);
+                if (relatedTrace && isGeneratedEofPoint(related))
+                    retainOuterSource(related.sourceId);
+            }
+            const unidentified = { ...span };
+            delete unidentified.nodeId;
+            delete unidentified.symbolId;
+            return [{ ...unidentified, origin: remapOriginSourceIds(span.origin, outerSourceIds) }];
+        }
+        const selectedRelated = trace?.related;
+        if (!selectedRelated)
+            throw new RangeError("Intermediate trace selection is missing its related origin.");
+        if (location && overlapping.length > 1 && span.mappingKind == "exact" &&
+            span.generated.end.offset - span.generated.start.offset == location.end.offset - location.start.offset) {
+            return overlapping.map((candidate) => {
+                const overlapStart = Math.max(location.start.offset, candidate.generated.start.offset);
+                const overlapEnd = Math.min(location.end.offset, candidate.generated.end.offset);
+                const generatedStart = span.generated.start.offset + overlapStart - location.start.offset;
+                const generatedEnd = span.generated.start.offset + overlapEnd - location.start.offset;
+                const preservesWholeOrigin = overlapStart == candidate.generated.start.offset && overlapEnd == candidate.generated.end.offset;
+                return composedSpan(span, candidate, locationFromOffsets(outer.generated.filename, outer.generated.content, generatedStart, generatedEnd), preservesWholeOrigin, selectedRelated, true);
+            });
+        }
+        const preservesWholeOrigin = Boolean(location && location.start.offset == traced.generated.start.offset &&
+            location.end.offset == traced.generated.end.offset);
+        const composed = composedSpan(span, traced, span.generated, preservesWholeOrigin, selectedRelated);
+        if (span.origin.kind == "source" && overlapping.length > 1) {
+            const origins = composeRelatedOrigins([selectedRelated], selectedRelated, traced, false);
+            if (origins.length > 0) {
+                return [{ ...composed, mappingKind: /** @type {const} */ ("anchor"), origin: {
+                            kind: /** @type {const} */ ("derived"),
+                            origins
+                        } }];
+            }
+        }
+        return [composed];
+    });
+    return finalizeMapping({
+        coordinateSystem: "utf16",
+        generated: outer.generated,
+        nodes: inner.nodes,
+        schema: "SemantifoldMapping",
+        sources,
+        spans,
+        symbols: inner.symbols,
+        version: 1
+    });
+    /**
+     * Composes one outer generated range with an inner range.
+     * @param {import("./semantic/types.js").SemantifoldMappingSpan} outerSpan - Outer span.
+     * @param {import("./semantic/types.js").SemantifoldMappingSpan} innerSpan - Inner span.
+     * @param {import("./semantic/types.js").SourceLocation} generated - Final generated subrange.
+     * @param {boolean} preservesWholeOrigin - Whether adopting the inner origin retains its complete range.
+     * @param {import("./semantic/types.js").RelatedOrigin} selectedRelated - Outer origin traced through this inner span.
+     * @param {boolean} [restrictSelectedTrace] - Whether an exact split selects only this inner span.
+     * @returns {import("./semantic/types.js").SemantifoldMappingSpan} Composed span.
+     */
+    function composedSpan(outerSpan, innerSpan, generated, preservesWholeOrigin, selectedRelated, restrictSelectedTrace = false) {
+        if (outerSpan.mappingKind == "synthetic" && outerSpan.origin.kind == "synthetic") {
+            return definedProperties({
+                generated,
+                mappingKind: /** @type {const} */ ("synthetic"),
+                name: outerSpan.name,
+                origin: {
+                    kind: /** @type {const} */ ("synthetic"),
+                    reason: outerSpan.origin.reason,
+                    relatedOrigins: composeRelatedOrigins(outerSpan.origin.relatedOrigins, selectedRelated, innerSpan, restrictSelectedTrace)
+                },
+                role: outerSpan.role
+            });
+        }
+        const composedDerivedOrigins = outerSpan.origin.kind == "derived"
+            ? composeRelatedOrigins(outerSpan.origin.origins, selectedRelated, innerSpan, restrictSelectedTrace)
+            : undefined;
+        const origin = outerSpan.origin.kind == "source" ? innerSpan.origin : outerSpan.origin.kind == "derived"
+            ? composedDerivedOrigins?.length == 0 && innerSpan.origin.kind == "synthetic"
+                ? innerSpan.origin
+                : { kind: /** @type {const} */ ("derived"), origins: /** @type {import("./semantic/types.js").RelatedOrigin[]} */ (composedDerivedOrigins) }
+            : {
+                kind: /** @type {const} */ ("synthetic"),
+                reason: outerSpan.origin.reason,
+                relatedOrigins: composeRelatedOrigins(outerSpan.origin.relatedOrigins, selectedRelated, innerSpan, restrictSelectedTrace)
+            };
+        return definedProperties({
+            ...outerSpan,
+            generated,
+            mappingKind: innerSpan.mappingKind == "synthetic" ? /** @type {const} */ ("synthetic") :
+                outerSpan.mappingKind == "exact" && innerSpan.mappingKind == "exact" && preservesWholeOrigin
+                    ? /** @type {const} */ ("exact")
+                    : /** @type {const} */ ("anchor"),
+            name: outerSpan.name ?? innerSpan.name,
+            nodeId: innerSpan.nodeId,
+            origin,
+            role: innerSpan.role ?? outerSpan.role,
+            symbolId: innerSpan.symbolId
+        });
+    }
+    /**
+     * Finds the inner span selected by one related intermediate origin.
+     * @param {import("./semantic/types.js").RelatedOrigin} related - Outer related origin.
+     * @returns {{
+     *   overlapping: import("./semantic/types.js").SemantifoldMappingSpan[],
+     *   related: import("./semantic/types.js").RelatedOrigin,
+     *   traced: import("./semantic/types.js").SemantifoldMappingSpan | undefined
+     * } | undefined} Trace selection when the related source is the intermediate artifact.
+     */
+    function traceRelatedOrigin(related) {
+        const source = outerIndex.sourcesById.get(related.sourceId);
+        if (!source || !sourceRepresentsGenerated(source, inner.generated))
+            return undefined;
+        const overlapping = spansOverlappingGenerated(inner.spans, related.location.start.offset, related.location.end.offset);
+        return {
+            overlapping,
+            related,
+            traced: overlapping[0] ?? spanForGenerated(inner.spans, related.location.start.offset)
+        };
+    }
+    /**
+     * Traces intermediate related origins and remaps unrelated source identities in order.
+     * @param {import("./semantic/types.js").RelatedOrigin[]} relatedOrigins - Outer related origins.
+     * @param {import("./semantic/types.js").RelatedOrigin} selectedRelated - Origin using the selected inner span.
+     * @param {import("./semantic/types.js").SemantifoldMappingSpan} selectedSpan - Selected inner span.
+     * @param {boolean} restrictSelectedTrace - Whether an exact split selects only the supplied span.
+     * @returns {import("./semantic/types.js").RelatedOrigin[]} Composed related origins.
+     */
+    function composeRelatedOrigins(relatedOrigins, selectedRelated, selectedSpan, restrictSelectedTrace) {
+        return relatedOrigins.flatMap((related) => {
+            const source = outerIndex.sourcesById.get(related.sourceId);
+            if (!source || !sourceRepresentsGenerated(source, inner.generated)) {
+                return [remapRelatedOriginSourceId(related, outerSourceIds)];
+            }
+            const trace = traceRelatedOrigin(related);
+            const tracedSpans = restrictSelectedTrace && related === selectedRelated
+                ? [selectedSpan]
+                : trace?.overlapping.length
+                    ? trace.overlapping
+                    : trace?.traced ? [trace.traced] : [];
+            if (tracedSpans.length == 0) {
+                if (!isGeneratedEofPoint(related))
+                    throw new RangeError(`Unable to trace intermediate origin '${related.location.filename}'.`);
+                retainOuterSource(related.sourceId);
+                return [remapRelatedOriginSourceId(related, outerSourceIds)];
+            }
+            return tracedSpans.flatMap((tracedSpan) => relatedOriginsForSpan(tracedSpan).map((tracedRelated) => definedProperties({
+                ...tracedRelated,
+                nodeId: tracedRelated.nodeId ?? tracedSpan.nodeId,
+                role: related.role ?? tracedRelated.role,
+                symbolId: tracedRelated.symbolId ?? tracedSpan.symbolId
+            })));
+        });
+    }
+    /**
+     * Retains one outer source that survives composition and assigns its composed identity.
+     * @param {string} sourceId - Outer source registry identity.
+     * @returns {void}
+     */
+    function retainOuterSource(sourceId) {
+        if (outerSourceIds.has(sourceId))
+            return;
+        const source = outerIndex.sourcesById.get(sourceId);
+        if (!source)
+            throw new RangeError(`Unknown outer mapping source '${sourceId}'.`);
+        let composedSource = sources.find((candidate) => sameRegisteredSource(candidate, source));
+        if (!composedSource) {
+            while (sourceIds.has(`source:${nextSourceIndex}`))
+                nextSourceIndex++;
+            composedSource = { ...source, id: `source:${nextSourceIndex}` };
+            sourceIds.add(composedSource.id);
+            sources.push(composedSource);
+        }
+        outerSourceIds.set(source.id, composedSource.id);
+    }
+    /**
+     * Tests whether one intermediate origin is the exact point after all generated code units.
+     * @param {import("./semantic/types.js").RelatedOrigin} related - Candidate intermediate origin.
+     * @returns {boolean} Whether this is an EOF point rather than a generated half-open range.
+     */
+    function isGeneratedEofPoint(related) {
+        return related.location.start.offset == inner.generated.content.length &&
+            related.location.end.offset == inner.generated.content.length;
+    }
+}
+/**
+ * Converts one mapped span's closed origin into related provenance.
+ * @param {import("./semantic/types.js").SemantifoldMappingSpan} span - Traced inner span.
+ * @returns {import("./semantic/types.js").RelatedOrigin[]} Related original ranges.
+ */
+function relatedOriginsForSpan(span) {
+    return relatedOriginsForOrigin(span.origin);
+}
+/**
+ * Returns every related range in one closed origin.
+ * @param {import("./semantic/types.js").SemanticOrigin} origin - Closed origin.
+ * @returns {import("./semantic/types.js").RelatedOrigin[]} Related ranges in semantic order.
+ */
+function relatedOriginsForOrigin(origin) {
+    if (origin.kind == "source")
+        return [{ location: origin.location, sourceId: origin.sourceId }];
+    if (origin.kind == "derived")
+        return origin.origins;
+    return origin.relatedOrigins;
+}
+/**
+ * Determines whether a registered source is the generated artifact consumed by an inner map.
+ * @param {import("./semantic/types.js").RegisteredSource} source - Outer source registry entry.
+ * @param {import("./semantic/types.js").GeneratedSource} generated - Inner generated artifact.
+ * @returns {boolean} Whether identity-selected provenance may be traced through the inner map.
+ */
+function sourceRepresentsGenerated(source, generated) {
+    return source.filename == generated.filename && source.content == generated.content &&
+        (source.language == null || source.language == generated.language);
+}
+/**
+ * Compares complete registered-source identity fields other than registry-local ID.
+ * @param {import("./semantic/types.js").RegisteredSource} left - First registered source.
+ * @param {import("./semantic/types.js").RegisteredSource} right - Second registered source.
+ * @returns {boolean} Whether both entries represent the same source artifact.
+ */
+function sameRegisteredSource(left, right) {
+    return left.filename == right.filename && left.content == right.content && left.language == right.language;
+}
+/**
+ * Composes Source Map v3 maps with maintained tracing machinery.
+ * @param {import("@jridgewell/trace-mapping").SourceMapInput} outer - Final output to intermediate map.
+ * @param {import("@jridgewell/trace-mapping").SourceMapInput} inner - Intermediate to original map.
+ * @returns {import("@jridgewell/gen-mapping").EncodedSourceMap} Composed v3 map.
+ */
+export function composeSourceMaps(outer, inner) {
+    const outerMap = new TraceMap(outer);
+    const innerMap = new TraceMap(inner);
+    const composed = new GenMapping({ file: outerMap.file });
+    const intermediateIndexes = typeof innerMap.file == "string"
+        ? outerMap.resolvedSources.flatMap((source, index) => source == innerMap.file ? [index] : [])
+        : [];
+    const intermediateIndex = intermediateIndexes.length == 1 ? intermediateIndexes[0] : undefined;
+    const intermediateSource = intermediateIndex === undefined ? undefined : outerMap.resolvedSources[intermediateIndex];
+    innerMap.sources.forEach((rawSource, index) => {
+        const source = innerMap.resolvedSources[index] ?? rawSource;
+        if (source != null)
+            setSourceContent(composed, source, innerMap.sourcesContent?.[index] ?? null);
+    });
+    outerMap.sources.forEach((rawSource, index) => {
+        const source = outerMap.resolvedSources[index] ?? rawSource;
+        if (source != null && index != intermediateIndex) {
+            setSourceContent(composed, source, outerMap.sourcesContent?.[index] ?? null);
+        }
+    });
+    eachMapping(outerMap, (mapping) => {
+        if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) {
+            maybeAddSegment(composed, mapping.generatedLine - 1, mapping.generatedColumn);
+            return;
+        }
+        const isIntermediate = intermediateSource !== undefined && mapping.source == intermediateSource;
+        const traced = isIntermediate
+            ? traceOriginalPositionFor(innerMap, { column: mapping.originalColumn, line: mapping.originalLine })
+            : { column: mapping.originalColumn, line: mapping.originalLine, name: mapping.name, source: mapping.source };
+        if (traced.source == null || traced.line == null || traced.column == null) {
+            maybeAddSegment(composed, mapping.generatedLine - 1, mapping.generatedColumn);
+            return;
+        }
+        const content = isIntermediate ? sourceContentFor(innerMap, traced.source) : sourceContentFor(outerMap, traced.source);
+        const name = traced.name ?? mapping.name;
+        if (name == null) {
+            addSegment(composed, mapping.generatedLine - 1, mapping.generatedColumn, traced.source, traced.line - 1, traced.column, null, content);
+        }
+        else {
+            addSegment(composed, mapping.generatedLine - 1, mapping.generatedColumn, traced.source, traced.line - 1, traced.column, name, content);
+        }
+    });
+    return toEncodedMap(composed);
+}
+/**
+ * Imports a point-based Source Map v3 as a range-based Semantifold map.
+ * @param {import("@jridgewell/trace-mapping").SourceMapInput} sourceMap - Source Map v3.
+ * @param {object} generated - Generated program.
+ * @param {string} generated.content - Exact generated content.
+ * @param {string} generated.filename - Generated filename.
+ * @param {import("./semantic/types.js").SemanticLanguage} generated.language - Generated language.
+ * @param {{filename: string, content: string, language?: import("./semantic/types.js").SemanticLanguage}[]} [generated.sources] - Exact source content overrides.
+ * @returns {import("./semantic/types.js").SemantifoldMapping} Imported rich map.
+ */
+export function mappingFromSourceMap(sourceMap, { content, filename, language, sources: provided = [] }) {
+    const trace = new TraceMap(sourceMap);
+    const generatedCoordinates = createCoordinateIndex(content);
+    /** @type {import("./semantic/types.js").RegisteredSource[]} */
+    const sources = [];
+    /** @type {Map<number, {filename: string, content: string, language?: import("./semantic/types.js").SemanticLanguage}>} */
+    const overridesBySourceIndex = new Map();
+    for (const override of provided) {
+        const exact = trace.sources.flatMap((source, index) => {
+            const resolved = trace.resolvedSources[index];
+            return source == override.filename || resolved == override.filename ? [index] : [];
+        });
+        if (exact.length > 0) {
+            for (const index of exact)
+                overridesBySourceIndex.set(index, override);
+            continue;
+        }
+        const suffix = trace.sources.flatMap((source, index) => {
+            const resolved = trace.resolvedSources[index];
+            return source?.endsWith(`/${override.filename}`) || resolved?.endsWith(`/${override.filename}`) ? [index] : [];
+        });
+        if (suffix.length > 1) {
+            throw new RangeError(`Ambiguous Source Map source content override '${override.filename}' matches multiple sources.`);
+        }
+        if (suffix.length == 1 && !overridesBySourceIndex.has(suffix[0]))
+            overridesBySourceIndex.set(suffix[0], override);
+    }
+    /** @type {Map<string, import("./semantic/types.js").RegisteredSource>} */
+    const sourcesByMapName = new Map();
+    trace.sources.forEach((source, index) => {
+        if (source == null)
+            return;
+        const resolvedSource = trace.resolvedSources[index] ?? source;
+        const providedSource = overridesBySourceIndex.get(index);
+        const registered = {
+            content: providedSource?.content ?? trace.sourcesContent?.[index] ?? null,
+            filename: providedSource?.filename ?? resolvedSource,
+            id: `source:${sources.length}`,
+            language: providedSource?.language ?? null
+        };
+        sources.push(registered);
+        if (!sourcesByMapName.has(resolvedSource))
+            sourcesByMapName.set(resolvedSource, registered);
+    });
+    const sourceCoordinates = new Map(sources.filter((source) => source.content != null)
+        .map((source) => [source.id, createCoordinateIndex(/** @type {string} */ (source.content))]));
+    /** @type {{generatedOffset: number, mapping: import("@jridgewell/trace-mapping").EachMapping}[]} */
+    const points = [];
+    eachMapping(trace, (mapping) => {
+        points.push({ generatedOffset: indexedOffsetAt(generatedCoordinates, mapping.generatedLine, mapping.generatedColumn + 1), mapping });
+    });
+    /** @type {import("./semantic/types.js").SemantifoldMappingSpan[]} */
+    const mappedSpans = [];
+    points.forEach(({ generatedOffset, mapping }, index) => {
+        const next = points[index + 1];
+        const end = next?.mapping.generatedLine == mapping.generatedLine
+            ? next.generatedOffset
+            : lineEndOffset(content, generatedOffset);
+        if (end <= generatedOffset)
+            return;
+        if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) {
+            mappedSpans.push({
+                generated: locationFromOffsets(filename, content, generatedOffset, end),
+                mappingKind: "synthetic",
+                origin: { kind: "synthetic", reason: "unmapped Source Map segment", relatedOrigins: [] }
+            });
+            return;
+        }
+        const source = sourcesByMapName.get(mapping.source);
+        if (!source)
+            throw new RangeError(`Source Map references unregistered source '${mapping.source}'.`);
+        if (source.content == null) {
+            throw new RangeError(`Source content is required to import mapped positions for '${source.filename}'.`);
+        }
+        const originalOffset = indexedOffsetAt(
+        /** @type {ReturnType<typeof createCoordinateIndex>} */ (sourceCoordinates.get(source.id)), mapping.originalLine, mapping.originalColumn + 1);
+        const originalEnd = Math.min(source.content.length, originalOffset + 1);
+        const originalLocation = locationFromOffsets(source.filename, source.content, originalOffset, originalEnd);
+        mappedSpans.push(definedProperties({
+            generated: locationFromOffsets(filename, content, generatedOffset, end),
+            mappingKind: "anchor",
+            name: mapping.name ?? undefined,
+            origin: { kind: "source", location: originalLocation, sourceId: source.id }
+        }));
+    });
+    /** @type {import("./semantic/types.js").SemantifoldMappingSpan[]} */
+    const spans = [];
+    let cursor = 0;
+    for (const span of mappedSpans) {
+        if (span.generated.start.offset > cursor)
+            spans.push(unmappedSpan(cursor, span.generated.start.offset));
+        if (span.generated.end.offset > cursor) {
+            spans.push(span.generated.start.offset < cursor ? {
+                ...span,
+                generated: locationFromOffsets(filename, content, cursor, span.generated.end.offset)
+            } : span);
+            cursor = span.generated.end.offset;
+        }
+    }
+    if (cursor < content.length)
+        spans.push(unmappedSpan(cursor, content.length));
+    return finalizeMapping({
+        coordinateSystem: "utf16",
+        generated: { content, filename, language },
+        nodes: [],
+        schema: "SemantifoldMapping",
+        sources,
+        spans,
+        symbols: [],
+        version: 1
+    });
+    /**
+     * Creates one explicit unmapped range.
+     * @param {number} start - Generated start offset.
+     * @param {number} end - Generated end offset.
+     * @returns {import("./semantic/types.js").SemantifoldMappingSpan} Synthetic span.
+     */
+    function unmappedSpan(start, end) {
+        return {
+            generated: locationFromOffsets(filename, content, start, end),
+            mappingKind: "synthetic",
+            origin: { kind: "synthetic", reason: "unmapped Source Map range", relatedOrigins: [] }
+        };
+    }
+}
+/**
+ * Remaps a generated location while retaining the generated range in the result.
+ * @param {import("./semantic/types.js").SourceLocation} location - Generated location.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Rich mapping.
+ * @returns {ReturnType<typeof originalPositionFor>} Remapped lookup.
+ */
+export function remapLocation(location, mapping) {
+    if (location.filename != mapping.generated.filename)
+        throw new RangeError(`Location is not in ${mapping.generated.filename}.`);
+    return originalPositionFor(mapping, { offset: location.start.offset });
+}
+/**
+ * Remaps a Semantifold diagnostic and preserves its generated location and cause.
+ * @param {SemantifoldDiagnostic} diagnostic - Generated-program diagnostic.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Rich mapping.
+ * @returns {SemantifoldDiagnostic} Remapped diagnostic.
+ */
+export function remapDiagnostic(diagnostic, mapping) {
+    if (!diagnostic.location)
+        return diagnostic;
+    const remapped = remapLocation(diagnostic.location, mapping);
+    if (!remapped.location)
+        return diagnostic;
+    return new SemantifoldDiagnostic({
+        cause: diagnostic,
+        code: diagnostic.code,
+        generatedLocation: diagnostic.location,
+        language: diagnostic.language,
+        location: remapped.location,
+        message: diagnostic.detail
+    });
+}
+/**
+ * Validates the public mapping envelope and ordered half-open generated ranges.
+ * @param {unknown} value - Candidate mapping.
+ * @returns {asserts value is import("./semantic/types.js").SemantifoldMapping} Nothing when valid.
+ */
+export function validateMapping(value) {
+    if (!value || typeof value != "object" || Reflect.get(value, "schema") != "SemantifoldMapping" ||
+        Reflect.get(value, "version") != 1 || Reflect.get(value, "coordinateSystem") != "utf16") {
+        throw new TypeError("Expected a SemantifoldMapping v1 value.");
+    }
+    const mapping = /** @type {Record<string, unknown>} */ (value);
+    const generated = /** @type {Record<string, unknown>} */ (mapping.generated);
+    const spans = mapping.spans;
+    if (!generated || typeof generated != "object" || typeof Reflect.get(generated, "filename") != "string" ||
+        typeof Reflect.get(generated, "content") != "string" || !isLanguage(Reflect.get(generated, "language")) ||
+        !Array.isArray(mapping.sources) ||
+        !Array.isArray(mapping.nodes) || !Array.isArray(mapping.symbols) || !Array.isArray(spans)) {
+        throw new TypeError("Malformed SemantifoldMapping v1 envelope.");
+    }
+    const content = /** @type {string} */ (generated.content);
+    const filename = /** @type {string} */ (generated.filename);
+    if (content.includes("\r"))
+        throw new TypeError("SemantifoldMapping generated content must use LF line endings.");
+    const sourceIds = new Set();
+    for (const source of mapping.sources) {
+        if (!source || typeof source != "object" || typeof source.id != "string" || source.id.length == 0 || sourceIds.has(source.id) ||
+            typeof source.filename != "string" || source.filename.length == 0 || source.content !== null && typeof source.content != "string" ||
+            source.language !== null && !isLanguage(source.language)) {
+            throw new TypeError("Malformed or duplicate SemantifoldMapping source.");
+        }
+        sourceIds.add(source.id);
+    }
+    const sourceCoordinates = new Map(mapping.sources.filter((source) => source.content != null)
+        .map((source) => [source.id, createCoordinateIndex(/** @type {string} */ (source.content))]));
+    const sourcesById = new Map(mapping.sources.map((source) => [source.id, source]));
+    /** @type {Map<string, import("./semantic/types.js").RegisteredSource[]>} */
+    const sourcesByFilename = new Map();
+    for (const source of mapping.sources) {
+        const sameName = sourcesByFilename.get(source.filename) ?? [];
+        sameName.push(source);
+        sourcesByFilename.set(source.filename, sameName);
+    }
+    const generatedCoordinates = createCoordinateIndex(content);
+    const nodeIds = new Set();
+    const nodePaths = new Set();
+    for (const node of mapping.nodes) {
+        if (!node || typeof node != "object" || typeof node.id != "string" || node.id.length == 0 || nodeIds.has(node.id) ||
+            typeof node.path != "string" || nodePaths.has(node.path) ||
+            typeof node.kind != "string" || node.kind.length == 0 || !node.origin || typeof node.ranges != "object" ||
+            node.ranges === null || Array.isArray(node.ranges))
+            throw new TypeError("Malformed or duplicate semantic node identity.");
+        nodeIds.add(node.id);
+        nodePaths.add(node.path);
+    }
+    const symbolIds = new Set();
+    for (const symbol of mapping.symbols) {
+        if (!symbol || typeof symbol != "object" || typeof symbol.id != "string" || symbol.id.length == 0 || symbolIds.has(symbol.id) ||
+            typeof symbol.name != "string" || symbol.name.length == 0 || !["function", "parameter", "local"].includes(symbol.kind) ||
+            !nodeIds.has(symbol.declarationNodeId) || !Array.isArray(symbol.references)) {
+            throw new TypeError("Malformed or duplicate semantic symbol identity.");
+        }
+        symbolIds.add(symbol.id);
+    }
+    for (const node of mapping.nodes) {
+        validateOrigin(node.origin, sourcesById, sourceCoordinates, nodeIds, symbolIds);
+        for (const [role, location] of Object.entries(node.ranges)) {
+            if (role.length == 0)
+                throw new TypeError("Semantic node range roles must be non-empty strings.");
+            validateLocationForSources(location, sourcesByFilename, sourceCoordinates);
+        }
+        if (node.symbolId !== undefined && (typeof node.symbolId != "string" || !symbolIds.has(node.symbolId))) {
+            throw new TypeError("Semantic node references an unknown symbol.");
+        }
+    }
+    for (const symbol of mapping.symbols) {
+        validateLocationForSources(symbol.location, sourcesByFilename, sourceCoordinates);
+        for (const reference of symbol.references) {
+            if (!reference || typeof reference != "object" || !nodeIds.has(reference.nodeId) ||
+                !["declaration", "read", "write", "call"].includes(reference.role)) {
+                throw new TypeError("Malformed semantic symbol reference.");
+            }
+            validateLocationForSources(reference.location, sourcesByFilename, sourceCoordinates);
+        }
+    }
+    let previousEnd = 0;
+    for (const span of spans) {
+        if (!span || typeof span != "object" || !["exact", "anchor", "synthetic"].includes(Reflect.get(span, "mappingKind")) ||
+            !Reflect.get(span, "generated") || !Reflect.get(span, "origin")) {
+            throw new TypeError("Malformed SemantifoldMapping span.");
+        }
+        const location = /** @type {import("./semantic/types.js").SourceLocation} */ (Reflect.get(span, "generated"));
+        if (!location.start || !location.end || location.filename != filename || location.start.offset != previousEnd ||
+            location.end.offset <= location.start.offset || location.end.offset > content.length ||
+            !samePoint(indexedPointAt(generatedCoordinates, location.start.offset), location.start) ||
+            !samePoint(indexedPointAt(generatedCoordinates, location.end.offset), location.end)) {
+            throw new TypeError("SemantifoldMapping spans must exactly cover ordered normalized generated ranges.");
+        }
+        validateOrigin(
+        /** @type {import("./semantic/types.js").SemanticOrigin} */ (Reflect.get(span, "origin")), sourcesById, sourceCoordinates, nodeIds, symbolIds);
+        const nodeId = Reflect.get(span, "nodeId");
+        const symbolId = Reflect.get(span, "symbolId");
+        if (nodeId !== undefined && (typeof nodeId != "string" || !nodeIds.has(nodeId)))
+            throw new TypeError("Mapping span references an unknown node.");
+        if (symbolId !== undefined && (typeof symbolId != "string" || !symbolIds.has(symbolId)))
+            throw new TypeError("Mapping span references an unknown symbol.");
+        if (Reflect.get(span, "role") !== undefined && typeof Reflect.get(span, "role") != "string" ||
+            Reflect.get(span, "name") !== undefined && typeof Reflect.get(span, "name") != "string") {
+            throw new TypeError("Mapping span roles and names must be strings.");
+        }
+        previousEnd = location.end.offset;
+    }
+    if (previousEnd != content.length)
+        throw new TypeError("SemantifoldMapping spans must cover all generated content.");
+}
+/**
+ * Validates, freezes, and indexes one mapping produced at a trust boundary.
+ * @param {unknown} value - Candidate mapping.
+ * @returns {import("./semantic/types.js").SemantifoldMapping} Immutable indexed mapping.
+ */
+export function finalizeMapping(value) {
+    // Producers may retain references to mutable semantic locations; mappings own their immutable copy.
+    const mapping = structuredClone(value);
+    validateMapping(mapping);
+    freezeJson(mapping);
+    mappingIndexes.set(mapping, buildMappingIndex(mapping));
+    return mapping;
+}
+/**
+ * Gets an index, validating mutable caller mappings on every trust-boundary use.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Mapping.
+ * @returns {MappingIndex} Lookup index.
+ */
+function mappingIndex(mapping) {
+    const cached = mappingIndexes.get(mapping);
+    if (cached)
+        return cached;
+    validateMapping(mapping);
+    return buildMappingIndex(mapping);
+}
+/**
+ * Builds generated, original, node, and symbol indexes in one pass.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Validated mapping.
+ * @returns {{generatedCoordinates: ReturnType<typeof createCoordinateIndex>, nodeSpans: Map<string, import("./semantic/types.js").SemantifoldMappingSpan[]>, originalBySource: Map<string, {end: number, prefixEnd: number, span: import("./semantic/types.js").SemantifoldMappingSpan, start: number}[]>, originalPointsBySource: Map<string, Map<number, import("./semantic/types.js").SemantifoldMappingSpan[]>>, sourceCoordinates: Map<string, ReturnType<typeof createCoordinateIndex>>, sourcesById: Map<string, import("./semantic/types.js").RegisteredSource>, symbolSpans: Map<string, import("./semantic/types.js").SemantifoldMappingSpan[]>}} Mapping index.
+ */
+function buildMappingIndex(mapping) {
+    const generatedCoordinates = createCoordinateIndex(mapping.generated.content);
+    const sourcesById = new Map(mapping.sources.map((source) => [source.id, source]));
+    const sourceCoordinates = new Map(mapping.sources.filter((source) => source.content != null)
+        .map((source) => [source.id, createCoordinateIndex(/** @type {string} */ (source.content))]));
+    const nodeSpans = new Map(mapping.nodes.map((node) => [node.id, /** @type {import("./semantic/types.js").SemantifoldMappingSpan[]} */ ([])]));
+    const symbolSpans = new Map(mapping.symbols.map((symbol) => [symbol.id, /** @type {import("./semantic/types.js").SemantifoldMappingSpan[]} */ ([])]));
+    /** @type {Map<string, {end: number, prefixEnd: number, span: import("./semantic/types.js").SemantifoldMappingSpan, start: number}[]>} */
+    const originalBySource = new Map(mapping.sources.map((source) => [source.id, []]));
+    /** @type {Map<string, Map<number, import("./semantic/types.js").SemantifoldMappingSpan[]>>} */
+    const originalPointsBySource = new Map(mapping.sources.map((source) => [source.id, new Map()]));
+    for (const span of mapping.spans) {
+        const spanNodeIds = new Set(span.nodeId ? [span.nodeId] : []);
+        const spanSymbolIds = new Set(span.symbolId ? [span.symbolId] : []);
+        for (const related of relatedOriginsForOrigin(span.origin)) {
+            if (related.nodeId)
+                spanNodeIds.add(related.nodeId);
+            if (related.symbolId)
+                spanSymbolIds.add(related.symbolId);
+            if (related.location.end.offset == related.location.start.offset) {
+                const points = originalPointsBySource.get(related.sourceId);
+                const pointSpans = points?.get(related.location.start.offset) ?? [];
+                pointSpans.push(span);
+                points?.set(related.location.start.offset, pointSpans);
+                continue;
+            }
+            originalBySource.get(related.sourceId)?.push({
+                end: related.location.end.offset,
+                prefixEnd: related.location.end.offset,
+                span,
+                start: related.location.start.offset
+            });
+        }
+        for (const nodeId of spanNodeIds)
+            nodeSpans.get(nodeId)?.push(span);
+        for (const symbolId of spanSymbolIds)
+            symbolSpans.get(symbolId)?.push(span);
+    }
+    for (const entries of originalBySource.values()) {
+        entries.sort((left, right) => left.start - right.start || left.span.generated.start.offset - right.span.generated.start.offset);
+        let prefixEnd = 0;
+        for (const entry of entries) {
+            prefixEnd = Math.max(prefixEnd, entry.end);
+            entry.prefixEnd = prefixEnd;
+        }
+    }
+    return { generatedCoordinates, nodeSpans, originalBySource, originalPointsBySource, sourceCoordinates, sourcesById, symbolSpans };
+}
+/**
+ * Finds the generated span containing an offset by binary search.
+ * @param {import("./semantic/types.js").SemantifoldMappingSpan[]} spans - Ordered spans.
+ * @param {number} offset - Generated offset.
+ * @returns {import("./semantic/types.js").SemantifoldMappingSpan | undefined} Containing span.
+ */
+function spanForGenerated(spans, offset) {
+    let low = 0;
+    let high = spans.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (spans[middle].generated.start.offset <= offset)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    const candidate = spans[low - 1];
+    return candidate && offset < candidate.generated.end.offset ? candidate : undefined;
+}
+/**
+ * Finds ordered generated spans intersecting a half-open range.
+ * @param {import("./semantic/types.js").SemantifoldMappingSpan[]} spans - Ordered spans.
+ * @param {number} start - Inclusive generated offset.
+ * @param {number} end - Exclusive generated offset.
+ * @returns {import("./semantic/types.js").SemantifoldMappingSpan[]} Overlapping spans.
+ */
+function spansOverlappingGenerated(spans, start, end) {
+    if (end <= start) {
+        const containing = spanForGenerated(spans, start);
+        return containing ? [containing] : [];
+    }
+    let low = 0;
+    let high = spans.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (spans[middle].generated.end.offset <= start)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    const overlapping = [];
+    for (let index = low; index < spans.length && spans[index].generated.start.offset < end; index++) {
+        overlapping.push(spans[index]);
+    }
+    return overlapping;
+}
+/**
+ * Deep-freezes a JSON tree.
+ * @param {unknown} value - JSON value.
+ * @param {WeakSet<object>} [visited] - Cycle protection for rejected caller extras.
+ * @returns {void}
+ */
+function freezeJson(value, visited = new WeakSet()) {
+    if (!value || typeof value != "object" || visited.has(value))
+        return;
+    visited.add(value);
+    for (const child of Object.values(value))
+        freezeJson(child, visited);
+    if (!Object.isFrozen(value))
+        Object.freeze(value);
+}
+/**
+ * Validates one closed mapping origin.
+ * @param {import("./semantic/types.js").SemanticOrigin} origin - Origin.
+ * @param {Map<string, import("./semantic/types.js").RegisteredSource>} sourcesById - Sources by identity.
+ * @param {Map<string, ReturnType<typeof createCoordinateIndex>>} coordinates - Source coordinate indexes.
+ * @param {Set<unknown>} [nodeIds] - Known semantic nodes.
+ * @param {Set<unknown>} [symbolIds] - Known semantic symbols.
+ * @returns {void}
+ */
+function validateOrigin(origin, sourcesById, coordinates, nodeIds, symbolIds) {
+    if (!origin || typeof origin != "object")
+        throw new TypeError("Mapping origin must be a closed provenance value.");
+    if (origin.kind == "source") {
+        validateRelated({ location: origin.location, sourceId: origin.sourceId }, sourcesById, coordinates, nodeIds, symbolIds);
+        return;
+    }
+    if (origin.kind == "derived") {
+        if (!Array.isArray(origin.origins) || origin.origins.length == 0)
+            throw new TypeError("Derived provenance requires origins.");
+        origin.origins.forEach((related) => validateRelated(related, sourcesById, coordinates, nodeIds, symbolIds));
+        return;
+    }
+    if (origin.kind == "synthetic") {
+        if (typeof origin.reason != "string" || !Array.isArray(origin.relatedOrigins))
+            throw new TypeError("Malformed synthetic provenance.");
+        origin.relatedOrigins.forEach((related) => validateRelated(related, sourcesById, coordinates, nodeIds, symbolIds));
+        return;
+    }
+    throw new TypeError("Unknown provenance kind.");
+}
+/**
+ * Validates one source-related origin.
+ * @param {import("./semantic/types.js").RelatedOrigin} related - Related origin.
+ * @param {Map<string, import("./semantic/types.js").RegisteredSource>} sourcesById - Sources by identity.
+ * @param {Map<string, ReturnType<typeof createCoordinateIndex>>} coordinates - Source coordinate indexes.
+ * @param {Set<unknown> | undefined} nodeIds - Known semantic nodes.
+ * @param {Set<unknown> | undefined} symbolIds - Known semantic symbols.
+ * @returns {void}
+ */
+function validateRelated(related, sourcesById, coordinates, nodeIds, symbolIds) {
+    const source = sourcesById.get(related.sourceId);
+    if (!source || !related.location || related.location.filename != source.filename ||
+        related.nodeId !== undefined && typeof related.nodeId != "string" ||
+        related.symbolId !== undefined && typeof related.symbolId != "string" ||
+        related.role !== undefined && typeof related.role != "string")
+        throw new TypeError("Origin references an unknown source.");
+    if (nodeIds && related.nodeId !== undefined && !nodeIds.has(related.nodeId))
+        throw new TypeError("Origin references an unknown node.");
+    if (symbolIds && related.symbolId !== undefined && !symbolIds.has(related.symbolId)) {
+        throw new TypeError("Origin references an unknown symbol.");
+    }
+    validateLocationForSource(related.location, source, coordinates.get(source.id));
+}
+/**
+ * Validates a location against at least one same-filename source.
+ * @param {unknown} value - Candidate location.
+ * @param {Map<string, import("./semantic/types.js").RegisteredSource[]>} sourcesByFilename - Sources by filename.
+ * @param {Map<string, ReturnType<typeof createCoordinateIndex>>} coordinates - Source coordinate indexes.
+ * @returns {void}
+ */
+function validateLocationForSources(value, sourcesByFilename, coordinates) {
+    if (!value || typeof value != "object")
+        throw new TypeError("Malformed original location.");
+    const location = /** @type {import("./semantic/types.js").SourceLocation} */ (value);
+    const candidates = sourcesByFilename.get(location.filename) ?? [];
+    if (candidates.length == 0 || !candidates.some((source) => locationMatchesSource(location, source, coordinates.get(source.id)))) {
+        throw new TypeError("Stale original location.");
+    }
+}
+/**
+ * Validates a location against its identified source.
+ * @param {unknown} value - Candidate location.
+ * @param {import("./semantic/types.js").RegisteredSource} source - Source.
+ * @param {ReturnType<typeof createCoordinateIndex> | undefined} coordinates - Source coordinates when content exists.
+ * @returns {void}
+ */
+function validateLocationForSource(value, source, coordinates) {
+    if (!value || typeof value != "object" || !locationMatchesSource(
+    /** @type {import("./semantic/types.js").SourceLocation} */ (value), source, coordinates))
+        throw new TypeError("Stale original location.");
+}
+/**
+ * Tests a location against one source entry.
+ * @param {import("./semantic/types.js").SourceLocation} location - Location.
+ * @param {import("./semantic/types.js").RegisteredSource} source - Source.
+ * @param {ReturnType<typeof createCoordinateIndex> | undefined} coordinates - Source coordinates when content exists.
+ * @returns {boolean} Whether the range is normalized for the source.
+ */
+function locationMatchesSource(location, source, coordinates) {
+    if (!location || location.filename != source.filename || !location.start || !location.end ||
+        !validPoint(location.start) || !validPoint(location.end) || location.end.offset < location.start.offset)
+        return false;
+    if (source.content == null)
+        return true;
+    return location.end.offset <= source.content.length && coordinates !== undefined &&
+        samePoint(indexedPointAt(coordinates, location.start.offset), location.start) &&
+        samePoint(indexedPointAt(coordinates, location.end.offset), location.end);
+}
+/**
+ * Tests the structural validity of one source point.
+ * @param {unknown} value - Candidate point.
+ * @returns {value is import("./semantic/types.js").SourcePoint} Whether it is a point.
+ */
+function validPoint(value) {
+    if (!value || typeof value != "object")
+        return false;
+    const point = /** @type {Record<string, unknown>} */ (value);
+    return Number.isInteger(point.offset) && Number.isInteger(point.line) && Number.isInteger(point.column) &&
+        /** @type {number} */ (point.offset) >= 0 && /** @type {number} */ (point.line) >= 1 && /** @type {number} */ (point.column) >= 1;
+}
+/**
+ * Tests a supported semantic language value.
+ * @param {unknown} value - Candidate language.
+ * @returns {value is import("./semantic/types.js").SemanticLanguage} Whether supported.
+ */
+function isLanguage(value) {
+    return value == "php" || value == "ruby" || value == "javascript" || value == "typescript" || value == "java";
+}
+/**
+ * Builds one stable lookup result.
+ * @param {import("./semantic/types.js").SemantifoldMappingSpan} span - Mapping span.
+ * @returns {{generatedLocation: import("./semantic/types.js").SourceLocation, location: import("./semantic/types.js").SourceLocation | undefined, mappingKind: import("./semantic/types.js").MappingKind, name: string | undefined, nodeId: string | undefined, role: string | undefined, symbolId: string | undefined}} Lookup result.
+ */
+function mappingResult(span) {
+    return {
+        generatedLocation: span.generated,
+        location: primaryLocation(span.origin),
+        mappingKind: span.mappingKind,
+        name: span.name,
+        nodeId: span.nodeId,
+        role: span.role,
+        symbolId: span.symbolId
+    };
+}
+/**
+ * Resolves an offset-form or line/column-form position.
+ * @param {ReturnType<typeof createCoordinateIndex>} coordinates - Source coordinate index.
+ * @param {{offset: number} | {line: number, column: number}} position - Position.
+ * @returns {number} UTF-16 offset.
+ */
+function positionOffset(coordinates, position) {
+    if ("offset" in position) {
+        indexedPointAt(coordinates, position.offset);
+        return position.offset;
+    }
+    return indexedOffsetAt(coordinates, position.line, position.column);
+}
+/**
+ * Finds the exclusive content offset before the next generated line break.
+ * @param {string} content - Generated content.
+ * @param {number} offset - Offset on the current line.
+ * @returns {number} End of the current line or content.
+ */
+function lineEndOffset(content, offset) {
+    const newline = content.indexOf("\n", offset);
+    return newline == -1 ? content.length : newline;
+}
+/**
+ * Compares complete normalized points.
+ * @param {import("./semantic/types.js").SourcePoint} left - Left point.
+ * @param {import("./semantic/types.js").SourcePoint} right - Right point.
+ * @returns {boolean} Whether coordinates match.
+ */
+function samePoint(left, right) {
+    return left.offset == right.offset && left.line == right.line && left.column == right.column;
+}
+/**
+ * Resolves a source registry entry for an origin.
+ * @param {import("./semantic/types.js").SemantifoldMapping} mapping - Mapping.
+ * @param {import("./semantic/types.js").SemanticOrigin} origin - Origin.
+ * @param {import("./semantic/types.js").SourceLocation} location - Primary location.
+ * @param {Map<string, import("./semantic/types.js").RegisteredSource>} sourcesById - Indexed sources.
+ * @returns {import("./semantic/types.js").RegisteredSource} Registered source.
+ */
+function sourceForOrigin(mapping, origin, location, sourcesById) {
+    const sourceId = sourceIdForOrigin(origin);
+    const source = sourcesById.get(sourceId ?? "") ??
+        mapping.sources.find((candidate) => candidate.filename == location.filename);
+    if (!source)
+        throw new RangeError(`Unknown mapping source for ${location.filename}.`);
+    return source;
+}
+/**
+ * Resolves the registry identity of an origin's primary location.
+ * @param {import("./semantic/types.js").SemanticOrigin} origin - Origin.
+ * @returns {string | undefined} Source identity.
+ */
+function sourceIdForOrigin(origin) {
+    if (origin.kind == "source")
+        return origin.sourceId;
+    if (origin.kind == "derived")
+        return origin.origins[0]?.sourceId;
+    return origin.relatedOrigins[0]?.sourceId;
+}
+/**
+ * Rewrites closed-origin source identities against a composed registry.
+ * @param {import("./semantic/types.js").SemanticOrigin} origin - Origin.
+ * @param {Map<string, string>} sourceIds - Original-to-composed source identities.
+ * @returns {import("./semantic/types.js").SemanticOrigin} Rewritten origin.
+ */
+function remapOriginSourceIds(origin, sourceIds) {
+    if (origin.kind == "source") {
+        const sourceId = sourceIds.get(origin.sourceId);
+        if (!sourceId)
+            throw new RangeError(`Composed mapping omitted source '${origin.location.filename}'.`);
+        return { kind: "source", location: origin.location, sourceId };
+    }
+    if (origin.kind == "derived")
+        return { kind: "derived", origins: origin.origins.map((related) => remapRelatedOriginSourceId(related, sourceIds)) };
+    return {
+        kind: "synthetic",
+        reason: origin.reason,
+        relatedOrigins: origin.relatedOrigins.map((related) => remapRelatedOriginSourceId(related, sourceIds))
+    };
+}
+/**
+ * Rewrites one related source identity while dropping identities from a discarded node registry.
+ * @param {import("./semantic/types.js").RelatedOrigin} related - Related origin.
+ * @param {Map<string, string>} sourceIds - Original-to-composed source identities.
+ * @returns {import("./semantic/types.js").RelatedOrigin} Rewritten related origin.
+ */
+function remapRelatedOriginSourceId(related, sourceIds) {
+    const sourceId = sourceIds.get(related.sourceId);
+    if (!sourceId)
+        throw new RangeError(`Composed mapping omitted source '${related.location.filename}'.`);
+    const unidentified = { ...related };
+    delete unidentified.nodeId;
+    delete unidentified.symbolId;
+    return { ...unidentified, sourceId };
+}
+/**
+ * Sorts object keys recursively while preserving semantic array order.
+ * @param {unknown} value - JSON value.
+ * @returns {unknown} Deterministically keyed value.
+ */
+function sortJson(value) {
+    if (Array.isArray(value))
+        return value.map(sortJson);
+    if (value && typeof value == "object") {
+        return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)
+            .map(([key, child]) => [key, sortJson(child)]));
+    }
+    return value;
+}
+/**
+ * Removes undefined optional properties from a public JSON value.
+ * @template {Record<string, unknown>} Value
+ * @param {Value} value - Candidate object.
+ * @returns {Value} Compact JSON-safe object.
+ */
+function definedProperties(value) {
+    return /** @type {Value} */ (Object.fromEntries(Object.entries(value).filter(([, child]) => child !== undefined)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mapping.js","sourceRoot":"","sources":["../../src/mapping.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {addSegment, GenMapping, maybeAddSegment, setSourceContent, toEncodedMap} from \"@jridgewell/gen-mapping\"\nimport {\n  eachMapping,\n  originalPositionFor as traceOriginalPositionFor,\n  sourceContentFor,\n  TraceMap\n} from \"@jridgewell/trace-mapping\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {createCoordinateIndex, indexedOffsetAt, indexedPointAt, locationFromOffsets} from \"./semantic/location.js\"\nimport {primaryLocation} from \"./semantic/provenance.js\"\n\n/** @typedef {ReturnType<typeof buildMappingIndex>} MappingIndex */\n/** @type {WeakMap<import(\"./semantic/types.js\").SemantifoldMapping, MappingIndex>} */\nconst mappingIndexes = new WeakMap()\n\n/**\n * Projects an authoritative Semantifold mapping to Source Map v3.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Rich mapping.\n * @returns {import(\"@jridgewell/gen-mapping\").EncodedSourceMap} Source Map v3.\n */\nexport function toSourceMapV3(mapping) {\n  const index = mappingIndex(mapping)\n\n  const generated = new GenMapping({file: mapping.generated.filename})\n\n  for (const source of mapping.sources) setSourceContent(generated, source.filename, source.content)\n\n  for (const span of mapping.spans) {\n    const location = primaryLocation(span.origin)\n    const line = span.generated.start.line - 1\n    const column = span.generated.start.column - 1\n\n    if (!location || span.mappingKind == \"synthetic\") {\n      maybeAddSegment(generated, line, column)\n      continue\n    }\n\n    const registered = sourceForOrigin(mapping, span.origin, location, index.sourcesById)\n\n    if (span.name) {\n      addSegment(generated, line, column, registered.filename, location.start.line - 1, location.start.column - 1, span.name, registered.content)\n    } else {\n      addSegment(generated, line, column, registered.filename, location.start.line - 1, location.start.column - 1, null, registered.content)\n    }\n  }\n\n  return toEncodedMap(generated)\n}\n\n/**\n * Looks up original provenance for one generated UTF-16 position.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Rich mapping.\n * @param {{offset: number} | {line: number, column: number}} position - Generated position.\n * @returns {{generatedLocation: import(\"./semantic/types.js\").SourceLocation, location: import(\"./semantic/types.js\").SourceLocation | undefined, mappingKind: import(\"./semantic/types.js\").MappingKind, name: string | undefined, nodeId: string | undefined, role: string | undefined, symbolId: string | undefined}} Lookup result.\n */\nexport function originalPositionFor(mapping, position) {\n  const index = mappingIndex(mapping)\n  const offset = positionOffset(index.generatedCoordinates, position)\n  const span = spanForGenerated(mapping.spans, offset)\n\n  if (!span) throw new RangeError(`No generated mapping at offset ${offset}.`)\n\n  return mappingResult(span)\n}\n\n/**\n * Looks up every generated span containing one original UTF-16 position.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Rich mapping.\n * @param {({filename: string} | {sourceId: string}) & ({offset: number} | {line: number, column: number})} position - Original position.\n * @returns {{generatedLocation: import(\"./semantic/types.js\").SourceLocation, location: import(\"./semantic/types.js\").SourceLocation | undefined, mappingKind: import(\"./semantic/types.js\").MappingKind, name: string | undefined, nodeId: string | undefined, role: string | undefined, symbolId: string | undefined}[]} Generated results.\n */\nexport function generatedPositionFor(mapping, position) {\n  const index = mappingIndex(mapping)\n  const source = \"sourceId\" in position\n    ? index.sourcesById.get(position.sourceId)\n    : mapping.sources.find((candidate) => candidate.filename == position.filename)\n\n  if (!source) return []\n  if (source.content == null && !(\"offset\" in position)) {\n    throw new TypeError(`Source content is required for line/column lookup of ${source.filename}.`)\n  }\n\n  let offset\n\n  if (\"offset\" in position) {\n    if (source.content == null) {\n      if (!Number.isInteger(position.offset) || position.offset < 0) throw new RangeError(`Invalid source offset: ${position.offset}`)\n    } else indexedPointAt(/** @type {ReturnType<typeof createCoordinateIndex>} */ (index.sourceCoordinates.get(source.id)), position.offset)\n    offset = position.offset\n  } else {\n    offset = indexedOffsetAt(/** @type {ReturnType<typeof createCoordinateIndex>} */ (index.sourceCoordinates.get(source.id)),\n      position.line, position.column)\n  }\n  const entries = index.originalBySource.get(source.id) ?? []\n  let low = 0\n  let high = entries.length\n\n  while (low < high) {\n    const middle = Math.floor((low + high) / 2)\n\n    if (entries[middle].start <= offset) low = middle + 1\n    else high = middle\n  }\n\n  /** @type {Set<import(\"./semantic/types.js\").SemantifoldMappingSpan>} */\n  const matches = new Set()\n\n  for (const span of index.originalPointsBySource.get(source.id)?.get(offset) ?? []) matches.add(span)\n\n  for (let candidate = low - 1; candidate >= 0 && entries[candidate].prefixEnd > offset; candidate--) {\n    if (entries[candidate].end > offset) matches.add(entries[candidate].span)\n  }\n\n  return [...matches].sort((left, right) => left.generated.start.offset - right.generated.start.offset).map(mappingResult)\n}\n\n/**\n * Returns every generated span associated with one canonical semantic node.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Rich mapping.\n * @param {string} nodeId - Canonical node identity.\n * @returns {import(\"./semantic/types.js\").SemantifoldMappingSpan[]} Matching spans.\n */\nexport function spansForNode(mapping, nodeId) {\n  const index = mappingIndex(mapping)\n  if (!index.nodeSpans.has(nodeId)) throw new RangeError(`Unknown semantic node: ${nodeId}`)\n\n  return [...(index.nodeSpans.get(nodeId) ?? [])]\n}\n\n/**\n * Returns every generated span associated with one canonical semantic symbol.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Rich mapping.\n * @param {string} symbolId - Canonical symbol identity.\n * @returns {import(\"./semantic/types.js\").SemantifoldMappingSpan[]} Matching spans.\n */\nexport function spansForSymbol(mapping, symbolId) {\n  const index = mappingIndex(mapping)\n  if (!index.symbolSpans.has(symbolId)) throw new RangeError(`Unknown semantic symbol: ${symbolId}`)\n\n  return [...(index.symbolSpans.get(symbolId) ?? [])]\n}\n\n/**\n * Serializes a validated rich mapping deterministically.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Rich mapping.\n * @returns {string} Canonical pretty JSON with one trailing LF.\n */\nexport function stringifyMapping(mapping) {\n  mappingIndex(mapping)\n\n  return `${JSON.stringify(sortJson(mapping), null, 2)}\\n`\n}\n\n/**\n * Parses and validates a rich mapping.\n * @param {string} serialized - Mapping JSON.\n * @returns {import(\"./semantic/types.js\").SemantifoldMapping} Parsed mapping.\n */\nexport function parseMapping(serialized) {\n  const mapping = /** @type {unknown} */ (JSON.parse(serialized))\n\n  return finalizeMapping(mapping)\n}\n\n/**\n * Composes an outer rich map through an inner rich map.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} outer - Final output to intermediate map.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} inner - Intermediate to original map.\n * @returns {import(\"./semantic/types.js\").SemantifoldMapping} Composed rich map.\n */\nexport function composeMappings(outer, inner) {\n  const outerIndex = mappingIndex(outer)\n\n  mappingIndex(inner)\n\n  /** @type {import(\"./semantic/types.js\").RegisteredSource[]} */\n  const sources = inner.sources.map((source) => ({...source}))\n  const sourceIds = new Set(sources.map((source) => source.id))\n  /** @type {Map<string, string>} */\n  const outerSourceIds = new Map()\n  let nextSourceIndex = 0\n\n  for (const source of outer.sources) {\n    if (sourceRepresentsGenerated(source, inner.generated)) continue\n    retainOuterSource(source.id)\n  }\n\n  const spans = outer.spans.flatMap((span) => {\n    /** @type {ReturnType<typeof traceRelatedOrigin> | undefined} */\n    let trace\n\n    for (const related of relatedOriginsForOrigin(span.origin)) {\n      trace = traceRelatedOrigin(related)\n      if (trace?.traced) break\n    }\n    const location = trace?.related.location\n    const overlapping = trace?.overlapping ?? []\n    const traced = trace?.traced\n\n    if (!traced) {\n      for (const related of relatedOriginsForOrigin(span.origin)) {\n        const relatedTrace = traceRelatedOrigin(related)\n\n        if (relatedTrace && isGeneratedEofPoint(related)) retainOuterSource(related.sourceId)\n      }\n      const unidentified = {...span}\n\n      delete unidentified.nodeId\n      delete unidentified.symbolId\n\n      return [{...unidentified, origin: remapOriginSourceIds(span.origin, outerSourceIds)}]\n    }\n    const selectedRelated = trace?.related\n\n    if (!selectedRelated) throw new RangeError(\"Intermediate trace selection is missing its related origin.\")\n\n    if (location && overlapping.length > 1 && span.mappingKind == \"exact\" &&\n      span.generated.end.offset - span.generated.start.offset == location.end.offset - location.start.offset) {\n      return overlapping.map((candidate) => {\n        const overlapStart = Math.max(location.start.offset, candidate.generated.start.offset)\n        const overlapEnd = Math.min(location.end.offset, candidate.generated.end.offset)\n        const generatedStart = span.generated.start.offset + overlapStart - location.start.offset\n        const generatedEnd = span.generated.start.offset + overlapEnd - location.start.offset\n        const preservesWholeOrigin = overlapStart == candidate.generated.start.offset && overlapEnd == candidate.generated.end.offset\n\n        return composedSpan(span, candidate, locationFromOffsets(\n          outer.generated.filename,\n          outer.generated.content,\n          generatedStart,\n          generatedEnd\n        ), preservesWholeOrigin, selectedRelated, true)\n      })\n    }\n\n    const preservesWholeOrigin = Boolean(location && location.start.offset == traced.generated.start.offset &&\n      location.end.offset == traced.generated.end.offset)\n    const composed = composedSpan(span, traced, span.generated, preservesWholeOrigin, selectedRelated)\n\n    if (span.origin.kind == \"source\" && overlapping.length > 1) {\n      const origins = composeRelatedOrigins([selectedRelated], selectedRelated, traced, false)\n\n      if (origins.length > 0) {\n        return [{...composed, mappingKind: /** @type {const} */ (\"anchor\"), origin: {\n          kind: /** @type {const} */ (\"derived\"),\n          origins\n        }}]\n      }\n    }\n\n    return [composed]\n  })\n\n  return finalizeMapping({\n    coordinateSystem: \"utf16\",\n    generated: outer.generated,\n    nodes: inner.nodes,\n    schema: \"SemantifoldMapping\",\n    sources,\n    spans,\n    symbols: inner.symbols,\n    version: 1\n  })\n\n  /**\n   * Composes one outer generated range with an inner range.\n   * @param {import(\"./semantic/types.js\").SemantifoldMappingSpan} outerSpan - Outer span.\n   * @param {import(\"./semantic/types.js\").SemantifoldMappingSpan} innerSpan - Inner span.\n   * @param {import(\"./semantic/types.js\").SourceLocation} generated - Final generated subrange.\n   * @param {boolean} preservesWholeOrigin - Whether adopting the inner origin retains its complete range.\n   * @param {import(\"./semantic/types.js\").RelatedOrigin} selectedRelated - Outer origin traced through this inner span.\n   * @param {boolean} [restrictSelectedTrace] - Whether an exact split selects only this inner span.\n   * @returns {import(\"./semantic/types.js\").SemantifoldMappingSpan} Composed span.\n   */\n  function composedSpan(outerSpan, innerSpan, generated, preservesWholeOrigin, selectedRelated, restrictSelectedTrace = false) {\n    if (outerSpan.mappingKind == \"synthetic\" && outerSpan.origin.kind == \"synthetic\") {\n      return definedProperties({\n        generated,\n        mappingKind: /** @type {const} */ (\"synthetic\"),\n        name: outerSpan.name,\n        origin: {\n          kind: /** @type {const} */ (\"synthetic\"),\n          reason: outerSpan.origin.reason,\n          relatedOrigins: composeRelatedOrigins(outerSpan.origin.relatedOrigins, selectedRelated, innerSpan, restrictSelectedTrace)\n        },\n        role: outerSpan.role\n      })\n    }\n\n    const composedDerivedOrigins = outerSpan.origin.kind == \"derived\"\n      ? composeRelatedOrigins(outerSpan.origin.origins, selectedRelated, innerSpan, restrictSelectedTrace)\n      : undefined\n    const origin = outerSpan.origin.kind == \"source\" ? innerSpan.origin : outerSpan.origin.kind == \"derived\"\n      ? composedDerivedOrigins?.length == 0 && innerSpan.origin.kind == \"synthetic\"\n        ? innerSpan.origin\n        : {kind: /** @type {const} */ (\"derived\"), origins: /** @type {import(\"./semantic/types.js\").RelatedOrigin[]} */ (composedDerivedOrigins)}\n      : {\n          kind: /** @type {const} */ (\"synthetic\"),\n          reason: outerSpan.origin.reason,\n          relatedOrigins: composeRelatedOrigins(outerSpan.origin.relatedOrigins, selectedRelated, innerSpan, restrictSelectedTrace)\n        }\n\n    return definedProperties({\n      ...outerSpan,\n      generated,\n      mappingKind: innerSpan.mappingKind == \"synthetic\" ? /** @type {const} */ (\"synthetic\") :\n        outerSpan.mappingKind == \"exact\" && innerSpan.mappingKind == \"exact\" && preservesWholeOrigin\n          ? /** @type {const} */ (\"exact\")\n          : /** @type {const} */ (\"anchor\"),\n      name: outerSpan.name ?? innerSpan.name,\n      nodeId: innerSpan.nodeId,\n      origin,\n      role: innerSpan.role ?? outerSpan.role,\n      symbolId: innerSpan.symbolId\n    })\n  }\n\n  /**\n   * Finds the inner span selected by one related intermediate origin.\n   * @param {import(\"./semantic/types.js\").RelatedOrigin} related - Outer related origin.\n   * @returns {{\n   *   overlapping: import(\"./semantic/types.js\").SemantifoldMappingSpan[],\n   *   related: import(\"./semantic/types.js\").RelatedOrigin,\n   *   traced: import(\"./semantic/types.js\").SemantifoldMappingSpan | undefined\n   * } | undefined} Trace selection when the related source is the intermediate artifact.\n   */\n  function traceRelatedOrigin(related) {\n    const source = outerIndex.sourcesById.get(related.sourceId)\n\n    if (!source || !sourceRepresentsGenerated(source, inner.generated)) return undefined\n    const overlapping = spansOverlappingGenerated(inner.spans, related.location.start.offset, related.location.end.offset)\n\n    return {\n      overlapping,\n      related,\n      traced: overlapping[0] ?? spanForGenerated(inner.spans, related.location.start.offset)\n    }\n  }\n\n  /**\n   * Traces intermediate related origins and remaps unrelated source identities in order.\n   * @param {import(\"./semantic/types.js\").RelatedOrigin[]} relatedOrigins - Outer related origins.\n   * @param {import(\"./semantic/types.js\").RelatedOrigin} selectedRelated - Origin using the selected inner span.\n   * @param {import(\"./semantic/types.js\").SemantifoldMappingSpan} selectedSpan - Selected inner span.\n   * @param {boolean} restrictSelectedTrace - Whether an exact split selects only the supplied span.\n   * @returns {import(\"./semantic/types.js\").RelatedOrigin[]} Composed related origins.\n   */\n  function composeRelatedOrigins(relatedOrigins, selectedRelated, selectedSpan, restrictSelectedTrace) {\n    return relatedOrigins.flatMap((related) => {\n      const source = outerIndex.sourcesById.get(related.sourceId)\n\n      if (!source || !sourceRepresentsGenerated(source, inner.generated)) {\n        return [remapRelatedOriginSourceId(related, outerSourceIds)]\n      }\n      const trace = traceRelatedOrigin(related)\n      const tracedSpans = restrictSelectedTrace && related === selectedRelated\n        ? [selectedSpan]\n        : trace?.overlapping.length\n          ? trace.overlapping\n          : trace?.traced ? [trace.traced] : []\n\n      if (tracedSpans.length == 0) {\n        if (!isGeneratedEofPoint(related)) throw new RangeError(`Unable to trace intermediate origin '${related.location.filename}'.`)\n        retainOuterSource(related.sourceId)\n\n        return [remapRelatedOriginSourceId(related, outerSourceIds)]\n      }\n\n      return tracedSpans.flatMap((tracedSpan) => relatedOriginsForSpan(tracedSpan).map((tracedRelated) => definedProperties({\n          ...tracedRelated,\n          nodeId: tracedRelated.nodeId ?? tracedSpan.nodeId,\n          role: related.role ?? tracedRelated.role,\n          symbolId: tracedRelated.symbolId ?? tracedSpan.symbolId\n        })))\n    })\n  }\n\n  /**\n   * Retains one outer source that survives composition and assigns its composed identity.\n   * @param {string} sourceId - Outer source registry identity.\n   * @returns {void}\n   */\n  function retainOuterSource(sourceId) {\n    if (outerSourceIds.has(sourceId)) return\n    const source = outerIndex.sourcesById.get(sourceId)\n\n    if (!source) throw new RangeError(`Unknown outer mapping source '${sourceId}'.`)\n    let composedSource = sources.find((candidate) => sameRegisteredSource(candidate, source))\n\n    if (!composedSource) {\n      while (sourceIds.has(`source:${nextSourceIndex}`)) nextSourceIndex++\n      composedSource = {...source, id: `source:${nextSourceIndex}`}\n      sourceIds.add(composedSource.id)\n      sources.push(composedSource)\n    }\n    outerSourceIds.set(source.id, composedSource.id)\n  }\n\n  /**\n   * Tests whether one intermediate origin is the exact point after all generated code units.\n   * @param {import(\"./semantic/types.js\").RelatedOrigin} related - Candidate intermediate origin.\n   * @returns {boolean} Whether this is an EOF point rather than a generated half-open range.\n   */\n  function isGeneratedEofPoint(related) {\n    return related.location.start.offset == inner.generated.content.length &&\n      related.location.end.offset == inner.generated.content.length\n  }\n}\n\n/**\n * Converts one mapped span's closed origin into related provenance.\n * @param {import(\"./semantic/types.js\").SemantifoldMappingSpan} span - Traced inner span.\n * @returns {import(\"./semantic/types.js\").RelatedOrigin[]} Related original ranges.\n */\nfunction relatedOriginsForSpan(span) {\n  return relatedOriginsForOrigin(span.origin)\n}\n\n/**\n * Returns every related range in one closed origin.\n * @param {import(\"./semantic/types.js\").SemanticOrigin} origin - Closed origin.\n * @returns {import(\"./semantic/types.js\").RelatedOrigin[]} Related ranges in semantic order.\n */\nfunction relatedOriginsForOrigin(origin) {\n  if (origin.kind == \"source\") return [{location: origin.location, sourceId: origin.sourceId}]\n  if (origin.kind == \"derived\") return origin.origins\n\n  return origin.relatedOrigins\n}\n\n/**\n * Determines whether a registered source is the generated artifact consumed by an inner map.\n * @param {import(\"./semantic/types.js\").RegisteredSource} source - Outer source registry entry.\n * @param {import(\"./semantic/types.js\").GeneratedSource} generated - Inner generated artifact.\n * @returns {boolean} Whether identity-selected provenance may be traced through the inner map.\n */\nfunction sourceRepresentsGenerated(source, generated) {\n  return source.filename == generated.filename && source.content == generated.content &&\n    (source.language == null || source.language == generated.language)\n}\n\n/**\n * Compares complete registered-source identity fields other than registry-local ID.\n * @param {import(\"./semantic/types.js\").RegisteredSource} left - First registered source.\n * @param {import(\"./semantic/types.js\").RegisteredSource} right - Second registered source.\n * @returns {boolean} Whether both entries represent the same source artifact.\n */\nfunction sameRegisteredSource(left, right) {\n  return left.filename == right.filename && left.content == right.content && left.language == right.language\n}\n\n/**\n * Composes Source Map v3 maps with maintained tracing machinery.\n * @param {import(\"@jridgewell/trace-mapping\").SourceMapInput} outer - Final output to intermediate map.\n * @param {import(\"@jridgewell/trace-mapping\").SourceMapInput} inner - Intermediate to original map.\n * @returns {import(\"@jridgewell/gen-mapping\").EncodedSourceMap} Composed v3 map.\n */\nexport function composeSourceMaps(outer, inner) {\n  const outerMap = new TraceMap(outer)\n  const innerMap = new TraceMap(inner)\n  const composed = new GenMapping({file: outerMap.file})\n  const intermediateIndexes = typeof innerMap.file == \"string\"\n    ? outerMap.resolvedSources.flatMap((source, index) => source == innerMap.file ? [index] : [])\n    : []\n  const intermediateIndex = intermediateIndexes.length == 1 ? intermediateIndexes[0] : undefined\n  const intermediateSource = intermediateIndex === undefined ? undefined : outerMap.resolvedSources[intermediateIndex]\n\n  innerMap.sources.forEach((rawSource, index) => {\n    const source = innerMap.resolvedSources[index] ?? rawSource\n\n    if (source != null) setSourceContent(composed, source, innerMap.sourcesContent?.[index] ?? null)\n  })\n  outerMap.sources.forEach((rawSource, index) => {\n    const source = outerMap.resolvedSources[index] ?? rawSource\n\n    if (source != null && index != intermediateIndex) {\n      setSourceContent(composed, source, outerMap.sourcesContent?.[index] ?? null)\n    }\n  })\n\n  eachMapping(outerMap, (mapping) => {\n    if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) {\n      maybeAddSegment(composed, mapping.generatedLine - 1, mapping.generatedColumn)\n      return\n    }\n\n    const isIntermediate = intermediateSource !== undefined && mapping.source == intermediateSource\n    const traced = isIntermediate\n      ? traceOriginalPositionFor(innerMap, {column: mapping.originalColumn, line: mapping.originalLine})\n      : {column: mapping.originalColumn, line: mapping.originalLine, name: mapping.name, source: mapping.source}\n\n    if (traced.source == null || traced.line == null || traced.column == null) {\n      maybeAddSegment(composed, mapping.generatedLine - 1, mapping.generatedColumn)\n      return\n    }\n\n    const content = isIntermediate ? sourceContentFor(innerMap, traced.source) : sourceContentFor(outerMap, traced.source)\n    const name = traced.name ?? mapping.name\n\n    if (name == null) {\n      addSegment(composed, mapping.generatedLine - 1, mapping.generatedColumn, traced.source, traced.line - 1, traced.column, null, content)\n    } else {\n      addSegment(composed, mapping.generatedLine - 1, mapping.generatedColumn, traced.source, traced.line - 1, traced.column, name, content)\n    }\n  })\n\n  return toEncodedMap(composed)\n}\n\n/**\n * Imports a point-based Source Map v3 as a range-based Semantifold map.\n * @param {import(\"@jridgewell/trace-mapping\").SourceMapInput} sourceMap - Source Map v3.\n * @param {object} generated - Generated program.\n * @param {string} generated.content - Exact generated content.\n * @param {string} generated.filename - Generated filename.\n * @param {import(\"./semantic/types.js\").SemanticLanguage} generated.language - Generated language.\n * @param {{filename: string, content: string, language?: import(\"./semantic/types.js\").SemanticLanguage}[]} [generated.sources] - Exact source content overrides.\n * @returns {import(\"./semantic/types.js\").SemantifoldMapping} Imported rich map.\n */\nexport function mappingFromSourceMap(sourceMap, {content, filename, language, sources: provided = []}) {\n  const trace = new TraceMap(sourceMap)\n  const generatedCoordinates = createCoordinateIndex(content)\n  /** @type {import(\"./semantic/types.js\").RegisteredSource[]} */\n  const sources = []\n  /** @type {Map<number, {filename: string, content: string, language?: import(\"./semantic/types.js\").SemanticLanguage}>} */\n  const overridesBySourceIndex = new Map()\n\n  for (const override of provided) {\n    const exact = trace.sources.flatMap((source, index) => {\n      const resolved = trace.resolvedSources[index]\n\n      return source == override.filename || resolved == override.filename ? [index] : []\n    })\n\n    if (exact.length > 0) {\n      for (const index of exact) overridesBySourceIndex.set(index, override)\n      continue\n    }\n    const suffix = trace.sources.flatMap((source, index) => {\n      const resolved = trace.resolvedSources[index]\n\n      return source?.endsWith(`/${override.filename}`) || resolved?.endsWith(`/${override.filename}`) ? [index] : []\n    })\n\n    if (suffix.length > 1) {\n      throw new RangeError(`Ambiguous Source Map source content override '${override.filename}' matches multiple sources.`)\n    }\n    if (suffix.length == 1 && !overridesBySourceIndex.has(suffix[0])) overridesBySourceIndex.set(suffix[0], override)\n  }\n  /** @type {Map<string, import(\"./semantic/types.js\").RegisteredSource>} */\n  const sourcesByMapName = new Map()\n\n  trace.sources.forEach((source, index) => {\n    if (source == null) return\n\n    const resolvedSource = trace.resolvedSources[index] ?? source\n    const providedSource = overridesBySourceIndex.get(index)\n    const registered = {\n      content: providedSource?.content ?? trace.sourcesContent?.[index] ?? null,\n      filename: providedSource?.filename ?? resolvedSource,\n      id: `source:${sources.length}`,\n      language: providedSource?.language ?? null\n    }\n\n    sources.push(registered)\n    if (!sourcesByMapName.has(resolvedSource)) sourcesByMapName.set(resolvedSource, registered)\n  })\n  const sourceCoordinates = new Map(sources.filter((source) => source.content != null)\n    .map((source) => [source.id, createCoordinateIndex(/** @type {string} */ (source.content))]))\n\n  /** @type {{generatedOffset: number, mapping: import(\"@jridgewell/trace-mapping\").EachMapping}[]} */\n  const points = []\n\n  eachMapping(trace, (mapping) => {\n    points.push({generatedOffset: indexedOffsetAt(generatedCoordinates, mapping.generatedLine, mapping.generatedColumn + 1), mapping})\n  })\n\n  /** @type {import(\"./semantic/types.js\").SemantifoldMappingSpan[]} */\n  const mappedSpans = []\n\n  points.forEach(({generatedOffset, mapping}, index) => {\n    const next = points[index + 1]\n    const end = next?.mapping.generatedLine == mapping.generatedLine\n      ? next.generatedOffset\n      : lineEndOffset(content, generatedOffset)\n\n    if (end <= generatedOffset) return\n\n    if (mapping.source == null || mapping.originalLine == null || mapping.originalColumn == null) {\n      mappedSpans.push({\n        generated: locationFromOffsets(filename, content, generatedOffset, end),\n        mappingKind: \"synthetic\",\n        origin: {kind: \"synthetic\", reason: \"unmapped Source Map segment\", relatedOrigins: []}\n      })\n      return\n    }\n\n    const source = sourcesByMapName.get(mapping.source)\n\n    if (!source) throw new RangeError(`Source Map references unregistered source '${mapping.source}'.`)\n    if (source.content == null) {\n      throw new RangeError(`Source content is required to import mapped positions for '${source.filename}'.`)\n    }\n\n    const originalOffset = indexedOffsetAt(\n      /** @type {ReturnType<typeof createCoordinateIndex>} */ (sourceCoordinates.get(source.id)),\n      mapping.originalLine,\n      mapping.originalColumn + 1\n    )\n    const originalEnd = Math.min(source.content.length, originalOffset + 1)\n    const originalLocation = locationFromOffsets(source.filename, source.content, originalOffset, originalEnd)\n\n    mappedSpans.push(definedProperties({\n      generated: locationFromOffsets(filename, content, generatedOffset, end),\n      mappingKind: \"anchor\",\n      name: mapping.name ?? undefined,\n      origin: {kind: \"source\", location: originalLocation, sourceId: source.id}\n    }))\n  })\n\n  /** @type {import(\"./semantic/types.js\").SemantifoldMappingSpan[]} */\n  const spans = []\n  let cursor = 0\n\n  for (const span of mappedSpans) {\n    if (span.generated.start.offset > cursor) spans.push(unmappedSpan(cursor, span.generated.start.offset))\n    if (span.generated.end.offset > cursor) {\n      spans.push(span.generated.start.offset < cursor ? {\n        ...span,\n        generated: locationFromOffsets(filename, content, cursor, span.generated.end.offset)\n      } : span)\n      cursor = span.generated.end.offset\n    }\n  }\n  if (cursor < content.length) spans.push(unmappedSpan(cursor, content.length))\n\n  return finalizeMapping({\n    coordinateSystem: \"utf16\",\n    generated: {content, filename, language},\n    nodes: [],\n    schema: \"SemantifoldMapping\",\n    sources,\n    spans,\n    symbols: [],\n    version: 1\n  })\n\n  /**\n   * Creates one explicit unmapped range.\n   * @param {number} start - Generated start offset.\n   * @param {number} end - Generated end offset.\n   * @returns {import(\"./semantic/types.js\").SemantifoldMappingSpan} Synthetic span.\n   */\n  function unmappedSpan(start, end) {\n    return {\n      generated: locationFromOffsets(filename, content, start, end),\n      mappingKind: \"synthetic\",\n      origin: {kind: \"synthetic\", reason: \"unmapped Source Map range\", relatedOrigins: []}\n    }\n  }\n}\n\n/**\n * Remaps a generated location while retaining the generated range in the result.\n * @param {import(\"./semantic/types.js\").SourceLocation} location - Generated location.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Rich mapping.\n * @returns {ReturnType<typeof originalPositionFor>} Remapped lookup.\n */\nexport function remapLocation(location, mapping) {\n  if (location.filename != mapping.generated.filename) throw new RangeError(`Location is not in ${mapping.generated.filename}.`)\n\n  return originalPositionFor(mapping, {offset: location.start.offset})\n}\n\n/**\n * Remaps a Semantifold diagnostic and preserves its generated location and cause.\n * @param {SemantifoldDiagnostic} diagnostic - Generated-program diagnostic.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Rich mapping.\n * @returns {SemantifoldDiagnostic} Remapped diagnostic.\n */\nexport function remapDiagnostic(diagnostic, mapping) {\n  if (!diagnostic.location) return diagnostic\n\n  const remapped = remapLocation(diagnostic.location, mapping)\n\n  if (!remapped.location) return diagnostic\n\n  return new SemantifoldDiagnostic({\n    cause: diagnostic,\n    code: diagnostic.code,\n    generatedLocation: diagnostic.location,\n    language: diagnostic.language,\n    location: remapped.location,\n    message: diagnostic.detail\n  })\n}\n\n/**\n * Validates the public mapping envelope and ordered half-open generated ranges.\n * @param {unknown} value - Candidate mapping.\n * @returns {asserts value is import(\"./semantic/types.js\").SemantifoldMapping} Nothing when valid.\n */\nexport function validateMapping(value) {\n  if (!value || typeof value != \"object\" || Reflect.get(value, \"schema\") != \"SemantifoldMapping\" ||\n    Reflect.get(value, \"version\") != 1 || Reflect.get(value, \"coordinateSystem\") != \"utf16\") {\n    throw new TypeError(\"Expected a SemantifoldMapping v1 value.\")\n  }\n\n  const mapping = /** @type {Record<string, unknown>} */ (value)\n  const generated = /** @type {Record<string, unknown>} */ (mapping.generated)\n  const spans = mapping.spans\n\n  if (!generated || typeof generated != \"object\" || typeof Reflect.get(generated, \"filename\") != \"string\" ||\n    typeof Reflect.get(generated, \"content\") != \"string\" || !isLanguage(Reflect.get(generated, \"language\")) ||\n    !Array.isArray(mapping.sources) ||\n    !Array.isArray(mapping.nodes) || !Array.isArray(mapping.symbols) || !Array.isArray(spans)) {\n    throw new TypeError(\"Malformed SemantifoldMapping v1 envelope.\")\n  }\n\n  const content = /** @type {string} */ (generated.content)\n  const filename = /** @type {string} */ (generated.filename)\n\n  if (content.includes(\"\\r\")) throw new TypeError(\"SemantifoldMapping generated content must use LF line endings.\")\n\n  const sourceIds = new Set()\n\n  for (const source of mapping.sources) {\n    if (!source || typeof source != \"object\" || typeof source.id != \"string\" || source.id.length == 0 || sourceIds.has(source.id) ||\n      typeof source.filename != \"string\" || source.filename.length == 0 || source.content !== null && typeof source.content != \"string\" ||\n      source.language !== null && !isLanguage(source.language)) {\n      throw new TypeError(\"Malformed or duplicate SemantifoldMapping source.\")\n    }\n    sourceIds.add(source.id)\n  }\n  const sourceCoordinates = new Map(mapping.sources.filter((source) => source.content != null)\n    .map((source) => [source.id, createCoordinateIndex(/** @type {string} */ (source.content))]))\n  const sourcesById = new Map(mapping.sources.map((source) => [source.id, source]))\n  /** @type {Map<string, import(\"./semantic/types.js\").RegisteredSource[]>} */\n  const sourcesByFilename = new Map()\n\n  for (const source of mapping.sources) {\n    const sameName = sourcesByFilename.get(source.filename) ?? []\n\n    sameName.push(source)\n    sourcesByFilename.set(source.filename, sameName)\n  }\n  const generatedCoordinates = createCoordinateIndex(content)\n\n  const nodeIds = new Set()\n  const nodePaths = new Set()\n\n  for (const node of mapping.nodes) {\n    if (!node || typeof node != \"object\" || typeof node.id != \"string\" || node.id.length == 0 || nodeIds.has(node.id) ||\n      typeof node.path != \"string\" || nodePaths.has(node.path) ||\n      typeof node.kind != \"string\" || node.kind.length == 0 || !node.origin || typeof node.ranges != \"object\" ||\n      node.ranges === null || Array.isArray(node.ranges)) throw new TypeError(\"Malformed or duplicate semantic node identity.\")\n    nodeIds.add(node.id)\n    nodePaths.add(node.path)\n  }\n\n  const symbolIds = new Set()\n\n  for (const symbol of mapping.symbols) {\n    if (!symbol || typeof symbol != \"object\" || typeof symbol.id != \"string\" || symbol.id.length == 0 || symbolIds.has(symbol.id) ||\n      typeof symbol.name != \"string\" || symbol.name.length == 0 || ![\"function\", \"parameter\", \"local\"].includes(symbol.kind) ||\n      !nodeIds.has(symbol.declarationNodeId) || !Array.isArray(symbol.references)) {\n      throw new TypeError(\"Malformed or duplicate semantic symbol identity.\")\n    }\n    symbolIds.add(symbol.id)\n  }\n\n  for (const node of mapping.nodes) {\n    validateOrigin(node.origin, sourcesById, sourceCoordinates, nodeIds, symbolIds)\n    for (const [role, location] of Object.entries(node.ranges)) {\n      if (role.length == 0) throw new TypeError(\"Semantic node range roles must be non-empty strings.\")\n      validateLocationForSources(location, sourcesByFilename, sourceCoordinates)\n    }\n    if (node.symbolId !== undefined && (typeof node.symbolId != \"string\" || !symbolIds.has(node.symbolId))) {\n      throw new TypeError(\"Semantic node references an unknown symbol.\")\n    }\n  }\n\n  for (const symbol of mapping.symbols) {\n    validateLocationForSources(symbol.location, sourcesByFilename, sourceCoordinates)\n    for (const reference of symbol.references) {\n      if (!reference || typeof reference != \"object\" || !nodeIds.has(reference.nodeId) ||\n        ![\"declaration\", \"read\", \"write\", \"call\"].includes(reference.role)) {\n        throw new TypeError(\"Malformed semantic symbol reference.\")\n      }\n      validateLocationForSources(reference.location, sourcesByFilename, sourceCoordinates)\n    }\n  }\n\n  let previousEnd = 0\n\n  for (const span of spans) {\n    if (!span || typeof span != \"object\" || ![\"exact\", \"anchor\", \"synthetic\"].includes(Reflect.get(span, \"mappingKind\")) ||\n      !Reflect.get(span, \"generated\") || !Reflect.get(span, \"origin\")) {\n      throw new TypeError(\"Malformed SemantifoldMapping span.\")\n    }\n\n    const location = /** @type {import(\"./semantic/types.js\").SourceLocation} */ (Reflect.get(span, \"generated\"))\n\n    if (!location.start || !location.end || location.filename != filename || location.start.offset != previousEnd ||\n      location.end.offset <= location.start.offset || location.end.offset > content.length ||\n      !samePoint(indexedPointAt(generatedCoordinates, location.start.offset), location.start) ||\n      !samePoint(indexedPointAt(generatedCoordinates, location.end.offset), location.end)) {\n      throw new TypeError(\"SemantifoldMapping spans must exactly cover ordered normalized generated ranges.\")\n    }\n    validateOrigin(\n      /** @type {import(\"./semantic/types.js\").SemanticOrigin} */ (Reflect.get(span, \"origin\")),\n      sourcesById,\n      sourceCoordinates,\n      nodeIds,\n      symbolIds\n    )\n    const nodeId = Reflect.get(span, \"nodeId\")\n    const symbolId = Reflect.get(span, \"symbolId\")\n\n    if (nodeId !== undefined && (typeof nodeId != \"string\" || !nodeIds.has(nodeId))) throw new TypeError(\"Mapping span references an unknown node.\")\n    if (symbolId !== undefined && (typeof symbolId != \"string\" || !symbolIds.has(symbolId))) throw new TypeError(\"Mapping span references an unknown symbol.\")\n    if (Reflect.get(span, \"role\") !== undefined && typeof Reflect.get(span, \"role\") != \"string\" ||\n      Reflect.get(span, \"name\") !== undefined && typeof Reflect.get(span, \"name\") != \"string\") {\n      throw new TypeError(\"Mapping span roles and names must be strings.\")\n    }\n    previousEnd = location.end.offset\n  }\n\n  if (previousEnd != content.length) throw new TypeError(\"SemantifoldMapping spans must cover all generated content.\")\n}\n\n/**\n * Validates, freezes, and indexes one mapping produced at a trust boundary.\n * @param {unknown} value - Candidate mapping.\n * @returns {import(\"./semantic/types.js\").SemantifoldMapping} Immutable indexed mapping.\n */\nexport function finalizeMapping(value) {\n  // Producers may retain references to mutable semantic locations; mappings own their immutable copy.\n  const mapping = structuredClone(value)\n\n  validateMapping(mapping)\n  freezeJson(mapping)\n  mappingIndexes.set(mapping, buildMappingIndex(mapping))\n\n  return mapping\n}\n\n/**\n * Gets an index, validating mutable caller mappings on every trust-boundary use.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Mapping.\n * @returns {MappingIndex} Lookup index.\n */\nfunction mappingIndex(mapping) {\n  const cached = mappingIndexes.get(mapping)\n\n  if (cached) return cached\n\n  validateMapping(mapping)\n\n  return buildMappingIndex(mapping)\n}\n\n/**\n * Builds generated, original, node, and symbol indexes in one pass.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Validated mapping.\n * @returns {{generatedCoordinates: ReturnType<typeof createCoordinateIndex>, nodeSpans: Map<string, import(\"./semantic/types.js\").SemantifoldMappingSpan[]>, originalBySource: Map<string, {end: number, prefixEnd: number, span: import(\"./semantic/types.js\").SemantifoldMappingSpan, start: number}[]>, originalPointsBySource: Map<string, Map<number, import(\"./semantic/types.js\").SemantifoldMappingSpan[]>>, sourceCoordinates: Map<string, ReturnType<typeof createCoordinateIndex>>, sourcesById: Map<string, import(\"./semantic/types.js\").RegisteredSource>, symbolSpans: Map<string, import(\"./semantic/types.js\").SemantifoldMappingSpan[]>}} Mapping index.\n */\nfunction buildMappingIndex(mapping) {\n  const generatedCoordinates = createCoordinateIndex(mapping.generated.content)\n  const sourcesById = new Map(mapping.sources.map((source) => [source.id, source]))\n  const sourceCoordinates = new Map(mapping.sources.filter((source) => source.content != null)\n    .map((source) => [source.id, createCoordinateIndex(/** @type {string} */ (source.content))]))\n  const nodeSpans = new Map(mapping.nodes.map((node) => [node.id, /** @type {import(\"./semantic/types.js\").SemantifoldMappingSpan[]} */ ([])]))\n  const symbolSpans = new Map(mapping.symbols.map((symbol) => [symbol.id, /** @type {import(\"./semantic/types.js\").SemantifoldMappingSpan[]} */ ([])]))\n  /** @type {Map<string, {end: number, prefixEnd: number, span: import(\"./semantic/types.js\").SemantifoldMappingSpan, start: number}[]>} */\n  const originalBySource = new Map(mapping.sources.map((source) => [source.id, []]))\n  /** @type {Map<string, Map<number, import(\"./semantic/types.js\").SemantifoldMappingSpan[]>>} */\n  const originalPointsBySource = new Map(mapping.sources.map((source) => [source.id, new Map()]))\n\n  for (const span of mapping.spans) {\n    const spanNodeIds = new Set(span.nodeId ? [span.nodeId] : [])\n    const spanSymbolIds = new Set(span.symbolId ? [span.symbolId] : [])\n\n    for (const related of relatedOriginsForOrigin(span.origin)) {\n      if (related.nodeId) spanNodeIds.add(related.nodeId)\n      if (related.symbolId) spanSymbolIds.add(related.symbolId)\n      if (related.location.end.offset == related.location.start.offset) {\n        const points = originalPointsBySource.get(related.sourceId)\n        const pointSpans = points?.get(related.location.start.offset) ?? []\n\n        pointSpans.push(span)\n        points?.set(related.location.start.offset, pointSpans)\n        continue\n      }\n      originalBySource.get(related.sourceId)?.push({\n        end: related.location.end.offset,\n        prefixEnd: related.location.end.offset,\n        span,\n        start: related.location.start.offset\n      })\n    }\n    for (const nodeId of spanNodeIds) nodeSpans.get(nodeId)?.push(span)\n    for (const symbolId of spanSymbolIds) symbolSpans.get(symbolId)?.push(span)\n  }\n\n  for (const entries of originalBySource.values()) {\n    entries.sort((left, right) => left.start - right.start || left.span.generated.start.offset - right.span.generated.start.offset)\n    let prefixEnd = 0\n\n    for (const entry of entries) {\n      prefixEnd = Math.max(prefixEnd, entry.end)\n      entry.prefixEnd = prefixEnd\n    }\n  }\n\n  return {generatedCoordinates, nodeSpans, originalBySource, originalPointsBySource, sourceCoordinates, sourcesById, symbolSpans}\n}\n\n/**\n * Finds the generated span containing an offset by binary search.\n * @param {import(\"./semantic/types.js\").SemantifoldMappingSpan[]} spans - Ordered spans.\n * @param {number} offset - Generated offset.\n * @returns {import(\"./semantic/types.js\").SemantifoldMappingSpan | undefined} Containing span.\n */\nfunction spanForGenerated(spans, offset) {\n  let low = 0\n  let high = spans.length\n\n  while (low < high) {\n    const middle = Math.floor((low + high) / 2)\n\n    if (spans[middle].generated.start.offset <= offset) low = middle + 1\n    else high = middle\n  }\n  const candidate = spans[low - 1]\n\n  return candidate && offset < candidate.generated.end.offset ? candidate : undefined\n}\n\n/**\n * Finds ordered generated spans intersecting a half-open range.\n * @param {import(\"./semantic/types.js\").SemantifoldMappingSpan[]} spans - Ordered spans.\n * @param {number} start - Inclusive generated offset.\n * @param {number} end - Exclusive generated offset.\n * @returns {import(\"./semantic/types.js\").SemantifoldMappingSpan[]} Overlapping spans.\n */\nfunction spansOverlappingGenerated(spans, start, end) {\n  if (end <= start) {\n    const containing = spanForGenerated(spans, start)\n\n    return containing ? [containing] : []\n  }\n\n  let low = 0\n  let high = spans.length\n\n  while (low < high) {\n    const middle = Math.floor((low + high) / 2)\n\n    if (spans[middle].generated.end.offset <= start) low = middle + 1\n    else high = middle\n  }\n  const overlapping = []\n\n  for (let index = low; index < spans.length && spans[index].generated.start.offset < end; index++) {\n    overlapping.push(spans[index])\n  }\n\n  return overlapping\n}\n\n/**\n * Deep-freezes a JSON tree.\n * @param {unknown} value - JSON value.\n * @param {WeakSet<object>} [visited] - Cycle protection for rejected caller extras.\n * @returns {void}\n */\nfunction freezeJson(value, visited = new WeakSet()) {\n  if (!value || typeof value != \"object\" || visited.has(value)) return\n\n  visited.add(value)\n  for (const child of Object.values(value)) freezeJson(child, visited)\n  if (!Object.isFrozen(value)) Object.freeze(value)\n}\n\n/**\n * Validates one closed mapping origin.\n * @param {import(\"./semantic/types.js\").SemanticOrigin} origin - Origin.\n * @param {Map<string, import(\"./semantic/types.js\").RegisteredSource>} sourcesById - Sources by identity.\n * @param {Map<string, ReturnType<typeof createCoordinateIndex>>} coordinates - Source coordinate indexes.\n * @param {Set<unknown>} [nodeIds] - Known semantic nodes.\n * @param {Set<unknown>} [symbolIds] - Known semantic symbols.\n * @returns {void}\n */\nfunction validateOrigin(origin, sourcesById, coordinates, nodeIds, symbolIds) {\n  if (!origin || typeof origin != \"object\") throw new TypeError(\"Mapping origin must be a closed provenance value.\")\n\n  if (origin.kind == \"source\") {\n    validateRelated({location: origin.location, sourceId: origin.sourceId}, sourcesById, coordinates, nodeIds, symbolIds)\n    return\n  }\n  if (origin.kind == \"derived\") {\n    if (!Array.isArray(origin.origins) || origin.origins.length == 0) throw new TypeError(\"Derived provenance requires origins.\")\n    origin.origins.forEach((related) => validateRelated(related, sourcesById, coordinates, nodeIds, symbolIds))\n    return\n  }\n  if (origin.kind == \"synthetic\") {\n    if (typeof origin.reason != \"string\" || !Array.isArray(origin.relatedOrigins)) throw new TypeError(\"Malformed synthetic provenance.\")\n    origin.relatedOrigins.forEach((related) => validateRelated(related, sourcesById, coordinates, nodeIds, symbolIds))\n    return\n  }\n\n  throw new TypeError(\"Unknown provenance kind.\")\n}\n\n/**\n * Validates one source-related origin.\n * @param {import(\"./semantic/types.js\").RelatedOrigin} related - Related origin.\n * @param {Map<string, import(\"./semantic/types.js\").RegisteredSource>} sourcesById - Sources by identity.\n * @param {Map<string, ReturnType<typeof createCoordinateIndex>>} coordinates - Source coordinate indexes.\n * @param {Set<unknown> | undefined} nodeIds - Known semantic nodes.\n * @param {Set<unknown> | undefined} symbolIds - Known semantic symbols.\n * @returns {void}\n */\nfunction validateRelated(related, sourcesById, coordinates, nodeIds, symbolIds) {\n  const source = sourcesById.get(related.sourceId)\n\n  if (!source || !related.location || related.location.filename != source.filename ||\n    related.nodeId !== undefined && typeof related.nodeId != \"string\" ||\n    related.symbolId !== undefined && typeof related.symbolId != \"string\" ||\n    related.role !== undefined && typeof related.role != \"string\") throw new TypeError(\"Origin references an unknown source.\")\n  if (nodeIds && related.nodeId !== undefined && !nodeIds.has(related.nodeId)) throw new TypeError(\"Origin references an unknown node.\")\n  if (symbolIds && related.symbolId !== undefined && !symbolIds.has(related.symbolId)) {\n    throw new TypeError(\"Origin references an unknown symbol.\")\n  }\n  validateLocationForSource(related.location, source, coordinates.get(source.id))\n}\n\n/**\n * Validates a location against at least one same-filename source.\n * @param {unknown} value - Candidate location.\n * @param {Map<string, import(\"./semantic/types.js\").RegisteredSource[]>} sourcesByFilename - Sources by filename.\n * @param {Map<string, ReturnType<typeof createCoordinateIndex>>} coordinates - Source coordinate indexes.\n * @returns {void}\n */\nfunction validateLocationForSources(value, sourcesByFilename, coordinates) {\n  if (!value || typeof value != \"object\") throw new TypeError(\"Malformed original location.\")\n  const location = /** @type {import(\"./semantic/types.js\").SourceLocation} */ (value)\n  const candidates = sourcesByFilename.get(location.filename) ?? []\n\n  if (candidates.length == 0 || !candidates.some((source) => locationMatchesSource(location, source, coordinates.get(source.id)))) {\n    throw new TypeError(\"Stale original location.\")\n  }\n}\n\n/**\n * Validates a location against its identified source.\n * @param {unknown} value - Candidate location.\n * @param {import(\"./semantic/types.js\").RegisteredSource} source - Source.\n * @param {ReturnType<typeof createCoordinateIndex> | undefined} coordinates - Source coordinates when content exists.\n * @returns {void}\n */\nfunction validateLocationForSource(value, source, coordinates) {\n  if (!value || typeof value != \"object\" || !locationMatchesSource(\n    /** @type {import(\"./semantic/types.js\").SourceLocation} */ (value), source, coordinates\n  )) throw new TypeError(\"Stale original location.\")\n}\n\n/**\n * Tests a location against one source entry.\n * @param {import(\"./semantic/types.js\").SourceLocation} location - Location.\n * @param {import(\"./semantic/types.js\").RegisteredSource} source - Source.\n * @param {ReturnType<typeof createCoordinateIndex> | undefined} coordinates - Source coordinates when content exists.\n * @returns {boolean} Whether the range is normalized for the source.\n */\nfunction locationMatchesSource(location, source, coordinates) {\n  if (!location || location.filename != source.filename || !location.start || !location.end ||\n    !validPoint(location.start) || !validPoint(location.end) || location.end.offset < location.start.offset) return false\n\n  if (source.content == null) return true\n\n  return location.end.offset <= source.content.length && coordinates !== undefined &&\n    samePoint(indexedPointAt(coordinates, location.start.offset), location.start) &&\n    samePoint(indexedPointAt(coordinates, location.end.offset), location.end)\n}\n\n/**\n * Tests the structural validity of one source point.\n * @param {unknown} value - Candidate point.\n * @returns {value is import(\"./semantic/types.js\").SourcePoint} Whether it is a point.\n */\nfunction validPoint(value) {\n  if (!value || typeof value != \"object\") return false\n  const point = /** @type {Record<string, unknown>} */ (value)\n\n  return Number.isInteger(point.offset) && Number.isInteger(point.line) && Number.isInteger(point.column) &&\n    /** @type {number} */ (point.offset) >= 0 && /** @type {number} */ (point.line) >= 1 && /** @type {number} */ (point.column) >= 1\n}\n\n/**\n * Tests a supported semantic language value.\n * @param {unknown} value - Candidate language.\n * @returns {value is import(\"./semantic/types.js\").SemanticLanguage} Whether supported.\n */\nfunction isLanguage(value) {\n  return value == \"php\" || value == \"ruby\" || value == \"javascript\" || value == \"typescript\" || value == \"java\"\n}\n\n/**\n * Builds one stable lookup result.\n * @param {import(\"./semantic/types.js\").SemantifoldMappingSpan} span - Mapping span.\n * @returns {{generatedLocation: import(\"./semantic/types.js\").SourceLocation, location: import(\"./semantic/types.js\").SourceLocation | undefined, mappingKind: import(\"./semantic/types.js\").MappingKind, name: string | undefined, nodeId: string | undefined, role: string | undefined, symbolId: string | undefined}} Lookup result.\n */\nfunction mappingResult(span) {\n  return {\n    generatedLocation: span.generated,\n    location: primaryLocation(span.origin),\n    mappingKind: span.mappingKind,\n    name: span.name,\n    nodeId: span.nodeId,\n    role: span.role,\n    symbolId: span.symbolId\n  }\n}\n\n/**\n * Resolves an offset-form or line/column-form position.\n * @param {ReturnType<typeof createCoordinateIndex>} coordinates - Source coordinate index.\n * @param {{offset: number} | {line: number, column: number}} position - Position.\n * @returns {number} UTF-16 offset.\n */\nfunction positionOffset(coordinates, position) {\n  if (\"offset\" in position) {\n    indexedPointAt(coordinates, position.offset)\n\n    return position.offset\n  }\n\n  return indexedOffsetAt(coordinates, position.line, position.column)\n}\n\n/**\n * Finds the exclusive content offset before the next generated line break.\n * @param {string} content - Generated content.\n * @param {number} offset - Offset on the current line.\n * @returns {number} End of the current line or content.\n */\nfunction lineEndOffset(content, offset) {\n  const newline = content.indexOf(\"\\n\", offset)\n\n  return newline == -1 ? content.length : newline\n}\n\n/**\n * Compares complete normalized points.\n * @param {import(\"./semantic/types.js\").SourcePoint} left - Left point.\n * @param {import(\"./semantic/types.js\").SourcePoint} right - Right point.\n * @returns {boolean} Whether coordinates match.\n */\nfunction samePoint(left, right) {\n  return left.offset == right.offset && left.line == right.line && left.column == right.column\n}\n\n/**\n * Resolves a source registry entry for an origin.\n * @param {import(\"./semantic/types.js\").SemantifoldMapping} mapping - Mapping.\n * @param {import(\"./semantic/types.js\").SemanticOrigin} origin - Origin.\n * @param {import(\"./semantic/types.js\").SourceLocation} location - Primary location.\n * @param {Map<string, import(\"./semantic/types.js\").RegisteredSource>} sourcesById - Indexed sources.\n * @returns {import(\"./semantic/types.js\").RegisteredSource} Registered source.\n */\nfunction sourceForOrigin(mapping, origin, location, sourcesById) {\n  const sourceId = sourceIdForOrigin(origin)\n  const source = sourcesById.get(sourceId ?? \"\") ??\n    mapping.sources.find((candidate) => candidate.filename == location.filename)\n\n  if (!source) throw new RangeError(`Unknown mapping source for ${location.filename}.`)\n\n  return source\n}\n\n/**\n * Resolves the registry identity of an origin's primary location.\n * @param {import(\"./semantic/types.js\").SemanticOrigin} origin - Origin.\n * @returns {string | undefined} Source identity.\n */\nfunction sourceIdForOrigin(origin) {\n  if (origin.kind == \"source\") return origin.sourceId\n  if (origin.kind == \"derived\") return origin.origins[0]?.sourceId\n\n  return origin.relatedOrigins[0]?.sourceId\n}\n\n/**\n * Rewrites closed-origin source identities against a composed registry.\n * @param {import(\"./semantic/types.js\").SemanticOrigin} origin - Origin.\n * @param {Map<string, string>} sourceIds - Original-to-composed source identities.\n * @returns {import(\"./semantic/types.js\").SemanticOrigin} Rewritten origin.\n */\nfunction remapOriginSourceIds(origin, sourceIds) {\n  if (origin.kind == \"source\") {\n    const sourceId = sourceIds.get(origin.sourceId)\n\n    if (!sourceId) throw new RangeError(`Composed mapping omitted source '${origin.location.filename}'.`)\n\n    return {kind: \"source\", location: origin.location, sourceId}\n  }\n  if (origin.kind == \"derived\") return {kind: \"derived\", origins: origin.origins.map((related) => remapRelatedOriginSourceId(related, sourceIds))}\n\n  return {\n    kind: \"synthetic\",\n    reason: origin.reason,\n    relatedOrigins: origin.relatedOrigins.map((related) => remapRelatedOriginSourceId(related, sourceIds))\n  }\n}\n\n/**\n * Rewrites one related source identity while dropping identities from a discarded node registry.\n * @param {import(\"./semantic/types.js\").RelatedOrigin} related - Related origin.\n * @param {Map<string, string>} sourceIds - Original-to-composed source identities.\n * @returns {import(\"./semantic/types.js\").RelatedOrigin} Rewritten related origin.\n */\nfunction remapRelatedOriginSourceId(related, sourceIds) {\n  const sourceId = sourceIds.get(related.sourceId)\n\n  if (!sourceId) throw new RangeError(`Composed mapping omitted source '${related.location.filename}'.`)\n\n  const unidentified = {...related}\n\n  delete unidentified.nodeId\n  delete unidentified.symbolId\n\n  return {...unidentified, sourceId}\n}\n\n/**\n * Sorts object keys recursively while preserving semantic array order.\n * @param {unknown} value - JSON value.\n * @returns {unknown} Deterministically keyed value.\n */\nfunction sortJson(value) {\n  if (Array.isArray(value)) return value.map(sortJson)\n  if (value && typeof value == \"object\") {\n    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0)\n      .map(([key, child]) => [key, sortJson(child)]))\n  }\n\n  return value\n}\n\n/**\n * Removes undefined optional properties from a public JSON value.\n * @template {Record<string, unknown>} Value\n * @param {Value} value - Candidate object.\n * @returns {Value} Compact JSON-safe object.\n */\nfunction definedProperties(value) {\n  return /** @type {Value} */ (Object.fromEntries(Object.entries(value).filter(([, child]) => child !== undefined)))\n}\n"]}