semantifold 0.1.0

package/build/src/semantic/provenance.js

@@ -0,0 +1,577 @@
+// @ts-check
+import { createCoordinateIndex, indexedPointAt } from "./location.js";
+/** @type {WeakMap<object, Readonly<Record<string, import("./types.js").SourceLocation>>>} */
+const parserRanges = new WeakMap();
+/** @type {WeakMap<import("./types.js").RegisteredSource, ReturnType<typeof createCoordinateIndex>>} */
+const sourceCoordinateIndexes = new WeakMap();
+/**
+ * Records parser-provided semantic-token ranges without exposing parser trees.
+ * @param {object} node - Semantic node.
+ * @param {Readonly<Record<string, import("./types.js").SourceLocation>>} ranges - Exact role ranges.
+ * @returns {void}
+ */
+export function setParserRanges(node, ranges) {
+    parserRanges.set(node, ranges);
+}
+/**
+ * Records parser ranges and returns the same semantic node.
+ * @template {object} Node
+ * @param {Node} node - Semantic node.
+ * @param {Readonly<Record<string, import("./types.js").SourceLocation>>} ranges - Exact role ranges.
+ * @returns {Node} The same node.
+ */
+export function withParserRanges(node, ranges) {
+    setParserRanges(node, ranges);
+    return node;
+}
+/**
+ * Adds deterministic provenance to a validated frontend module.
+ * @param {import("./types.js").SemanticModule} module - Validated semantic module.
+ * @param {object} source - Parsed source.
+ * @param {string} source.filename - Source filename.
+ * @param {import("./types.js").SemanticLanguage} source.language - Source language.
+ * @param {string} source.source - Exact source content.
+ * @returns {import("./types.js").SemanticModule} The same semantic module.
+ */
+export function annotateParsedModule(module, { filename, language, source }) {
+    const sources = [{ content: source, filename, id: "source:0", language }];
+    const entries = semanticEntries(module);
+    /** @type {Map<string, import("./types.js").SemanticNodeProvenance>} */
+    const recordsByPath = new Map();
+    /** @type {import("./types.js").SemanticNodeProvenance[]} */
+    const records = [];
+    for (const [index, entry] of entries.entries()) {
+        const ranges = parserRanges.get(entry.node) ?? {};
+        const location = "location" in entry.node ? entry.node.location : ranges.type ?? entry.ownerLocation;
+        const sourceProvenance = /** @type {import("./types.js").SemanticNodeSourceProvenance} */ ({
+            origin: { kind: "source", location, sourceId: "source:0" },
+            ranges,
+            schema: "SemantifoldNodeProvenance",
+            version: 1
+        });
+        const record = {
+            id: `node:${index}`,
+            kind: entry.node.kind,
+            origin: sourceProvenance.origin,
+            path: entry.path,
+            ranges: sourceProvenance.ranges
+        };
+        records.push(record);
+        recordsByPath.set(entry.path, record);
+        entry.node.sourceProvenance = sourceProvenance;
+    }
+    const symbols = resolveSymbols(module, recordsByPath);
+    module.provenance = {
+        coordinateSystem: "utf16",
+        nodes: records,
+        schema: "SemantifoldProvenance",
+        sources,
+        symbols,
+        version: 1
+    };
+    return module;
+}
+/**
+ * Rebuilds canonical generation metadata without trusting caller-provided identities.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {{filename: string, content: string, language?: import("./types.js").SemanticLanguage}[]} [providedSources] - Additional source content.
+ * @returns {{provenance: import("./types.js").SemanticProvenance, recordFor: (node: import("./types.js").SemanticNode, path?: string) => import("./types.js").SemanticNodeProvenance}} Canonical index.
+ */
+export function createGenerationIndex(module, providedSources = []) {
+    const entries = semanticEntries(module);
+    const priorSources = usableSourceProvenance(module.provenance);
+    /** @type {import("./types.js").RegisteredSource[]} */
+    const sources = [];
+    /** @type {Map<string, import("./types.js").RegisteredSource>} */
+    const priorSourcesById = new Map();
+    for (const source of providedSources)
+        addSource(source.filename, source.content, source.language ?? null);
+    if (priorSources) {
+        for (const source of priorSources.sources) {
+            const canonical = addSource(source.filename, source.content, source.language);
+            priorSourcesById.set(source.id, canonical);
+        }
+    }
+    for (const entry of entries) {
+        const location = "location" in entry.node ? entry.node.location : entry.ownerLocation;
+        if (!sources.some((source) => source.filename == location.filename))
+            addSource(location.filename, null, null);
+    }
+    const verifiableSources = sources.filter((source) => source.content != null);
+    /** @type {Map<object, import("./types.js").SemanticNodeProvenance[]>} */
+    const recordsByNode = new Map();
+    /** @type {Map<string, import("./types.js").SemanticNodeProvenance>} */
+    const recordsByPath = new Map();
+    /** @type {import("./types.js").SemanticNodeProvenance[]} */
+    const records = [];
+    for (const [index, entry] of entries.entries()) {
+        const located = "location" in entry.node ? entry.node.location : entry.ownerLocation;
+        const associated = usableNodeProvenance(entry.node.sourceProvenance);
+        const ranges = associated ? validRanges(associated.ranges, verifiableSources) : {};
+        const normalizedOrigin = associated
+            ? normalizeOrigin(associated.origin, priorSourcesById, verifiableSources)
+            : undefined;
+        const fallbackSource = sourceForLocation(located, sources);
+        const origin = normalizedOrigin ?? sourceOrigin(fallbackSource, located);
+        const record = {
+            id: `node:${index}`,
+            kind: entry.node.kind,
+            origin,
+            path: entry.path,
+            ranges
+        };
+        records.push(record);
+        recordsByPath.set(entry.path, record);
+        const occurrences = recordsByNode.get(entry.node) ?? [];
+        occurrences.push(record);
+        recordsByNode.set(entry.node, occurrences);
+    }
+    const symbols = resolveSymbols(module, recordsByPath);
+    const provenance = /** @type {import("./types.js").SemanticProvenance} */ ({
+        coordinateSystem: "utf16",
+        nodes: records,
+        schema: "SemantifoldProvenance",
+        sources,
+        symbols,
+        version: 1
+    });
+    return {
+        provenance,
+        recordFor(node, path) {
+            const occurrences = recordsByNode.get(node);
+            if (!occurrences)
+                throw new RangeError("Semantic node is not part of this module.");
+            if (path !== undefined) {
+                const record = occurrences.find((candidate) => candidate.path == path);
+                if (!record)
+                    throw new RangeError(`Semantic node does not occur at '${path}'.`);
+                return record;
+            }
+            if (occurrences.length != 1) {
+                throw new RangeError("Shared semantic node requires an occurrence path.");
+            }
+            return occurrences[0];
+        }
+    };
+    /**
+     * Registers one canonical source.
+     * @param {string} filename - Source filename.
+     * @param {string | null} content - Source content.
+     * @param {import("./types.js").SemanticLanguage | null} language - Source language.
+     * @returns {import("./types.js").RegisteredSource} Canonical source.
+     */
+    function addSource(filename, content, language) {
+        if (typeof filename != "string" || content !== null && typeof content != "string" ||
+            language !== null && !["php", "ruby", "javascript", "typescript", "java"].includes(language)) {
+            throw new TypeError("Malformed semantic source registry entry.");
+        }
+        const existing = sources.find((source) => source.filename == filename && source.content == content);
+        if (existing)
+            return existing;
+        const registered = { content, filename, id: `source:${sources.length}`, language };
+        sources.push(registered);
+        return registered;
+    }
+}
+/**
+ * Selects the safe primary original location for closed provenance.
+ * @param {import("./types.js").SemanticOrigin} origin - Closed provenance.
+ * @returns {import("./types.js").SourceLocation | undefined} Primary location.
+ */
+export function primaryLocation(origin) {
+    if (origin.kind == "source")
+        return origin.location;
+    if (origin.kind == "derived")
+        return origin.origins[0]?.location;
+    return origin.relatedOrigins[0]?.location;
+}
+/**
+ * Accepts source metadata only when it is attached to the semantic node it describes.
+ * Registry-local IDs and paths are intentionally ignored and rebuilt.
+ * @param {import("./types.js").SemanticNodeSourceProvenance | undefined} record - Candidate node association.
+ * @returns {import("./types.js").SemanticNodeSourceProvenance | undefined} Usable association.
+ */
+function usableNodeProvenance(record) {
+    if (!record || record.schema != "SemantifoldNodeProvenance" || record.version != 1 ||
+        !record.origin || typeof record.origin != "object" ||
+        !record.ranges || typeof record.ranges != "object" || Array.isArray(record.ranges))
+        return undefined;
+    return record;
+}
+/**
+ * Retains a valid source registry independently from potentially stale node metadata.
+ * @param {import("./types.js").SemanticProvenance | undefined} provenance - Candidate provenance.
+ * @returns {import("./types.js").SemanticProvenance | undefined} Provenance with a usable source registry.
+ */
+function usableSourceProvenance(provenance) {
+    if (!provenance || provenance.schema != "SemantifoldProvenance" || provenance.version != 1 ||
+        provenance.coordinateSystem != "utf16" || !Array.isArray(provenance.sources))
+        return undefined;
+    const sourceIds = new Set();
+    for (const source of provenance.sources) {
+        if (!source || typeof source.id != "string" || sourceIds.has(source.id) || typeof source.filename != "string" ||
+            source.filename.length == 0 ||
+            source.content !== null && typeof source.content != "string" || source.language !== null &&
+            !["php", "ruby", "javascript", "typescript", "java"].includes(source.language))
+            return undefined;
+        sourceIds.add(source.id);
+    }
+    return provenance;
+}
+/**
+ * Retains only self-consistent source ranges.
+ * @param {Readonly<Record<string, import("./types.js").SourceLocation>>} ranges - Candidate ranges.
+ * @param {import("./types.js").RegisteredSource[]} sources - Canonical sources.
+ * @returns {Readonly<Record<string, import("./types.js").SourceLocation>>} Safe ranges.
+ */
+function validRanges(ranges, sources) {
+    if (!ranges || typeof ranges != "object" || Array.isArray(ranges))
+        return {};
+    /** @type {Record<string, import("./types.js").SourceLocation>} */
+    const valid = {};
+    for (const [role, location] of Object.entries(ranges)) {
+        if (validLocation(location, sources))
+            valid[role] = location;
+    }
+    return valid;
+}
+/**
+ * Normalizes a closed origin while remapping untrusted source identities.
+ * @param {import("./types.js").SemanticOrigin} origin - Candidate origin.
+ * @param {Map<string, import("./types.js").RegisteredSource>} priorSources - Prior-to-canonical source mapping.
+ * @param {import("./types.js").RegisteredSource[]} sources - Canonical sources.
+ * @returns {import("./types.js").SemanticOrigin | undefined} Safe origin.
+ */
+function normalizeOrigin(origin, priorSources, sources) {
+    if (!origin || typeof origin != "object")
+        return undefined;
+    if (origin.kind == "source" && validLocation(origin.location, sources)) {
+        const claimed = priorSources.get(origin.sourceId);
+        const source = claimed && sourceOwnsLocation(claimed, origin.location) ? claimed : sourceForLocation(origin.location, sources);
+        return sourceOrigin(source, origin.location);
+    }
+    if (origin.kind == "derived" && Array.isArray(origin.origins) && origin.origins.length > 0) {
+        const origins = origin.origins.map((related) => normalizeRelatedOrigin(related, priorSources, sources));
+        if (origins.every(Boolean))
+            return { kind: "derived", origins: /** @type {import("./types.js").RelatedOrigin[]} */ (origins) };
+    }
+    if (origin.kind == "synthetic" && typeof origin.reason == "string" && Array.isArray(origin.relatedOrigins)) {
+        const relatedOrigins = origin.relatedOrigins.map((related) => normalizeRelatedOrigin(related, priorSources, sources));
+        if (relatedOrigins.every(Boolean)) {
+            return { kind: "synthetic", reason: origin.reason, relatedOrigins: /** @type {import("./types.js").RelatedOrigin[]} */ (relatedOrigins) };
+        }
+    }
+    return undefined;
+}
+/**
+ * Normalizes one related origin.
+ * @param {import("./types.js").RelatedOrigin} related - Candidate related origin.
+ * @param {Map<string, import("./types.js").RegisteredSource>} priorSources - Prior sources.
+ * @param {import("./types.js").RegisteredSource[]} sources - Canonical sources.
+ * @returns {import("./types.js").RelatedOrigin | undefined} Safe related origin.
+ */
+function normalizeRelatedOrigin(related, priorSources, sources) {
+    if (!related || !validLocation(related.location, sources))
+        return undefined;
+    const claimed = priorSources.get(related.sourceId);
+    const source = claimed && sourceOwnsLocation(claimed, related.location) ? claimed : sourceForLocation(related.location, sources);
+    const normalized = { location: related.location, sourceId: source.id };
+    if (typeof related.role == "string")
+        Object.assign(normalized, { role: related.role });
+    return normalized;
+}
+/**
+ * Checks normalized coordinates against exact source content when available.
+ * @param {import("./types.js").SourceLocation} location - Candidate location.
+ * @param {import("./types.js").RegisteredSource[]} sources - Registered sources.
+ * @returns {boolean} Whether the location is safe.
+ */
+function validLocation(location, sources) {
+    if (!location || typeof location.filename != "string" || !location.start || !location.end ||
+        !Number.isInteger(location.start.offset) || !Number.isInteger(location.end.offset) || location.start.offset < 0 ||
+        location.end.offset < location.start.offset || !validPointShape(location.start) || !validPointShape(location.end))
+        return false;
+    const candidates = sources.filter((source) => source.filename == location.filename);
+    return candidates.some((source) => sourceOwnsLocation(source, location));
+}
+/**
+ * Checks that one identified registry source owns a normalized location.
+ * @param {import("./types.js").RegisteredSource} source - Identified source.
+ * @param {import("./types.js").SourceLocation} location - Candidate location.
+ * @returns {boolean} Whether the source owns the location.
+ */
+function sourceOwnsLocation(source, location) {
+    if (source.filename != location.filename)
+        return false;
+    if (source.content == null)
+        return true;
+    if (location.end.offset > source.content.length)
+        return false;
+    let coordinates = sourceCoordinateIndexes.get(source);
+    if (!coordinates) {
+        coordinates = createCoordinateIndex(source.content);
+        sourceCoordinateIndexes.set(source, coordinates);
+    }
+    return samePoint(indexedPointAt(coordinates, location.start.offset), location.start) &&
+        samePoint(indexedPointAt(coordinates, location.end.offset), location.end);
+}
+/**
+ * Checks the integer shape of one source point.
+ * @param {import("./types.js").SourcePoint} point - Source point.
+ * @returns {boolean} Whether it is structurally valid.
+ */
+function validPointShape(point) {
+    return Number.isInteger(point.line) && point.line >= 1 && Number.isInteger(point.column) && point.column >= 1;
+}
+/**
+ * Compares normalized source coordinates.
+ * @param {import("./types.js").SourcePoint} left - Left point.
+ * @param {import("./types.js").SourcePoint} right - Right point.
+ * @returns {boolean} Whether all coordinates match.
+ */
+function samePoint(left, right) {
+    return left.offset == right.offset && left.line == right.line && left.column == right.column;
+}
+/**
+ * Finds the deterministic source owning a location.
+ * @param {import("./types.js").SourceLocation} location - Source location.
+ * @param {import("./types.js").RegisteredSource[]} sources - Canonical sources.
+ * @returns {import("./types.js").RegisteredSource} Owning source.
+ */
+function sourceForLocation(location, sources) {
+    const source = sources.find((candidate) => sourceOwnsLocation(candidate, location));
+    if (!source)
+        throw new RangeError(`No registered source owns ${location.filename}:${location.start.offset}.`);
+    return source;
+}
+/**
+ * Creates direct source provenance.
+ * @param {import("./types.js").RegisteredSource} source - Source.
+ * @param {import("./types.js").SourceLocation} location - Location.
+ * @returns {import("./types.js").SourceOrigin} Origin.
+ */
+function sourceOrigin(source, location) {
+    return { kind: "source", location, sourceId: source.id };
+}
+/**
+ * Finds one node provenance record by semantic object or node identity.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {import("./types.js").SemanticNode | string} node - Semantic object or node identity.
+ * @returns {import("./types.js").SemanticNodeProvenance} Provenance record.
+ */
+export function getNodeProvenance(module, node) {
+    requireProvenance(module);
+    const index = createGenerationIndex(module);
+    const record = typeof node == "string"
+        ? index.provenance.nodes.find((candidate) => candidate.id == node)
+        : index.recordFor(node);
+    if (!record)
+        throw new RangeError(`Unknown semantic node: ${node}`);
+    return record;
+}
+/**
+ * Finds one semantic symbol record.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {string} symbolId - Symbol identity.
+ * @returns {import("./types.js").SemanticSymbolProvenance} Symbol record.
+ */
+export function getSymbolProvenance(module, symbolId) {
+    requireProvenance(module);
+    const symbol = createGenerationIndex(module).provenance.symbols.find((candidate) => candidate.id == symbolId);
+    if (!symbol)
+        throw new RangeError(`Unknown semantic symbol: ${symbolId}`);
+    return symbol;
+}
+/**
+ * Requires frontend provenance.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @returns {import("./types.js").SemanticProvenance} Provenance.
+ */
+function requireProvenance(module) {
+    if (!module.provenance)
+        throw new TypeError("Semantic module does not contain source provenance.");
+    return module.provenance;
+}
+/**
+ * Traverses public semantic nodes in one stable order.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @returns {{node: import("./types.js").SemanticNode, ownerLocation: import("./types.js").SourceLocation, path: string}[]} Entries.
+ */
+export function semanticEntries(module) {
+    /** @type {{node: import("./types.js").SemanticNode, ownerLocation: import("./types.js").SourceLocation, path: string}[]} */
+    const entries = [];
+    visit(module, "", module.location);
+    return entries;
+    /**
+     * Visits one semantic node and its children.
+     * @param {import("./types.js").SemanticNode} node - Current node.
+     * @param {string} path - Current JSON Pointer.
+     * @param {import("./types.js").SourceLocation} ownerLocation - Nearest located owner.
+     * @returns {void}
+     */
+    function visit(node, path, ownerLocation) {
+        const location = "location" in node ? node.location : ownerLocation;
+        entries.push({ node, ownerLocation: location, path });
+        if (node.kind == "Module") {
+            node.functions.forEach((child, index) => visit(child, `/functions/${index}`, location));
+            visit(node.entryPoint, "/entryPoint", location);
+        }
+        else if (node.kind == "FunctionDeclaration") {
+            node.parameters.forEach((child, index) => visit(child, `${path}/parameters/${index}`, location));
+            visit(node.returnType, `${path}/returnType`, location);
+            visit(node.body, `${path}/body`, location);
+        }
+        else if (node.kind == "Block") {
+            node.statements.forEach((child, index) => visit(child, `${path}/statements/${index}`, location));
+        }
+        else if (node.kind == "Parameter") {
+            visit(node.type, `${path}/type`, location);
+        }
+        else if (node.kind == "LocalDeclaration") {
+            visit(node.type, `${path}/type`, location);
+            visit(node.initializer, `${path}/initializer`, location);
+        }
+        else if (node.kind == "AssignmentStatement") {
+            visit(node.target, `${path}/target`, location);
+            visit(node.expression, `${path}/expression`, location);
+        }
+        else if (node.kind == "ReturnStatement" || node.kind == "PrintStatement") {
+            visit(node.expression, `${path}/expression`, location);
+        }
+        else if (node.kind == "IfStatement") {
+            visit(node.condition, `${path}/condition`, location);
+            visit(node.consequent, `${path}/consequent`, location);
+            if (node.alternate)
+                visit(node.alternate, `${path}/alternate`, location);
+        }
+        else if (node.kind == "EntryPoint") {
+            visit(node.body, `${path}/body`, location);
+        }
+        else if (node.kind == "UnaryExpression") {
+            visit(node.operand, `${path}/operand`, location);
+        }
+        else if (node.kind == "BinaryExpression") {
+            visit(node.left, `${path}/left`, location);
+            visit(node.right, `${path}/right`, location);
+        }
+        else if (node.kind == "CallExpression") {
+            node.arguments.forEach((child, index) => visit(child, `${path}/arguments/${index}`, location));
+        }
+    }
+}
+/**
+ * Resolves declarations and references after semantic validation.
+ * @param {import("./types.js").SemanticModule} module - Validated module.
+ * @param {Map<string, import("./types.js").SemanticNodeProvenance>} records - Node records by occurrence path.
+ * @returns {import("./types.js").SemanticSymbolProvenance[]} Symbols.
+ */
+function resolveSymbols(module, records) {
+    /** @type {import("./types.js").SemanticSymbolProvenance[]} */
+    const symbols = [];
+    /** @type {Map<string, string>} */
+    const functions = new Map();
+    for (const [index, declaration] of module.functions.entries()) {
+        functions.set(declaration.name, declare(declaration, declaration.name, "function", `/functions/${index}`));
+    }
+    for (const [index, declaration] of module.functions.entries()) {
+        const declarationPath = `/functions/${index}`;
+        const scope = new Map();
+        for (const [parameterIndex, parameter] of declaration.parameters.entries()) {
+            scope.set(parameter.name, declare(parameter, parameter.name, "parameter", `${declarationPath}/parameters/${parameterIndex}`));
+        }
+        visitBlock(declaration.body, scope, `${declarationPath}/body`);
+    }
+    visitBlock(module.entryPoint.body, new Map(), "/entryPoint/body");
+    return symbols;
+    /**
+     * Declares one canonical symbol.
+     * @param {import("./types.js").FunctionDeclaration | import("./types.js").Parameter | import("./types.js").LocalDeclaration} node - Declaration.
+     * @param {string} name - Symbol name.
+     * @param {import("./types.js").SemanticSymbolKind} kind - Symbol kind.
+     * @param {string} path - Declaration occurrence path.
+     * @returns {string} Symbol identity.
+     */
+    function declare(node, name, kind, path) {
+        const record = records.get(path);
+        if (!record)
+            throw new Error(`Missing provenance for ${node.kind}.`);
+        const location = record.ranges.name ?? node.location;
+        const id = `symbol:${symbols.length}`;
+        record.symbolId = id;
+        symbols.push({ declarationNodeId: record.id, id, kind, location, name, references: [] });
+        return id;
+    }
+    /**
+     * Resolves references in one lexical block.
+     * @param {import("./types.js").Block} block - Semantic block.
+     * @param {Map<string, string>} parent - Visible bindings.
+     * @param {string} path - Statement sequence path.
+     * @returns {void}
+     */
+    function visitBlock(block, parent, path) {
+        const scope = new Map(parent);
+        for (const [index, statement] of block.statements.entries()) {
+            const statementPath = `${path}/statements/${index}`;
+            if (statement.kind == "LocalDeclaration") {
+                visitExpression(statement.initializer, scope, `${statementPath}/initializer`);
+                scope.set(statement.name, declare(statement, statement.name, "local", statementPath));
+            }
+            else if (statement.kind == "AssignmentStatement") {
+                reference(statement.target, scope.get(statement.target.name), "write", `${statementPath}/target`);
+                visitExpression(statement.expression, scope, `${statementPath}/expression`);
+            }
+            else if (statement.kind == "ReturnStatement" || statement.kind == "PrintStatement") {
+                visitExpression(statement.expression, scope, `${statementPath}/expression`);
+            }
+            else if (statement.kind == "IfStatement") {
+                visitExpression(statement.condition, scope, `${statementPath}/condition`);
+                visitBlock(statement.consequent, scope, `${statementPath}/consequent`);
+                if (statement.alternate)
+                    visitBlock(statement.alternate, scope, `${statementPath}/alternate`);
+            }
+        }
+    }
+    /**
+     * Resolves references in one expression.
+     * @param {import("./types.js").Expression} expression - Expression.
+     * @param {Map<string, string>} scope - Visible bindings.
+     * @param {string} path - Expression occurrence path.
+     * @returns {void}
+     */
+    function visitExpression(expression, scope, path) {
+        if (expression.kind == "IdentifierExpression")
+            reference(expression, scope.get(expression.name), "read", path);
+        else if (expression.kind == "CallExpression") {
+            reference(expression, functions.get(expression.callee), "call", path);
+            for (const [index, argument] of expression.arguments.entries())
+                visitExpression(argument, scope, `${path}/arguments/${index}`);
+        }
+        else if (expression.kind == "UnaryExpression") {
+            visitExpression(expression.operand, scope, `${path}/operand`);
+        }
+        else if (expression.kind == "BinaryExpression") {
+            visitExpression(expression.left, scope, `${path}/left`);
+            visitExpression(expression.right, scope, `${path}/right`);
+        }
+    }
+    /**
+     * Attaches one resolved symbol reference.
+     * @param {import("./types.js").IdentifierExpression | import("./types.js").CallExpression} node - Reference node.
+     * @param {string | undefined} symbolId - Resolved symbol.
+     * @param {"read" | "write" | "call"} role - Reference role.
+     * @param {string} path - Reference occurrence path.
+     * @returns {void}
+     */
+    function reference(node, symbolId, role, path) {
+        if (!symbolId)
+            return;
+        const record = records.get(path);
+        const symbol = symbols.find((candidate) => candidate.id == symbolId);
+        if (!record || !symbol)
+            throw new Error(`Missing provenance while resolving ${node.kind}.`);
+        const location = record.ranges[role == "call" ? "callee" : "name"] ?? node.location;
+        record.symbolId = symbolId;
+        symbol.references.push({ location, nodeId: record.id, role });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provenance.js","sourceRoot":"","sources":["../../../src/semantic/provenance.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createCoordinateIndex, indexedPointAt} from \"./location.js\"\n\n/** @type {WeakMap<object, Readonly<Record<string, import(\"./types.js\").SourceLocation>>>} */\nconst parserRanges = new WeakMap()\n/** @type {WeakMap<import(\"./types.js\").RegisteredSource, ReturnType<typeof createCoordinateIndex>>} */\nconst sourceCoordinateIndexes = new WeakMap()\n\n/**\n * Records parser-provided semantic-token ranges without exposing parser trees.\n * @param {object} node - Semantic node.\n * @param {Readonly<Record<string, import(\"./types.js\").SourceLocation>>} ranges - Exact role ranges.\n * @returns {void}\n */\nexport function setParserRanges(node, ranges) {\n  parserRanges.set(node, ranges)\n}\n\n/**\n * Records parser ranges and returns the same semantic node.\n * @template {object} Node\n * @param {Node} node - Semantic node.\n * @param {Readonly<Record<string, import(\"./types.js\").SourceLocation>>} ranges - Exact role ranges.\n * @returns {Node} The same node.\n */\nexport function withParserRanges(node, ranges) {\n  setParserRanges(node, ranges)\n\n  return node\n}\n\n/**\n * Adds deterministic provenance to a validated frontend module.\n * @param {import(\"./types.js\").SemanticModule} module - Validated semantic module.\n * @param {object} source - Parsed source.\n * @param {string} source.filename - Source filename.\n * @param {import(\"./types.js\").SemanticLanguage} source.language - Source language.\n * @param {string} source.source - Exact source content.\n * @returns {import(\"./types.js\").SemanticModule} The same semantic module.\n */\nexport function annotateParsedModule(module, {filename, language, source}) {\n  const sources = [{content: source, filename, id: \"source:0\", language}]\n  const entries = semanticEntries(module)\n  /** @type {Map<string, import(\"./types.js\").SemanticNodeProvenance>} */\n  const recordsByPath = new Map()\n  /** @type {import(\"./types.js\").SemanticNodeProvenance[]} */\n  const records = []\n\n  for (const [index, entry] of entries.entries()) {\n    const ranges = parserRanges.get(entry.node) ?? {}\n    const location = \"location\" in entry.node ? entry.node.location : ranges.type ?? entry.ownerLocation\n    const sourceProvenance = /** @type {import(\"./types.js\").SemanticNodeSourceProvenance} */ ({\n      origin: {kind: \"source\", location, sourceId: \"source:0\"},\n      ranges,\n      schema: \"SemantifoldNodeProvenance\",\n      version: 1\n    })\n    const record = {\n      id: `node:${index}`,\n      kind: entry.node.kind,\n      origin: sourceProvenance.origin,\n      path: entry.path,\n      ranges: sourceProvenance.ranges\n    }\n\n    records.push(record)\n    recordsByPath.set(entry.path, record)\n    entry.node.sourceProvenance = sourceProvenance\n  }\n\n  const symbols = resolveSymbols(module, recordsByPath)\n\n  module.provenance = {\n    coordinateSystem: \"utf16\",\n    nodes: records,\n    schema: \"SemantifoldProvenance\",\n    sources,\n    symbols,\n    version: 1\n  }\n\n  return module\n}\n\n/**\n * Rebuilds canonical generation metadata without trusting caller-provided identities.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {{filename: string, content: string, language?: import(\"./types.js\").SemanticLanguage}[]} [providedSources] - Additional source content.\n * @returns {{provenance: import(\"./types.js\").SemanticProvenance, recordFor: (node: import(\"./types.js\").SemanticNode, path?: string) => import(\"./types.js\").SemanticNodeProvenance}} Canonical index.\n */\nexport function createGenerationIndex(module, providedSources = []) {\n  const entries = semanticEntries(module)\n  const priorSources = usableSourceProvenance(module.provenance)\n  /** @type {import(\"./types.js\").RegisteredSource[]} */\n  const sources = []\n  /** @type {Map<string, import(\"./types.js\").RegisteredSource>} */\n  const priorSourcesById = new Map()\n\n  for (const source of providedSources) addSource(source.filename, source.content, source.language ?? null)\n  if (priorSources) {\n    for (const source of priorSources.sources) {\n      const canonical = addSource(source.filename, source.content, source.language)\n\n      priorSourcesById.set(source.id, canonical)\n    }\n  }\n  for (const entry of entries) {\n    const location = \"location\" in entry.node ? entry.node.location : entry.ownerLocation\n\n    if (!sources.some((source) => source.filename == location.filename)) addSource(location.filename, null, null)\n  }\n  const verifiableSources = sources.filter((source) => source.content != null)\n\n  /** @type {Map<object, import(\"./types.js\").SemanticNodeProvenance[]>} */\n  const recordsByNode = new Map()\n  /** @type {Map<string, import(\"./types.js\").SemanticNodeProvenance>} */\n  const recordsByPath = new Map()\n  /** @type {import(\"./types.js\").SemanticNodeProvenance[]} */\n  const records = []\n\n  for (const [index, entry] of entries.entries()) {\n    const located = \"location\" in entry.node ? entry.node.location : entry.ownerLocation\n    const associated = usableNodeProvenance(entry.node.sourceProvenance)\n    const ranges = associated ? validRanges(associated.ranges, verifiableSources) : {}\n    const normalizedOrigin = associated\n      ? normalizeOrigin(associated.origin, priorSourcesById, verifiableSources)\n      : undefined\n    const fallbackSource = sourceForLocation(located, sources)\n    const origin = normalizedOrigin ?? sourceOrigin(fallbackSource, located)\n\n    const record = {\n      id: `node:${index}`,\n      kind: entry.node.kind,\n      origin,\n      path: entry.path,\n      ranges\n    }\n\n    records.push(record)\n    recordsByPath.set(entry.path, record)\n    const occurrences = recordsByNode.get(entry.node) ?? []\n\n    occurrences.push(record)\n    recordsByNode.set(entry.node, occurrences)\n  }\n\n  const symbols = resolveSymbols(module, recordsByPath)\n  const provenance = /** @type {import(\"./types.js\").SemanticProvenance} */ ({\n    coordinateSystem: \"utf16\",\n    nodes: records,\n    schema: \"SemantifoldProvenance\",\n    sources,\n    symbols,\n    version: 1\n  })\n\n  return {\n    provenance,\n    recordFor(node, path) {\n      const occurrences = recordsByNode.get(node)\n\n      if (!occurrences) throw new RangeError(\"Semantic node is not part of this module.\")\n      if (path !== undefined) {\n        const record = occurrences.find((candidate) => candidate.path == path)\n\n        if (!record) throw new RangeError(`Semantic node does not occur at '${path}'.`)\n\n        return record\n      }\n      if (occurrences.length != 1) {\n        throw new RangeError(\"Shared semantic node requires an occurrence path.\")\n      }\n\n      return occurrences[0]\n    }\n  }\n\n  /**\n   * Registers one canonical source.\n   * @param {string} filename - Source filename.\n   * @param {string | null} content - Source content.\n   * @param {import(\"./types.js\").SemanticLanguage | null} language - Source language.\n   * @returns {import(\"./types.js\").RegisteredSource} Canonical source.\n   */\n  function addSource(filename, content, language) {\n    if (typeof filename != \"string\" || content !== null && typeof content != \"string\" ||\n      language !== null && ![\"php\", \"ruby\", \"javascript\", \"typescript\", \"java\"].includes(language)) {\n      throw new TypeError(\"Malformed semantic source registry entry.\")\n    }\n\n    const existing = sources.find((source) => source.filename == filename && source.content == content)\n\n    if (existing) return existing\n\n    const registered = {content, filename, id: `source:${sources.length}`, language}\n\n    sources.push(registered)\n\n    return registered\n  }\n}\n\n/**\n * Selects the safe primary original location for closed provenance.\n * @param {import(\"./types.js\").SemanticOrigin} origin - Closed provenance.\n * @returns {import(\"./types.js\").SourceLocation | undefined} Primary location.\n */\nexport function primaryLocation(origin) {\n  if (origin.kind == \"source\") return origin.location\n  if (origin.kind == \"derived\") return origin.origins[0]?.location\n\n  return origin.relatedOrigins[0]?.location\n}\n\n/**\n * Accepts source metadata only when it is attached to the semantic node it describes.\n * Registry-local IDs and paths are intentionally ignored and rebuilt.\n * @param {import(\"./types.js\").SemanticNodeSourceProvenance | undefined} record - Candidate node association.\n * @returns {import(\"./types.js\").SemanticNodeSourceProvenance | undefined} Usable association.\n */\nfunction usableNodeProvenance(record) {\n  if (!record || record.schema != \"SemantifoldNodeProvenance\" || record.version != 1 ||\n    !record.origin || typeof record.origin != \"object\" ||\n    !record.ranges || typeof record.ranges != \"object\" || Array.isArray(record.ranges)) return undefined\n\n  return record\n}\n\n/**\n * Retains a valid source registry independently from potentially stale node metadata.\n * @param {import(\"./types.js\").SemanticProvenance | undefined} provenance - Candidate provenance.\n * @returns {import(\"./types.js\").SemanticProvenance | undefined} Provenance with a usable source registry.\n */\nfunction usableSourceProvenance(provenance) {\n  if (!provenance || provenance.schema != \"SemantifoldProvenance\" || provenance.version != 1 ||\n    provenance.coordinateSystem != \"utf16\" || !Array.isArray(provenance.sources)) return undefined\n\n  const sourceIds = new Set()\n\n  for (const source of provenance.sources) {\n    if (!source || typeof source.id != \"string\" || sourceIds.has(source.id) || typeof source.filename != \"string\" ||\n      source.filename.length == 0 ||\n      source.content !== null && typeof source.content != \"string\" || source.language !== null &&\n      ![\"php\", \"ruby\", \"javascript\", \"typescript\", \"java\"].includes(source.language)) return undefined\n    sourceIds.add(source.id)\n  }\n\n  return provenance\n}\n\n/**\n * Retains only self-consistent source ranges.\n * @param {Readonly<Record<string, import(\"./types.js\").SourceLocation>>} ranges - Candidate ranges.\n * @param {import(\"./types.js\").RegisteredSource[]} sources - Canonical sources.\n * @returns {Readonly<Record<string, import(\"./types.js\").SourceLocation>>} Safe ranges.\n */\nfunction validRanges(ranges, sources) {\n  if (!ranges || typeof ranges != \"object\" || Array.isArray(ranges)) return {}\n\n  /** @type {Record<string, import(\"./types.js\").SourceLocation>} */\n  const valid = {}\n\n  for (const [role, location] of Object.entries(ranges)) {\n    if (validLocation(location, sources)) valid[role] = location\n  }\n\n  return valid\n}\n\n/**\n * Normalizes a closed origin while remapping untrusted source identities.\n * @param {import(\"./types.js\").SemanticOrigin} origin - Candidate origin.\n * @param {Map<string, import(\"./types.js\").RegisteredSource>} priorSources - Prior-to-canonical source mapping.\n * @param {import(\"./types.js\").RegisteredSource[]} sources - Canonical sources.\n * @returns {import(\"./types.js\").SemanticOrigin | undefined} Safe origin.\n */\nfunction normalizeOrigin(origin, priorSources, sources) {\n  if (!origin || typeof origin != \"object\") return undefined\n\n  if (origin.kind == \"source\" && validLocation(origin.location, sources)) {\n    const claimed = priorSources.get(origin.sourceId)\n    const source = claimed && sourceOwnsLocation(claimed, origin.location) ? claimed : sourceForLocation(origin.location, sources)\n\n    return sourceOrigin(source, origin.location)\n  }\n  if (origin.kind == \"derived\" && Array.isArray(origin.origins) && origin.origins.length > 0) {\n    const origins = origin.origins.map((related) => normalizeRelatedOrigin(related, priorSources, sources))\n\n    if (origins.every(Boolean)) return {kind: \"derived\", origins: /** @type {import(\"./types.js\").RelatedOrigin[]} */ (origins)}\n  }\n  if (origin.kind == \"synthetic\" && typeof origin.reason == \"string\" && Array.isArray(origin.relatedOrigins)) {\n    const relatedOrigins = origin.relatedOrigins.map((related) => normalizeRelatedOrigin(related, priorSources, sources))\n\n    if (relatedOrigins.every(Boolean)) {\n      return {kind: \"synthetic\", reason: origin.reason, relatedOrigins: /** @type {import(\"./types.js\").RelatedOrigin[]} */ (relatedOrigins)}\n    }\n  }\n\n  return undefined\n}\n\n/**\n * Normalizes one related origin.\n * @param {import(\"./types.js\").RelatedOrigin} related - Candidate related origin.\n * @param {Map<string, import(\"./types.js\").RegisteredSource>} priorSources - Prior sources.\n * @param {import(\"./types.js\").RegisteredSource[]} sources - Canonical sources.\n * @returns {import(\"./types.js\").RelatedOrigin | undefined} Safe related origin.\n */\nfunction normalizeRelatedOrigin(related, priorSources, sources) {\n  if (!related || !validLocation(related.location, sources)) return undefined\n\n  const claimed = priorSources.get(related.sourceId)\n  const source = claimed && sourceOwnsLocation(claimed, related.location) ? claimed : sourceForLocation(related.location, sources)\n  const normalized = {location: related.location, sourceId: source.id}\n\n  if (typeof related.role == \"string\") Object.assign(normalized, {role: related.role})\n\n  return normalized\n}\n\n/**\n * Checks normalized coordinates against exact source content when available.\n * @param {import(\"./types.js\").SourceLocation} location - Candidate location.\n * @param {import(\"./types.js\").RegisteredSource[]} sources - Registered sources.\n * @returns {boolean} Whether the location is safe.\n */\nfunction validLocation(location, sources) {\n  if (!location || typeof location.filename != \"string\" || !location.start || !location.end ||\n    !Number.isInteger(location.start.offset) || !Number.isInteger(location.end.offset) || location.start.offset < 0 ||\n    location.end.offset < location.start.offset || !validPointShape(location.start) || !validPointShape(location.end)) return false\n\n  const candidates = sources.filter((source) => source.filename == location.filename)\n\n  return candidates.some((source) => sourceOwnsLocation(source, location))\n}\n\n/**\n * Checks that one identified registry source owns a normalized location.\n * @param {import(\"./types.js\").RegisteredSource} source - Identified source.\n * @param {import(\"./types.js\").SourceLocation} location - Candidate location.\n * @returns {boolean} Whether the source owns the location.\n */\nfunction sourceOwnsLocation(source, location) {\n  if (source.filename != location.filename) return false\n  if (source.content == null) return true\n  if (location.end.offset > source.content.length) return false\n  let coordinates = sourceCoordinateIndexes.get(source)\n\n  if (!coordinates) {\n    coordinates = createCoordinateIndex(source.content)\n    sourceCoordinateIndexes.set(source, coordinates)\n  }\n\n  return samePoint(indexedPointAt(coordinates, location.start.offset), location.start) &&\n    samePoint(indexedPointAt(coordinates, location.end.offset), location.end)\n}\n\n/**\n * Checks the integer shape of one source point.\n * @param {import(\"./types.js\").SourcePoint} point - Source point.\n * @returns {boolean} Whether it is structurally valid.\n */\nfunction validPointShape(point) {\n  return Number.isInteger(point.line) && point.line >= 1 && Number.isInteger(point.column) && point.column >= 1\n}\n\n/**\n * Compares normalized source coordinates.\n * @param {import(\"./types.js\").SourcePoint} left - Left point.\n * @param {import(\"./types.js\").SourcePoint} right - Right point.\n * @returns {boolean} Whether all 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 * Finds the deterministic source owning a location.\n * @param {import(\"./types.js\").SourceLocation} location - Source location.\n * @param {import(\"./types.js\").RegisteredSource[]} sources - Canonical sources.\n * @returns {import(\"./types.js\").RegisteredSource} Owning source.\n */\nfunction sourceForLocation(location, sources) {\n  const source = sources.find((candidate) => sourceOwnsLocation(candidate, location))\n\n  if (!source) throw new RangeError(`No registered source owns ${location.filename}:${location.start.offset}.`)\n\n  return source\n}\n\n/**\n * Creates direct source provenance.\n * @param {import(\"./types.js\").RegisteredSource} source - Source.\n * @param {import(\"./types.js\").SourceLocation} location - Location.\n * @returns {import(\"./types.js\").SourceOrigin} Origin.\n */\nfunction sourceOrigin(source, location) {\n  return {kind: \"source\", location, sourceId: source.id}\n}\n\n/**\n * Finds one node provenance record by semantic object or node identity.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {import(\"./types.js\").SemanticNode | string} node - Semantic object or node identity.\n * @returns {import(\"./types.js\").SemanticNodeProvenance} Provenance record.\n */\nexport function getNodeProvenance(module, node) {\n  requireProvenance(module)\n  const index = createGenerationIndex(module)\n  const record = typeof node == \"string\"\n    ? index.provenance.nodes.find((candidate) => candidate.id == node)\n    : index.recordFor(node)\n\n  if (!record) throw new RangeError(`Unknown semantic node: ${node}`)\n\n  return record\n}\n\n/**\n * Finds one semantic symbol record.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {string} symbolId - Symbol identity.\n * @returns {import(\"./types.js\").SemanticSymbolProvenance} Symbol record.\n */\nexport function getSymbolProvenance(module, symbolId) {\n  requireProvenance(module)\n  const symbol = createGenerationIndex(module).provenance.symbols.find((candidate) => candidate.id == symbolId)\n\n  if (!symbol) throw new RangeError(`Unknown semantic symbol: ${symbolId}`)\n\n  return symbol\n}\n\n/**\n * Requires frontend provenance.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @returns {import(\"./types.js\").SemanticProvenance} Provenance.\n */\nfunction requireProvenance(module) {\n  if (!module.provenance) throw new TypeError(\"Semantic module does not contain source provenance.\")\n\n  return module.provenance\n}\n\n/**\n * Traverses public semantic nodes in one stable order.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @returns {{node: import(\"./types.js\").SemanticNode, ownerLocation: import(\"./types.js\").SourceLocation, path: string}[]} Entries.\n */\nexport function semanticEntries(module) {\n  /** @type {{node: import(\"./types.js\").SemanticNode, ownerLocation: import(\"./types.js\").SourceLocation, path: string}[]} */\n  const entries = []\n\n  visit(module, \"\", module.location)\n\n  return entries\n\n  /**\n   * Visits one semantic node and its children.\n   * @param {import(\"./types.js\").SemanticNode} node - Current node.\n   * @param {string} path - Current JSON Pointer.\n   * @param {import(\"./types.js\").SourceLocation} ownerLocation - Nearest located owner.\n   * @returns {void}\n   */\n  function visit(node, path, ownerLocation) {\n    const location = \"location\" in node ? node.location : ownerLocation\n\n    entries.push({node, ownerLocation: location, path})\n\n    if (node.kind == \"Module\") {\n      node.functions.forEach((child, index) => visit(child, `/functions/${index}`, location))\n      visit(node.entryPoint, \"/entryPoint\", location)\n    } else if (node.kind == \"FunctionDeclaration\") {\n      node.parameters.forEach((child, index) => visit(child, `${path}/parameters/${index}`, location))\n      visit(node.returnType, `${path}/returnType`, location)\n      visit(node.body, `${path}/body`, location)\n    } else if (node.kind == \"Block\") {\n      node.statements.forEach((child, index) => visit(child, `${path}/statements/${index}`, location))\n    } else if (node.kind == \"Parameter\") {\n      visit(node.type, `${path}/type`, location)\n    } else if (node.kind == \"LocalDeclaration\") {\n      visit(node.type, `${path}/type`, location)\n      visit(node.initializer, `${path}/initializer`, location)\n    } else if (node.kind == \"AssignmentStatement\") {\n      visit(node.target, `${path}/target`, location)\n      visit(node.expression, `${path}/expression`, location)\n    } else if (node.kind == \"ReturnStatement\" || node.kind == \"PrintStatement\") {\n      visit(node.expression, `${path}/expression`, location)\n    } else if (node.kind == \"IfStatement\") {\n      visit(node.condition, `${path}/condition`, location)\n      visit(node.consequent, `${path}/consequent`, location)\n      if (node.alternate) visit(node.alternate, `${path}/alternate`, location)\n    } else if (node.kind == \"EntryPoint\") {\n      visit(node.body, `${path}/body`, location)\n    } else if (node.kind == \"UnaryExpression\") {\n      visit(node.operand, `${path}/operand`, location)\n    } else if (node.kind == \"BinaryExpression\") {\n      visit(node.left, `${path}/left`, location)\n      visit(node.right, `${path}/right`, location)\n    } else if (node.kind == \"CallExpression\") {\n      node.arguments.forEach((child, index) => visit(child, `${path}/arguments/${index}`, location))\n    }\n  }\n}\n\n/**\n * Resolves declarations and references after semantic validation.\n * @param {import(\"./types.js\").SemanticModule} module - Validated module.\n * @param {Map<string, import(\"./types.js\").SemanticNodeProvenance>} records - Node records by occurrence path.\n * @returns {import(\"./types.js\").SemanticSymbolProvenance[]} Symbols.\n */\nfunction resolveSymbols(module, records) {\n  /** @type {import(\"./types.js\").SemanticSymbolProvenance[]} */\n  const symbols = []\n  /** @type {Map<string, string>} */\n  const functions = new Map()\n\n  for (const [index, declaration] of module.functions.entries()) {\n    functions.set(declaration.name, declare(declaration, declaration.name, \"function\", `/functions/${index}`))\n  }\n\n  for (const [index, declaration] of module.functions.entries()) {\n    const declarationPath = `/functions/${index}`\n    const scope = new Map()\n\n    for (const [parameterIndex, parameter] of declaration.parameters.entries()) {\n      scope.set(parameter.name, declare(parameter, parameter.name, \"parameter\", `${declarationPath}/parameters/${parameterIndex}`))\n    }\n    visitBlock(declaration.body, scope, `${declarationPath}/body`)\n  }\n\n  visitBlock(module.entryPoint.body, new Map(), \"/entryPoint/body\")\n\n  return symbols\n\n  /**\n   * Declares one canonical symbol.\n   * @param {import(\"./types.js\").FunctionDeclaration | import(\"./types.js\").Parameter | import(\"./types.js\").LocalDeclaration} node - Declaration.\n   * @param {string} name - Symbol name.\n   * @param {import(\"./types.js\").SemanticSymbolKind} kind - Symbol kind.\n   * @param {string} path - Declaration occurrence path.\n   * @returns {string} Symbol identity.\n   */\n  function declare(node, name, kind, path) {\n    const record = records.get(path)\n\n    if (!record) throw new Error(`Missing provenance for ${node.kind}.`)\n\n    const location = record.ranges.name ?? node.location\n    const id = `symbol:${symbols.length}`\n\n    record.symbolId = id\n    symbols.push({declarationNodeId: record.id, id, kind, location, name, references: []})\n\n    return id\n  }\n\n  /**\n   * Resolves references in one lexical block.\n   * @param {import(\"./types.js\").Block} block - Semantic block.\n   * @param {Map<string, string>} parent - Visible bindings.\n   * @param {string} path - Statement sequence path.\n   * @returns {void}\n   */\n  function visitBlock(block, parent, path) {\n    const scope = new Map(parent)\n\n    for (const [index, statement] of block.statements.entries()) {\n      const statementPath = `${path}/statements/${index}`\n\n      if (statement.kind == \"LocalDeclaration\") {\n        visitExpression(statement.initializer, scope, `${statementPath}/initializer`)\n        scope.set(statement.name, declare(statement, statement.name, \"local\", statementPath))\n      } else if (statement.kind == \"AssignmentStatement\") {\n        reference(statement.target, scope.get(statement.target.name), \"write\", `${statementPath}/target`)\n        visitExpression(statement.expression, scope, `${statementPath}/expression`)\n      } else if (statement.kind == \"ReturnStatement\" || statement.kind == \"PrintStatement\") {\n        visitExpression(statement.expression, scope, `${statementPath}/expression`)\n      } else if (statement.kind == \"IfStatement\") {\n        visitExpression(statement.condition, scope, `${statementPath}/condition`)\n        visitBlock(statement.consequent, scope, `${statementPath}/consequent`)\n        if (statement.alternate) visitBlock(statement.alternate, scope, `${statementPath}/alternate`)\n      }\n    }\n  }\n\n  /**\n   * Resolves references in one expression.\n   * @param {import(\"./types.js\").Expression} expression - Expression.\n   * @param {Map<string, string>} scope - Visible bindings.\n   * @param {string} path - Expression occurrence path.\n   * @returns {void}\n   */\n  function visitExpression(expression, scope, path) {\n    if (expression.kind == \"IdentifierExpression\") reference(expression, scope.get(expression.name), \"read\", path)\n    else if (expression.kind == \"CallExpression\") {\n      reference(expression, functions.get(expression.callee), \"call\", path)\n      for (const [index, argument] of expression.arguments.entries()) visitExpression(argument, scope, `${path}/arguments/${index}`)\n    } else if (expression.kind == \"UnaryExpression\") {\n      visitExpression(expression.operand, scope, `${path}/operand`)\n    } else if (expression.kind == \"BinaryExpression\") {\n      visitExpression(expression.left, scope, `${path}/left`)\n      visitExpression(expression.right, scope, `${path}/right`)\n    }\n  }\n\n  /**\n   * Attaches one resolved symbol reference.\n   * @param {import(\"./types.js\").IdentifierExpression | import(\"./types.js\").CallExpression} node - Reference node.\n   * @param {string | undefined} symbolId - Resolved symbol.\n   * @param {\"read\" | \"write\" | \"call\"} role - Reference role.\n   * @param {string} path - Reference occurrence path.\n   * @returns {void}\n   */\n  function reference(node, symbolId, role, path) {\n    if (!symbolId) return\n\n    const record = records.get(path)\n    const symbol = symbols.find((candidate) => candidate.id == symbolId)\n\n    if (!record || !symbol) throw new Error(`Missing provenance while resolving ${node.kind}.`)\n\n    const location = record.ranges[role == \"call\" ? \"callee\" : \"name\"] ?? node.location\n\n    record.symbolId = symbolId\n    symbol.references.push({location, nodeId: record.id, role})\n  }\n}\n"]}