@lsctech/polaris 0.1.0

package/dist/graph/parser/pipeline.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runExtractionPipeline = runExtractionPipeline;
+const node_fs_1 = require("node:fs");
+const node_crypto_1 = require("node:crypto");
+const node_path_1 = require("node:path");
+const registry_js_1 = require("../adapter/registry.js");
+const index_js_1 = require("../capability/index.js");
+const queries_js_1 = require("../store/queries.js");
+async function runExtractionPipeline(filePaths, options) {
+    const adapterRegistry = options.adapterRegistry ?? (0, registry_js_1.getDefaultAdapterRegistry)();
+    const db = options.graphStore.getDatabase();
+    const warningMessages = [];
+    const sortedPaths = Array.from(new Set(filePaths)).sort((left, right) => left.localeCompare(right));
+    const capabilityRegistry = new index_js_1.GraphCapabilityRegistry(adapterRegistry.getAll().map((adapter) => adapter.languageId));
+    let succeededFiles = 0;
+    let failedFiles = 0;
+    let persistedNodes = 0;
+    let persistedSymbols = 0;
+    const fallbackFiles = [];
+    for (const filePath of sortedPaths) {
+        const ext = (0, node_path_1.extname)(filePath).toLowerCase();
+        const adapter = adapterRegistry.getForExtension(ext);
+        const languageId = adapter?.languageId ?? index_js_1.GraphCapabilityRegistry.unsupportedLanguageId(ext);
+        try {
+            if (!adapter) {
+                const fileId = makeDeterministicId("file", filePath);
+                persistUnsupportedFile(db, filePath, languageId, fileId);
+                fallbackFiles.push({ path: filePath, ext });
+                succeededFiles += 1;
+                persistedNodes += 1;
+                const warning = `Falling back to file node for unsupported file type: ${filePath}`;
+                warningMessages.push(warning);
+                capabilityRegistry.noteUnsupportedExtension(ext);
+                capabilityRegistry.recordFileLevel(languageId, [warning]);
+                options.logger?.warn(warning);
+                continue;
+            }
+            const source = (0, node_fs_1.readFileSync)(filePath, "utf-8");
+            const extracted = await adapter.extractSymbols(filePath, source);
+            const fileId = makeDeterministicId("file", filePath);
+            const symbols = extracted.symbols.map((entry, index) => toPersistableSymbol(fileId, filePath, entry, index));
+            persistFileSymbols(db, filePath, extracted.language, fileId, symbols);
+            succeededFiles += 1;
+            persistedNodes += symbols.length;
+            persistedSymbols += symbols.length;
+            capabilityRegistry.recordSymbolLevel(adapter.languageId, symbols.length);
+        }
+        catch (error) {
+            failedFiles += 1;
+            const message = error instanceof Error ? error.message : String(error);
+            const warning = `Extraction failed for ${filePath}: ${message}`;
+            warningMessages.push(warning);
+            if (!adapter) {
+                capabilityRegistry.noteUnsupportedExtension(ext);
+            }
+            capabilityRegistry.recordFailure(languageId, warning);
+            options.logger?.warn(warning);
+        }
+    }
+    return {
+        processedFiles: sortedPaths.length,
+        succeededFiles,
+        failedFiles,
+        persistedNodes,
+        persistedSymbols,
+        fallbackFiles,
+        warnings: warningMessages,
+        capability: capabilityRegistry.buildReport(),
+    };
+}
+function toPersistableSymbol(fileId, filePath, entry, index) {
+    const symbolIdSeed = [
+        filePath,
+        entry.kind,
+        entry.name,
+        entry.startLine,
+        entry.startColumn,
+        entry.endLine,
+        entry.endColumn,
+        index,
+    ].join(":");
+    const symbolId = makeDeterministicId("symbol", symbolIdSeed);
+    const nodeId = makeDeterministicId("node", symbolIdSeed);
+    const node = {
+        id: nodeId,
+        type: mapKindToNodeType(entry.kind),
+        fileId,
+        name: entry.name,
+        startLine: entry.startLine,
+        startColumn: entry.startColumn,
+        endLine: entry.endLine,
+        endColumn: entry.endColumn,
+    };
+    const symbol = {
+        id: symbolId,
+        nodeId,
+        fileId,
+        name: entry.name,
+        kind: entry.kind,
+        signature: entry.signature,
+        exported: entry.exported,
+    };
+    return { node, symbol };
+}
+function persistFileSymbols(db, filePath, language, fileId, symbols) {
+    db.exec("BEGIN IMMEDIATE TRANSACTION");
+    try {
+        db.prepare(`
+        INSERT INTO files (id, path, language)
+        VALUES (?1, ?2, ?3)
+        ON CONFLICT(path) DO UPDATE SET
+          id = excluded.id,
+          language = excluded.language
+      `).run(fileId, filePath, normalizeLanguage(language, filePath));
+        db.prepare("DELETE FROM symbols WHERE file_id = ?1").run(fileId);
+        db.prepare("DELETE FROM nodes WHERE file_id = ?1").run(fileId);
+        for (const item of symbols) {
+            (0, queries_js_1.insertNode)(db, item.node);
+            db.prepare(`
+          INSERT INTO symbols (id, node_id, file_id, name, kind, signature, exported)
+          VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
+          ON CONFLICT(id) DO UPDATE SET
+            node_id = excluded.node_id,
+            file_id = excluded.file_id,
+            name = excluded.name,
+            kind = excluded.kind,
+            signature = excluded.signature,
+            exported = excluded.exported
+        `).run(item.symbol.id, item.symbol.nodeId, item.symbol.fileId, item.symbol.name, item.symbol.kind, item.symbol.signature ?? null, item.symbol.exported ? 1 : 0);
+        }
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+function persistUnsupportedFile(db, filePath, language, fileId) {
+    db.exec("BEGIN IMMEDIATE TRANSACTION");
+    try {
+        db.prepare(`
+        INSERT INTO files (id, path, language)
+        VALUES (?1, ?2, ?3)
+        ON CONFLICT(path) DO UPDATE SET
+          id = excluded.id,
+          language = excluded.language
+      `).run(fileId, filePath, normalizeLanguage(language, filePath));
+        db.prepare("DELETE FROM symbols WHERE file_id = ?1").run(fileId);
+        db.prepare("DELETE FROM nodes WHERE file_id = ?1").run(fileId);
+        (0, queries_js_1.insertNode)(db, {
+            id: fileId,
+            type: "FILE",
+            fileId,
+        });
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+function normalizeLanguage(language, filePath) {
+    const extension = (0, node_path_1.extname)(filePath).toLowerCase();
+    if (language === "typescript" || extension === ".ts" || extension === ".tsx") {
+        return "ts";
+    }
+    if (language === "javascript" ||
+        extension === ".js" ||
+        extension === ".jsx" ||
+        extension === ".mjs" ||
+        extension === ".cjs") {
+        return "js";
+    }
+    return language;
+}
+function mapKindToNodeType(kind) {
+    switch (kind) {
+        case "function":
+            return "FUNCTION";
+        case "class":
+            return "CLASS";
+        case "method":
+            return "METHOD";
+        case "import":
+            return "IMPORT";
+        default:
+            return "SYMBOL";
+    }
+}
+function makeDeterministicId(prefix, input) {
+    const digest = (0, node_crypto_1.createHash)("sha256").update(input).digest("hex").slice(0, 24);
+    return `${prefix}-${digest}`;
+}

package/dist/graph/query/index.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureGraphQuery = configureGraphQuery;
+exports.lookupSymbol = lookupSymbol;
+exports.getCallers = getCallers;
+exports.getCallees = getCallees;
+exports.getImpactedFiles = getImpactedFiles;
+exports.getGraphStats = getGraphStats;
+const types_js_1 = require("./types.js");
+const FILE_NODE_PREFIX = "node-file-";
+const queryState = {
+    defaultStore: null,
+    overrideStore: null,
+};
+function configureGraphQuery(options) {
+    queryState.overrideStore = options.graphStore ?? null;
+}
+function lookupSymbol(name, file) {
+    const db = getDatabase();
+    const row = db
+        .prepare(`
+        SELECT
+          s.id,
+          s.node_id AS nodeId,
+          s.name,
+          s.kind,
+          s.signature,
+          s.exported,
+          s.file_id AS fileId,
+          f.path AS filePath
+        FROM symbols s
+        JOIN files f ON f.id = s.file_id
+        WHERE s.name = ?1
+          AND (?2 IS NULL OR f.path = ?2)
+        ORDER BY s.id
+        LIMIT 1
+      `)
+        .get(name, file ?? null);
+    if (!row) {
+        return null;
+    }
+    return toGraphSymbol(row);
+}
+function getCallers(symbolId) {
+    const db = getDatabase();
+    return lookupRelatedSymbols(db, symbolId, "CALLS", "to_node_id", "from_node_id");
+}
+function getCallees(symbolId) {
+    const db = getDatabase();
+    return lookupRelatedSymbols(db, symbolId, "CALLS", "from_node_id", "to_node_id");
+}
+function getImpactedFiles(symbolId) {
+    const db = getDatabase();
+    const root = lookupSymbolRowById(db, symbolId);
+    if (!root) {
+        return [];
+    }
+    const impactedFiles = new Map();
+    const visitedSymbolNodes = new Set();
+    const visitedFileNodes = new Set();
+    const queue = [];
+    addImpactedFile(impactedFiles, {
+        fileId: root.fileId,
+        path: root.filePath,
+        language: lookupLanguageByFileId(db, root.fileId),
+    });
+    queue.push({ kind: "symbol", nodeId: root.nodeId, depth: 0 });
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        if (current.depth > types_js_1.DEFAULT_IMPACT_MAX_DEPTH) {
+            continue;
+        }
+        if (current.kind === "symbol") {
+            if (visitedSymbolNodes.has(current.nodeId)) {
+                continue;
+            }
+            visitedSymbolNodes.add(current.nodeId);
+            const symbolFile = lookupFileBySymbolNodeId(db, current.nodeId);
+            if (symbolFile) {
+                addImpactedFile(impactedFiles, symbolFile);
+                queue.push({
+                    kind: "file",
+                    nodeId: `${FILE_NODE_PREFIX}${symbolFile.fileId}`,
+                    depth: current.depth + 1,
+                });
+            }
+            const outgoingCalls = db
+                .prepare(`
+            SELECT e.to_node_id AS nodeId
+            FROM edges e
+            WHERE e.type = 'CALLS'
+              AND e.from_node_id = ?1
+            ORDER BY e.to_node_id
+          `)
+                .all(current.nodeId);
+            for (const edge of outgoingCalls) {
+                queue.push({ kind: "symbol", nodeId: edge.nodeId, depth: current.depth + 1 });
+            }
+            continue;
+        }
+        if (visitedFileNodes.has(current.nodeId)) {
+            continue;
+        }
+        visitedFileNodes.add(current.nodeId);
+        const fileByNode = lookupFileByFileNodeId(db, current.nodeId);
+        if (fileByNode) {
+            addImpactedFile(impactedFiles, fileByNode);
+        }
+        const importedFiles = db
+            .prepare(`
+          SELECT e.to_node_id AS fileNodeId
+          FROM edges e
+          WHERE e.type = 'IMPORTS'
+            AND e.from_node_id = ?1
+          ORDER BY e.to_node_id
+        `)
+            .all(current.nodeId);
+        for (const imported of importedFiles) {
+            const importedFile = lookupFileByFileNodeId(db, imported.fileNodeId);
+            if (importedFile) {
+                addImpactedFile(impactedFiles, importedFile);
+            }
+            queue.push({ kind: "file", nodeId: imported.fileNodeId, depth: current.depth + 1 });
+        }
+        const symbolsInFile = db
+            .prepare(`
+          SELECT e.from_node_id AS symbolNodeId
+          FROM edges e
+          WHERE e.type = 'DEFINED_IN'
+            AND e.to_node_id = ?1
+          ORDER BY e.from_node_id
+        `)
+            .all(current.nodeId);
+        for (const symbol of symbolsInFile) {
+            queue.push({ kind: "symbol", nodeId: symbol.symbolNodeId, depth: current.depth + 1 });
+        }
+    }
+    return Array.from(impactedFiles.values()).sort((left, right) => left.path.localeCompare(right.path));
+}
+function getGraphStats() {
+    const db = getDatabase();
+    const row = db
+        .prepare(`
+        SELECT
+          (SELECT COUNT(*) FROM nodes) AS nodeCount,
+          (SELECT COUNT(*) FROM edges) AS edgeCount,
+          (SELECT COUNT(*) FROM files) AS fileCount,
+          (SELECT COUNT(*) FROM symbols) AS symbolCount
+      `)
+        .get();
+    return {
+        version: types_js_1.GRAPH_QUERY_RESPONSE_VERSION,
+        nodeCount: row.nodeCount,
+        edgeCount: row.edgeCount,
+        fileCount: row.fileCount,
+        symbolCount: row.symbolCount,
+    };
+}
+function getDatabase() {
+    const activeStore = queryState.overrideStore ?? getDefaultStore();
+    return activeStore.getDatabase();
+}
+function getDefaultStore() {
+    if (queryState.defaultStore) {
+        return queryState.defaultStore;
+    }
+    throw new Error("No graph store configured. Call configureGraphQuery() before using the query API.");
+}
+function lookupRelatedSymbols(db, symbolId, edgeType, sourceColumn, targetColumn) {
+    const source = lookupSymbolRowById(db, symbolId);
+    if (!source) {
+        return [];
+    }
+    const rows = db
+        .prepare(`
+        SELECT DISTINCT
+          s.id,
+          s.node_id AS nodeId,
+          s.name,
+          s.kind,
+          s.signature,
+          s.exported,
+          s.file_id AS fileId,
+          f.path AS filePath
+        FROM edges e
+        JOIN symbols s ON s.node_id = e.${targetColumn}
+        JOIN files f ON f.id = s.file_id
+        WHERE e.type = ?1
+          AND e.${sourceColumn} = ?2
+        ORDER BY s.id
+      `)
+        .all(edgeType, source.nodeId);
+    return rows.map((row) => toGraphSymbol(row));
+}
+function lookupSymbolRowById(db, symbolId) {
+    const row = db
+        .prepare(`
+        SELECT
+          s.id,
+          s.node_id AS nodeId,
+          s.name,
+          s.kind,
+          s.signature,
+          s.exported,
+          s.file_id AS fileId,
+          f.path AS filePath
+        FROM symbols s
+        JOIN files f ON f.id = s.file_id
+        WHERE s.id = ?1
+        LIMIT 1
+      `)
+        .get(symbolId);
+    return row ?? null;
+}
+function lookupFileBySymbolNodeId(db, symbolNodeId) {
+    const row = db
+        .prepare(`
+        SELECT DISTINCT
+          f.id AS fileId,
+          f.path,
+          f.language
+        FROM symbols s
+        JOIN files f ON f.id = s.file_id
+        WHERE s.node_id = ?1
+        LIMIT 1
+      `)
+        .get(symbolNodeId);
+    return row ?? null;
+}
+function lookupFileByFileNodeId(db, fileNodeId) {
+    const row = db
+        .prepare(`
+        SELECT
+          f.id AS fileId,
+          f.path,
+          f.language
+        FROM nodes n
+        JOIN files f ON f.id = n.file_id
+        WHERE n.id = ?1
+          AND n.type = 'FILE'
+        LIMIT 1
+      `)
+        .get(fileNodeId);
+    return row ?? null;
+}
+function lookupLanguageByFileId(db, fileId) {
+    const row = db
+        .prepare(`
+        SELECT language
+        FROM files
+        WHERE id = ?1
+        LIMIT 1
+      `)
+        .get(fileId);
+    return row?.language ?? "unknown";
+}
+function addImpactedFile(target, file) {
+    target.set(file.path, {
+        version: types_js_1.GRAPH_QUERY_RESPONSE_VERSION,
+        path: file.path,
+        language: file.language,
+    });
+}
+function toGraphSymbol(row) {
+    return {
+        version: types_js_1.GRAPH_QUERY_RESPONSE_VERSION,
+        id: row.id,
+        name: row.name,
+        kind: row.kind,
+        signature: row.signature,
+        exported: row.exported === 1,
+        filePath: row.filePath,
+    };
+}

package/dist/graph/query/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_IMPACT_MAX_DEPTH = exports.GRAPH_QUERY_RESPONSE_VERSION = void 0;
+exports.GRAPH_QUERY_RESPONSE_VERSION = 1;
+exports.DEFAULT_IMPACT_MAX_DEPTH = 8;

package/dist/graph/resolver/build-edges.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEdges = buildEdges;
+const node_crypto_1 = require("node:crypto");
+const queries_js_1 = require("../store/queries.js");
+const FILE_NODE_PREFIX = "node-file-";
+const UNRESOLVED_NODE_PREFIX = "node-unresolved-call-";
+const UNRESOLVED_SYMBOL_PREFIX = "symbol-unresolved-call-";
+const UNRESOLVED_SIGNATURE = "__UNRESOLVED__";
+function buildEdges(db, resolvedImports) {
+    const files = db
+        .prepare(`
+        SELECT id, path
+        FROM files
+      `)
+        .all();
+    for (const file of files) {
+        upsertFileNode(db, file.id, file.path);
+    }
+    const symbols = db
+        .prepare(`
+        SELECT id, node_id AS nodeId, file_id AS fileId, name, kind, signature
+        FROM symbols
+      `)
+        .all();
+    const symbolById = new Map();
+    const symbolsByName = new Map();
+    for (const symbol of symbols) {
+        symbolById.set(symbol.id, symbol);
+        if (symbol.kind === "import") {
+            continue;
+        }
+        const existing = symbolsByName.get(symbol.name) ?? [];
+        existing.push(symbol);
+        symbolsByName.set(symbol.name, existing);
+    }
+    for (const list of symbolsByName.values()) {
+        list.sort((left, right) => left.id.localeCompare(right.id));
+    }
+    let importsEdges = 0;
+    let unresolvedImports = 0;
+    for (const resolvedImport of resolvedImports) {
+        const fromFileNodeId = toFileNodeId(resolvedImport.importerFileId);
+        const targetFileNodeId = toFileNodeId(resolvedImport.resolvedFileId);
+        const importEdge = {
+            id: makeEdgeId("imports", fromFileNodeId, targetFileNodeId, resolvedImport.importSpecifier),
+            type: "IMPORTS",
+            fromNodeId: fromFileNodeId,
+            toNodeId: targetFileNodeId,
+            metadata: JSON.stringify({
+                importSpecifier: resolvedImport.importSpecifier,
+                resolvedSymbolIds: resolvedImport.resolvedSymbolIds,
+                UNRESOLVED: resolvedImport.unresolved,
+            }),
+        };
+        (0, queries_js_1.insertEdge)(db, importEdge);
+        importsEdges += 1;
+        if (resolvedImport.unresolved) {
+            unresolvedImports += 1;
+        }
+    }
+    let definedInEdges = 0;
+    for (const symbol of symbols) {
+        const edge = {
+            id: makeEdgeId("defined-in", symbol.nodeId, toFileNodeId(symbol.fileId), symbol.id),
+            type: "DEFINED_IN",
+            fromNodeId: symbol.nodeId,
+            toNodeId: toFileNodeId(symbol.fileId),
+            metadata: null,
+        };
+        (0, queries_js_1.insertEdge)(db, edge);
+        definedInEdges += 1;
+    }
+    let callsEdges = 0;
+    let unresolvedCalls = 0;
+    for (const symbol of symbols) {
+        if ((symbol.kind !== "function" && symbol.kind !== "method") || !symbol.signature) {
+            continue;
+        }
+        const callees = extractCallNames(symbol.signature);
+        for (const calleeName of callees) {
+            if (calleeName === symbol.name) {
+                continue;
+            }
+            const resolvedCallee = resolveCalleeSymbol(calleeName, symbol.fileId, symbolsByName);
+            if (resolvedCallee) {
+                const edge = {
+                    id: makeEdgeId("calls", symbol.nodeId, resolvedCallee.nodeId, calleeName),
+                    type: "CALLS",
+                    fromNodeId: symbol.nodeId,
+                    toNodeId: resolvedCallee.nodeId,
+                    metadata: JSON.stringify({
+                        calleeName,
+                        UNRESOLVED: false,
+                    }),
+                };
+                (0, queries_js_1.insertEdge)(db, edge);
+                callsEdges += 1;
+                continue;
+            }
+            const unresolved = upsertUnresolvedCallStub(db, symbol.fileId, calleeName);
+            const unresolvedDefinedIn = {
+                id: makeEdgeId("defined-in", unresolved.nodeId, toFileNodeId(symbol.fileId), unresolved.nodeId),
+                type: "DEFINED_IN",
+                fromNodeId: unresolved.nodeId,
+                toNodeId: toFileNodeId(symbol.fileId),
+                metadata: JSON.stringify({
+                    UNRESOLVED: true,
+                }),
+            };
+            (0, queries_js_1.insertEdge)(db, unresolvedDefinedIn);
+            definedInEdges += 1;
+            const edge = {
+                id: makeEdgeId("calls", symbol.nodeId, unresolved.nodeId, calleeName),
+                type: "CALLS",
+                fromNodeId: symbol.nodeId,
+                toNodeId: unresolved.nodeId,
+                metadata: JSON.stringify({
+                    calleeName,
+                    UNRESOLVED: true,
+                }),
+            };
+            (0, queries_js_1.insertEdge)(db, edge);
+            callsEdges += 1;
+            unresolvedCalls += 1;
+        }
+    }
+    return {
+        callsEdges,
+        importsEdges,
+        definedInEdges,
+        unresolvedImports,
+        unresolvedCalls,
+    };
+}
+function upsertFileNode(db, fileId, filePath) {
+    const node = {
+        id: toFileNodeId(fileId),
+        type: "FILE",
+        fileId,
+        name: filePath,
+    };
+    (0, queries_js_1.insertNode)(db, node);
+}
+function upsertUnresolvedCallStub(db, callerFileId, calleeName) {
+    const digest = makeDigest(`${callerFileId}:${calleeName}`);
+    const nodeId = `${UNRESOLVED_NODE_PREFIX}${digest}`;
+    const symbolId = `${UNRESOLVED_SYMBOL_PREFIX}${digest}`;
+    const node = {
+        id: nodeId,
+        type: "SYMBOL",
+        fileId: callerFileId,
+        name: `UNRESOLVED:${calleeName}`,
+    };
+    (0, queries_js_1.insertNode)(db, node);
+    db.prepare(`
+      INSERT INTO symbols (id, node_id, file_id, name, kind, signature, exported)
+      VALUES (?1, ?2, ?3, ?4, ?5, ?6, 0)
+      ON CONFLICT(id) DO UPDATE SET
+        node_id = excluded.node_id,
+        file_id = excluded.file_id,
+        name = excluded.name,
+        kind = excluded.kind,
+        signature = excluded.signature,
+        exported = excluded.exported
+    `).run(symbolId, nodeId, callerFileId, calleeName, "unknown", UNRESOLVED_SIGNATURE);
+    return { nodeId };
+}
+function resolveCalleeSymbol(calleeName, callerFileId, symbolsByName) {
+    const candidates = symbolsByName.get(calleeName);
+    if (!candidates || candidates.length === 0) {
+        return null;
+    }
+    const local = candidates.find((entry) => entry.fileId === callerFileId);
+    return local ?? candidates[0] ?? null;
+}
+function extractCallNames(signature) {
+    const matches = new Set();
+    for (const match of signature.matchAll(/\b([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/g)) {
+        const name = match[1];
+        if (!name || RESERVED_CALL_TOKENS.has(name)) {
+            continue;
+        }
+        matches.add(name);
+    }
+    return Array.from(matches.values()).sort((left, right) => left.localeCompare(right));
+}
+function makeEdgeId(prefix, fromNodeId, toNodeId, suffix) {
+    return `${prefix}-${makeDigest(`${fromNodeId}:${toNodeId}:${suffix}`)}`;
+}
+function toFileNodeId(fileId) {
+    return `${FILE_NODE_PREFIX}${fileId}`;
+}
+function makeDigest(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex").slice(0, 24);
+}
+const RESERVED_CALL_TOKENS = new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "function",
+    "return",
+    "new",
+    "typeof",
+    "await",
+    "import",
+    "super",
+    "console",
+]);