cgraphx 2.0.2 → 2.0.6

package/dist/core/code/engine/core/lbug/csv-generator.js

@@ -0,0 +1,710 @@
+"use strict";
+/**
+ * CSV Generator for LadybugDB Hybrid Schema
+ *
+ * Streams CSV rows directly to disk files in a single pass over graph nodes.
+ * File contents are lazy-read from disk per-node to avoid holding the entire
+ * repo in RAM. Rows are buffered (FLUSH_BYTES) before writing to minimize
+ * per-row Promise overhead.
+ *
+ * RFC 4180 Compliant:
+ * - Fields containing commas, double quotes, or newlines are enclosed in double quotes
+ * - Double quotes within fields are escaped by doubling them ("")
+ * - All fields are consistently quoted for safety with code content
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamAllCSVsToDisk = exports.buildBasicBlockRow = exports.BASICBLOCK_CSV_HEADER = exports.buildRelRow = exports.REL_CSV_HEADER = exports.normalizeFtsText = exports.isBinaryContent = exports.escapeCSVNumber = exports.escapeCSVField = exports.sanitizeUTF8 = exports.shouldFlushCSVBuffer = exports.FLUSH_BYTES = exports.DECLARED_RELATION_PAIRS = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const schema_js_1 = require("./schema.js");
+const rel_pair_routing_js_1 = require("./rel-pair-routing.js");
+const env_js_1 = require("../ingestion/utils/env.js");
+const symbol_labels_js_1 = require("../ingestion/utils/symbol-labels.js");
+/** Computed once — `RELATION_SCHEMA` is a static template literal. Exported so
+ *  the streamed sinks (`GraphEmitSink`, `PdgEmitSink`) share this parse
+ *  instead of each re-deriving it from the same DDL string. */
+exports.DECLARED_RELATION_PAIRS = (0, rel_pair_routing_js_1.parseRelationSchemaPairs)(schema_js_1.RELATION_SCHEMA);
+/**
+ * Deterministic output ordering — optional (out-of-core / windowed-resolve
+ * enabler). When `CGRAPH_SORT_GRAPH_OUTPUT` is set, nodes and relationships
+ * are emitted sorted by their (unique, dedup-key) graph `id` rather than in
+ * graph-insertion order, making the CSV a pure function of the graph's node/edge
+ * SET instead of of emit order. Default off returns the iterator untouched, so
+ * the bytes are identical to today. With it on, a windowed/out-of-core emit
+ * (the later windowed-resolve work) need only reproduce the same edge SET, not the global insertion order —
+ * which removes "CSV row order == Map insertion order" as a byte-identical
+ * hazard for every later windowing step.
+ */
+const byGraphId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+const orderedNodes = (graph, sorted) => sorted ? [...graph.iterNodes()].sort(byGraphId) : graph.iterNodes();
+const orderedRelationships = (graph, sorted) => sorted ? [...graph.iterRelationships()].sort(byGraphId) : graph.iterRelationships();
+/**
+ * Flush buffered rows to disk once the buffered chunk reaches this many bytes.
+ * Byte-bounded rather than row-count-bounded: row size ranges from a few dozen
+ * bytes (typical symbol/relationship rows) up to a full File's content
+ * (#2317/#2323), so a row-count-only cap lets a handful of huge rows build an
+ * unbounded `buffer.join('\n')` string before ever tripping it.
+ *
+ * Not an env knob — fixed by a safety margin, not a preference. The one worst
+ * case that matters: one more oversized row lands right after the buffer was
+ * just under this threshold, before the flush fires. That row is capped at
+ * TREE_SITTER_MAX_BUFFER (32MB, hard-clamped — CGRAPH_MAX_FILE_SIZE cannot
+ * raise it), and `escapeCSVField`'s worst-case quote-doubling (2x) can grow it
+ * before it reaches the buffer. So the peak joined-string size is bounded by
+ *   FLUSH_BYTES + 2 * TREE_SITTER_MAX_BUFFER ≈ 8MB + 64MB ≈ 72MB,
+ * versus Node's `buffer.constants.MAX_STRING_LENGTH` (~512MB) — a comfortable
+ * margin (see the `shouldFlushCSVBuffer stays within the V8 string-length
+ * ceiling` test, which fails loudly if any of these constants ever moves this
+ * margin the wrong way). Raising FLUSH_BYTES trades fewer/larger flushes for
+ * less margin; lowering it trades the reverse for lower peak transient memory.
+ * Change the constant directly if a real workload needs a different point on
+ * that curve — a per-host env var would let the margin get silently
+ * reintroduced by an operator with no way to know why 512MB is dangerous.
+ */
+exports.FLUSH_BYTES = 8 * 1024 * 1024;
+const shouldFlushCSVBuffer = (byteCount) => byteCount >= exports.FLUSH_BYTES;
+exports.shouldFlushCSVBuffer = shouldFlushCSVBuffer;
+/**
+ * Yield the event loop every N relationship rows during the emit pass (#2226 F4)
+ * so a concurrent node COPY (the overlap in loadGraphToLbug) and write-stream
+ * drain callbacks get scheduling time during long synchronous emit stretches.
+ * Scheduling-only — never changes row content or order (byte-identical). Tuning
+ * constant, not load-bearing.
+ */
+const REL_YIELD_EVERY = 5000;
+// ============================================================================
+// CSV ESCAPE UTILITIES
+// ============================================================================
+const sanitizeUTF8 = (str) => {
+    return str
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '')
+        .replace(/[\uD800-\uDFFF]/g, '')
+        .replace(/[\uFFFE\uFFFF]/g, '');
+};
+exports.sanitizeUTF8 = sanitizeUTF8;
+const escapeCSVField = (value) => {
+    if (value === undefined || value === null)
+        return '""';
+    let str = String(value);
+    str = (0, exports.sanitizeUTF8)(str);
+    return `"${str.replace(/"/g, '""')}"`;
+};
+exports.escapeCSVField = escapeCSVField;
+const escapeCSVNumber = (value, defaultValue = -1) => {
+    if (value === undefined || value === null)
+        return String(defaultValue);
+    return String(value);
+};
+exports.escapeCSVNumber = escapeCSVNumber;
+const formatCSVStringArray = (value) => {
+    const items = Array.isArray(value)
+        ? value.filter((item) => typeof item === 'string')
+        : [];
+    const unsafe = items.find((item) => /[,\[\]'"\n\r]/.test(item));
+    if (unsafe !== undefined) {
+        throw new Error(`Cannot safely encode CSV string-list item: ${JSON.stringify(unsafe)}`);
+    }
+    return `[${items.join(',')}]`;
+};
+// ============================================================================
+// CONTENT EXTRACTION (lazy — reads from disk on demand)
+// ============================================================================
+const isBinaryContent = (content) => {
+    if (!content || content.length === 0)
+        return false;
+    const sample = content.slice(0, 1000);
+    let nonPrintable = 0;
+    for (let i = 0; i < sample.length; i++) {
+        const code = sample.charCodeAt(i);
+        if (code < 9 || (code > 13 && code < 32) || code === 127)
+            nonPrintable++;
+    }
+    return nonPrintable / sample.length > 0.1;
+};
+exports.isBinaryContent = isBinaryContent;
+/**
+ * LRU content cache — avoids re-reading the same source file for every
+ * symbol defined in it. Sized generously so most files stay cached during
+ * the single-pass node iteration.
+ */
+class FileContentCache {
+    cache = new Map();
+    accessOrder = [];
+    maxSize;
+    repoPath;
+    constructor(repoPath, maxSize = 3000) {
+        this.repoPath = repoPath;
+        this.maxSize = maxSize;
+    }
+    async get(relativePath) {
+        if (!relativePath)
+            return '';
+        const cached = this.cache.get(relativePath);
+        if (cached !== undefined) {
+            // Move to end of accessOrder (LRU promotion)
+            const idx = this.accessOrder.indexOf(relativePath);
+            if (idx !== -1) {
+                this.accessOrder.splice(idx, 1);
+                this.accessOrder.push(relativePath);
+            }
+            return cached;
+        }
+        try {
+            const fullPath = path_1.default.join(this.repoPath, relativePath);
+            const content = await promises_1.default.readFile(fullPath, 'utf-8');
+            this.set(relativePath, content);
+            return content;
+        }
+        catch {
+            this.set(relativePath, '');
+            return '';
+        }
+    }
+    set(key, value) {
+        if (this.cache.size >= this.maxSize) {
+            const oldest = this.accessOrder.shift();
+            if (oldest)
+                this.cache.delete(oldest);
+        }
+        this.cache.set(key, value);
+        this.accessOrder.push(key);
+    }
+}
+/**
+ * Flatten newlines and tabs to single spaces for the stored text columns
+ * (`content`, `description`), so stored file/symbol text is uniformly
+ * space-separated (#2317). This rewrites the STORED column too (the same
+ * value is COPYed in), so File content returned via the graph API is
+ * space-flattened. Leading/trailing/empty are no-ops.
+ */
+const normalizeFtsText = (text) => text.replace(/[\r\n\t]+/g, ' ');
+exports.normalizeFtsText = normalizeFtsText;
+/** Normalizes the `description` column — one place for the six emission sites below to call, instead of repeating the transform. */
+const formatFtsDescription = (description) => (0, exports.normalizeFtsText)(description);
+// Labels that get exact source-span content (no ±2 window). Single source of
+// truth in `symbol-labels.ts` — see there for why the exactness depends on the
+// 0-based line invariant. Kept as a named alias to read intent at the use site.
+const EXACT_SYMBOL_CONTENT_LABELS = symbol_labels_js_1.SYMBOL_NODE_LABELS;
+const extractContent = async (node, contentCache) => {
+    const filePath = node.properties.filePath;
+    const content = await contentCache.get(filePath);
+    if (!content)
+        return '';
+    if (node.label === 'Folder')
+        return '';
+    if ((0, exports.isBinaryContent)(content))
+        return '[Binary file - content not stored]';
+    // File content is stored in full — intentionally NOT length-capped here
+    // (#2317). It is already bounded upstream by the walker's max-file-size cap
+    // (512KB default / 32MB), and only whitespace-normalized. The symbol snippet
+    // path below, by contrast, deliberately stays capped at MAX_SNIPPET.
+    if (node.label === 'File') {
+        return (0, exports.normalizeFtsText)(content);
+    }
+    const startLine = node.properties.startLine;
+    const endLine = node.properties.endLine;
+    if (startLine === undefined || endLine === undefined)
+        return '';
+    const lines = content.split('\n');
+    const exactSymbolContent = EXACT_SYMBOL_CONTENT_LABELS.has(node.label);
+    const start = Math.max(0, exactSymbolContent ? startLine : startLine - 2);
+    const end = Math.min(lines.length - 1, exactSymbolContent ? endLine : endLine + 2);
+    const snippet = lines.slice(start, end + 1).join('\n');
+    const MAX_SNIPPET = 5000;
+    const capped = snippet.length > MAX_SNIPPET ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]' : snippet;
+    return (0, exports.normalizeFtsText)(capped);
+};
+// ============================================================================
+// BUFFERED CSV WRITER
+// ============================================================================
+class BufferedCSVWriter {
+    ws;
+    buffer = [];
+    bufferedBytes = 0;
+    rows = 0;
+    constructor(filePath, header) {
+        this.ws = (0, fs_1.createWriteStream)(filePath, 'utf-8');
+        // Large repos flush many times — raise listener cap to avoid MaxListenersExceededWarning
+        this.ws.setMaxListeners(50);
+        this.buffer.push(header);
+        this.bufferedBytes = Buffer.byteLength(header) + 1;
+    }
+    /**
+     * Buffer a row. Returns a promise ONLY when the buffer crossed FLUSH_BYTES
+     * and a disk write was issued; otherwise returns `undefined` so the caller
+     * can skip awaiting (#2203 U3) — avoiding a microtask tick on every buffered
+     * row (millions at scale). The flush promise still resolves on drain, so
+     * backpressure is preserved on the rows that actually write.
+     */
+    addRow(row) {
+        this.buffer.push(row);
+        this.bufferedBytes += Buffer.byteLength(row) + 1;
+        this.rows++;
+        if ((0, exports.shouldFlushCSVBuffer)(this.bufferedBytes)) {
+            return this.flush();
+        }
+        return undefined;
+    }
+    flush() {
+        if (this.buffer.length === 0)
+            return Promise.resolve();
+        const chunk = this.buffer.join('\n') + '\n';
+        this.buffer.length = 0;
+        this.bufferedBytes = 0;
+        return new Promise((resolve, reject) => {
+            this.ws.once('error', reject);
+            const ok = this.ws.write(chunk);
+            if (ok) {
+                this.ws.removeListener('error', reject);
+                resolve();
+            }
+            else {
+                this.ws.once('drain', () => {
+                    this.ws.removeListener('error', reject);
+                    resolve();
+                });
+            }
+        });
+    }
+    async finish() {
+        await this.flush();
+        return new Promise((resolve, reject) => {
+            this.ws.end(() => resolve());
+            this.ws.on('error', reject);
+        });
+    }
+}
+// ============================================================================
+// STREAMING CSV GENERATION — SINGLE PASS
+// ============================================================================
+/** Canonical relationship CSV header — shared by the emit pass and the
+ * `splitRelCsvByLabelPair` differential oracle. */
+exports.REL_CSV_HEADER = 'from,to,type,confidence,reason,step';
+/** Build the escaped CSV row (no trailing newline) for one relationship.
+ * Single source of the relationship row bytes — used by the emit pass and by
+ * the byte-identity differential test that feeds the legacy split oracle. */
+const buildRelRow = (rel) => [
+    (0, exports.escapeCSVField)(rel.sourceId),
+    (0, exports.escapeCSVField)(rel.targetId),
+    (0, exports.escapeCSVField)(rel.type),
+    (0, exports.escapeCSVNumber)(rel.confidence, 1.0),
+    (0, exports.escapeCSVField)(rel.reason),
+    (0, exports.escapeCSVNumber)(rel.step, 0),
+].join(',');
+exports.buildRelRow = buildRelRow;
+/** Canonical BasicBlock node CSV header — taint/PDG substrate (issue #2080).
+ * No `name` column; blocks are identified by id + source span. Shared by the
+ * whole-graph emit pass and the streaming PDG emit sink (issue #2202) so the
+ * two paths produce byte-identical BasicBlock rows by construction. */
+exports.BASICBLOCK_CSV_HEADER = 'id,filePath,startLine,endLine,text,callees,calleeIds';
+/** Build the escaped CSV row (no trailing newline) for one BasicBlock node.
+ * Single source of the BasicBlock row bytes — used by `streamAllCSVsToDisk`
+ * and by the streaming `PdgEmitSink` (issue #2202). `callees` is a comma-free
+ * (space-joined) list of the leaf callee names invoked in the block — the
+ * statement-precise inter-procedural reach substrate (the field is itself a CSV
+ * cell, so the inner separator must NOT be a comma). `calleeIds` is the SOUND
+ * parallel to `callees`: the space-joined RESOLVED callee symbol ids for the
+ * block (#2227 follow-up), likewise a comma-free cell. */
+const buildBasicBlockRow = (node) => [
+    (0, exports.escapeCSVField)(node.id),
+    (0, exports.escapeCSVField)(node.properties.filePath || ''),
+    (0, exports.escapeCSVNumber)(node.properties.startLine, -1),
+    (0, exports.escapeCSVNumber)(node.properties.endLine, -1),
+    (0, exports.escapeCSVField)(node.properties.text || ''),
+    (0, exports.escapeCSVField)(String(node.properties.callees ?? '')),
+    (0, exports.escapeCSVField)(String(node.properties.calleeIds ?? '')),
+].join(',');
+exports.buildBasicBlockRow = buildBasicBlockRow;
+/**
+ * Stream all CSV data directly to disk files.
+ * Iterates graph nodes exactly ONCE — routes each node to the right writer.
+ * File contents are lazy-read from disk with a generous LRU cache.
+ *
+ * `onNodePhaseComplete` (optional, #2203 parallelism leg): fired exactly once,
+ * right after every node CSV is fully flushed to disk and BEFORE the
+ * relationship pass starts writing any `rel_*.csv`. It receives the finished
+ * node-file manifest so the caller can begin `COPY`-ing nodes while this
+ * function keeps generating relationship CSVs (the only single-writer-safe
+ * overlap — node `COPY` ‖ relationship emit). It is intentionally NOT awaited:
+ * the relationship pass proceeds concurrently with whatever the caller
+ * schedules. A synchronous throw from the callback is allowed and propagates out
+ * of this function (rejecting the returned promise) — it is raised before the
+ * relationship pass begins, so no `rel_*.csv` is written; `loadGraphToLbug` uses
+ * this to surface its PDG-manifest collision guard. The callback must NOT, however,
+ * schedule un-awaited async work that can reject unobserved. Absent ⇒ today's
+ * behavior, byte-for-byte.
+ */
+const streamAllCSVsToDisk = async (graph, repoPath, csvDir, onNodePhaseComplete) => {
+    // Deterministic (id-sorted) node/relationship row order when enabled;
+    // default off = today's graph-insertion order (byte-identical).
+    const sortOutput = (0, env_js_1.parseTruthyEnv)(process.env.CGRAPH_SORT_GRAPH_OUTPUT);
+    // Remove stale CSVs from previous crashed runs, then recreate
+    try {
+        await promises_1.default.rm(csvDir, { recursive: true, force: true });
+    }
+    catch { }
+    await promises_1.default.mkdir(csvDir, { recursive: true });
+    // We open ~30 concurrent write-streams; raise process limit to suppress
+    // MaxListenersExceededWarning (restored after all streams finish).
+    const prevMax = process.getMaxListeners();
+    process.setMaxListeners(prevMax + 40);
+    // try/finally so the listener bump is ALWAYS restored — including the
+    // rel-routing throw path (#2203 U2) and any node-writer finish() rejection,
+    // not just the success path (avoids leaking +40 listeners across failed runs
+    // in long-lived hosts / the test suite).
+    try {
+        const contentCache = new FileContentCache(repoPath);
+        // Create writers for every node type up-front
+        const fileWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'file.csv'), 'id,name,filePath,content');
+        const folderWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'folder.csv'), 'id,name,filePath');
+        const codeElementHeader = 'id,name,filePath,startLine,endLine,isExported,content,description';
+        const functionWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'function.csv'), codeElementHeader);
+        const classWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'class.csv'), `${codeElementHeader},frameworkAnnotations`);
+        const interfaceWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'interface.csv'), codeElementHeader);
+        const methodHeader = 'id,name,filePath,startLine,endLine,isExported,content,description,parameterCount,returnType';
+        const methodWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'method.csv'), methodHeader);
+        const codeElemWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'codeelement.csv'), codeElementHeader);
+        const communityWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'community.csv'), 'id,label,heuristicLabel,keywords,description,enrichedBy,cohesion,symbolCount');
+        const processWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'process.csv'), 'id,label,heuristicLabel,processType,stepCount,communities,entryPointId,terminalId');
+        // Section nodes have an extra 'level' column
+        const sectionWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'section.csv'), 'id,name,filePath,startLine,endLine,level,content,description');
+        // Route nodes for API endpoint mapping
+        const routeWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'route.csv'), 'id,name,filePath,responseKeys,errorKeys,middleware,method,handlerSymbolId');
+        // Tool nodes for MCP tool definitions
+        const toolWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'tool.csv'), 'id,name,filePath,description');
+        // BasicBlock nodes — taint/PDG substrate (issue #2080). No `name` column;
+        // blocks are identified by id + source span. Emitted by no phase yet.
+        const basicBlockWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'basicblock.csv'), exports.BASICBLOCK_CSV_HEADER);
+        // Multi-language node types share the same CSV shape (no isExported column)
+        const multiLangHeader = 'id,name,filePath,startLine,endLine,content,description';
+        const MULTI_LANG_TYPES = [
+            'Struct',
+            'Enum',
+            'Macro',
+            'Typedef',
+            'Union',
+            'Namespace',
+            'Trait',
+            'Impl',
+            'TypeAlias',
+            'Const',
+            'Static',
+            'Variable',
+            'Property',
+            'Record',
+            'Delegate',
+            'Annotation',
+            'Constructor',
+            'Template',
+            'Module',
+        ];
+        const propertyHeader = 'id,name,filePath,startLine,endLine,content,description,declaredType';
+        const multiLangWriters = new Map();
+        for (const t of MULTI_LANG_TYPES) {
+            multiLangWriters.set(t, new BufferedCSVWriter(path_1.default.join(csvDir, `${t.toLowerCase()}.csv`), t === 'Property' ? propertyHeader : multiLangHeader));
+        }
+        // ExternalService 节点 —— spec §6.1 单边情形的合成外部 RPC 服务端点。
+        // rpc-edges / http-api-calls 阶段在仅有一侧(消费方或提供方)落在仓库内时
+        // 生成它,使 RCALLS / HTTP_CALLS 边始终可解析、impact 能追踪外部依赖。列形态
+        // 与 EXTERNAL_SERVICE_SCHEMA 一致(通用 code-element 形,复用 multiLangHeader),
+        // 故 getCopyQuery 默认分支与 deleteNodesForFile 的 filePath 表过滤均无需改动 ——
+        // 此前仅缺本处 emit 接线,导致节点被 switch default 的"未知标签"分支静默丢弃。
+        const externalServiceWriter = new BufferedCSVWriter(path_1.default.join(csvDir, 'externalservice.csv'), multiLangHeader);
+        const codeWriterMap = {
+            Function: functionWriter,
+            Class: classWriter,
+            Interface: interfaceWriter,
+            CodeElement: codeElemWriter,
+        };
+        // Deduplicate all node types — the pipeline can produce duplicate IDs across
+        // all symbol types (Class, Method, Function, etc.), not just File nodes.
+        // A single Set covering every label prevents PK violations on COPY.
+        const seenNodeIds = new Set();
+        // --- SINGLE PASS over all nodes ---
+        for (const node of orderedNodes(graph, sortOutput)) {
+            if (seenNodeIds.has(node.id))
+                continue;
+            seenNodeIds.add(node.id);
+            // addRow returns a promise only when it flushes; awaiting it once after the
+            // switch (instead of `await`-ing every addRow) skips a per-row microtask
+            // tick on the rows buffered between byte-bounded flushes (#2203 U3).
+            let pending;
+            switch (node.label) {
+                case 'File': {
+                    const content = await extractContent(node, contentCache);
+                    pending = fileWriter.addRow([
+                        (0, exports.escapeCSVField)(node.id),
+                        (0, exports.escapeCSVField)(node.properties.name || ''),
+                        (0, exports.escapeCSVField)(node.properties.filePath || ''),
+                        (0, exports.escapeCSVField)(content),
+                    ].join(','));
+                    break;
+                }
+                case 'Folder':
+                    pending = folderWriter.addRow([
+                        (0, exports.escapeCSVField)(node.id),
+                        (0, exports.escapeCSVField)(node.properties.name || ''),
+                        (0, exports.escapeCSVField)(node.properties.filePath || ''),
+                    ].join(','));
+                    break;
+                case 'Community': {
+                    const keywords = node.properties.keywords || [];
+                    const keywordsStr = `[${keywords.map((k) => `'${k.replace(/\\/g, '\\\\').replace(/'/g, "''").replace(/,/g, '\\,')}'`).join(',')}]`;
+                    pending = communityWriter.addRow([
+                        (0, exports.escapeCSVField)(node.id),
+                        (0, exports.escapeCSVField)(node.properties.name || ''),
+                        (0, exports.escapeCSVField)(node.properties.heuristicLabel || ''),
+                        keywordsStr,
+                        (0, exports.escapeCSVField)(formatFtsDescription(node.properties.description || '')),
+                        (0, exports.escapeCSVField)(node.properties.enrichedBy || 'heuristic'),
+                        (0, exports.escapeCSVNumber)(node.properties.cohesion, 0),
+                        (0, exports.escapeCSVNumber)(node.properties.symbolCount, 0),
+                    ].join(','));
+                    break;
+                }
+                case 'Process': {
+                    const communities = node.properties.communities || [];
+                    const communitiesStr = `[${communities.map((c) => `'${c.replace(/'/g, "''")}'`).join(',')}]`;
+                    pending = processWriter.addRow([
+                        (0, exports.escapeCSVField)(node.id),
+                        (0, exports.escapeCSVField)(node.properties.name || ''),
+                        (0, exports.escapeCSVField)(node.properties.heuristicLabel || ''),
+                        (0, exports.escapeCSVField)(node.properties.processType || ''),
+                        (0, exports.escapeCSVNumber)(node.properties.stepCount, 0),
+                        (0, exports.escapeCSVField)(communitiesStr),
+                        (0, exports.escapeCSVField)(node.properties.entryPointId || ''),
+                        (0, exports.escapeCSVField)(node.properties.terminalId || ''),
+                    ].join(','));
+                    break;
+                }
+                case 'Method': {
+                    const content = await extractContent(node, contentCache);
+                    pending = methodWriter.addRow([
+                        (0, exports.escapeCSVField)(node.id),
+                        (0, exports.escapeCSVField)(node.properties.name || ''),
+                        (0, exports.escapeCSVField)(node.properties.filePath || ''),
+                        (0, exports.escapeCSVNumber)(node.properties.startLine, -1),
+                        (0, exports.escapeCSVNumber)(node.properties.endLine, -1),
+                        node.properties.isExported ? 'true' : 'false',
+                        (0, exports.escapeCSVField)(content),
+                        (0, exports.escapeCSVField)(formatFtsDescription(node.properties.description || '')),
+                        (0, exports.escapeCSVNumber)(node.properties.parameterCount, 0),
+                        (0, exports.escapeCSVField)(node.properties.returnType || ''),
+                    ].join(','));
+                    break;
+                }
+                case 'Section': {
+                    const content = await extractContent(node, contentCache);
+                    pending = sectionWriter.addRow([
+                        (0, exports.escapeCSVField)(node.id),
+                        (0, exports.escapeCSVField)(node.properties.name || ''),
+                        (0, exports.escapeCSVField)(node.properties.filePath || ''),
+                        (0, exports.escapeCSVNumber)(node.properties.startLine, -1),
+                        (0, exports.escapeCSVNumber)(node.properties.endLine, -1),
+                        (0, exports.escapeCSVNumber)(node.properties.level, 1),
+                        (0, exports.escapeCSVField)(content),
+                        (0, exports.escapeCSVField)(formatFtsDescription(node.properties.description || '')),
+                    ].join(','));
+                    break;
+                }
+                case 'Route': {
+                    const responseKeys = node.properties.responseKeys || [];
+                    // LadybugDB array literal inside a quoted CSV field: escapeCSVField wraps in "..."
+                    // and the array uses single-quoted elements
+                    const keysStr = `[${responseKeys.map((k) => `'${k.replace(/'/g, "''")}'`).join(',')}]`;
+                    const errorKeys = node.properties.errorKeys || [];
+                    const errorKeysStr = `[${errorKeys.map((k) => `'${k.replace(/'/g, "''")}'`).join(',')}]`;
+                    const middleware = node.properties.middleware || [];
+                    const middlewareStr = `[${middleware.map((m) => `'${m.replace(/'/g, "''")}'`).join(',')}]`;
+                    pending = routeWriter.addRow([
+                        (0, exports.escapeCSVField)(node.id),
+                        (0, exports.escapeCSVField)(node.properties.name || ''),
+                        (0, exports.escapeCSVField)(node.properties.filePath || ''),
+                        (0, exports.escapeCSVField)(keysStr),
+                        (0, exports.escapeCSVField)(errorKeysStr),
+                        (0, exports.escapeCSVField)(middlewareStr),
+                        (0, exports.escapeCSVField)(String(node.properties.method ?? '')),
+                        (0, exports.escapeCSVField)(String(node.properties.handlerSymbolId ?? '')),
+                    ].join(','));
+                    break;
+                }
+                case 'Tool':
+                    pending = toolWriter.addRow([
+                        (0, exports.escapeCSVField)(node.id),
+                        (0, exports.escapeCSVField)(node.properties.name || ''),
+                        (0, exports.escapeCSVField)(node.properties.filePath || ''),
+                        (0, exports.escapeCSVField)(formatFtsDescription(node.properties.description || '')),
+                    ].join(','));
+                    break;
+                case 'BasicBlock':
+                    pending = basicBlockWriter.addRow((0, exports.buildBasicBlockRow)(node));
+                    break;
+                case 'ExternalService': {
+                    // 合成外部 RPC 服务节点(无源码):content 取空,行/列为 -1,其余字段
+                    // 直接取 node.properties,列序与 multiLangHeader 严格对齐。
+                    const content = await extractContent(node, contentCache);
+                    pending = externalServiceWriter.addRow([
+                        (0, exports.escapeCSVField)(node.id),
+                        (0, exports.escapeCSVField)(node.properties.name || ''),
+                        (0, exports.escapeCSVField)(node.properties.filePath || ''),
+                        (0, exports.escapeCSVNumber)(node.properties.startLine, -1),
+                        (0, exports.escapeCSVNumber)(node.properties.endLine, -1),
+                        (0, exports.escapeCSVField)(content),
+                        (0, exports.escapeCSVField)(formatFtsDescription(node.properties.description || '')),
+                    ].join(','));
+                    break;
+                }
+                default: {
+                    // Code element nodes (Function, Class, Interface, CodeElement)
+                    const writer = codeWriterMap[node.label];
+                    if (writer) {
+                        const content = await extractContent(node, contentCache);
+                        const row = [
+                            (0, exports.escapeCSVField)(node.id),
+                            (0, exports.escapeCSVField)(node.properties.name || ''),
+                            (0, exports.escapeCSVField)(node.properties.filePath || ''),
+                            (0, exports.escapeCSVNumber)(node.properties.startLine, -1),
+                            (0, exports.escapeCSVNumber)(node.properties.endLine, -1),
+                            node.properties.isExported ? 'true' : 'false',
+                            (0, exports.escapeCSVField)(content),
+                            (0, exports.escapeCSVField)(formatFtsDescription(node.properties.description || '')),
+                        ];
+                        if (node.label === 'Class') {
+                            row.push((0, exports.escapeCSVField)(formatCSVStringArray(node.properties.frameworkAnnotations)));
+                        }
+                        pending = writer.addRow(row.join(','));
+                    }
+                    else {
+                        // Multi-language node types (Struct, Impl, Trait, Macro, etc.)
+                        const mlWriter = multiLangWriters.get(node.label);
+                        if (mlWriter) {
+                            const content = await extractContent(node, contentCache);
+                            pending = mlWriter.addRow([
+                                (0, exports.escapeCSVField)(node.id),
+                                (0, exports.escapeCSVField)(node.properties.name || ''),
+                                (0, exports.escapeCSVField)(node.properties.filePath || ''),
+                                (0, exports.escapeCSVNumber)(node.properties.startLine, -1),
+                                (0, exports.escapeCSVNumber)(node.properties.endLine, -1),
+                                (0, exports.escapeCSVField)(content),
+                                (0, exports.escapeCSVField)(formatFtsDescription(node.properties.description || '')),
+                                ...(node.label === 'Property'
+                                    ? [(0, exports.escapeCSVField)(node.properties.declaredType || '')]
+                                    : []),
+                            ].join(','));
+                        }
+                        else {
+                            // Unknown label: not in codeWriterMap or multiLangWriters, so there
+                            // is no CSV table for it and it is intentionally NOT persisted —
+                            // `pending` stays undefined, so the loop awaits nothing. Made
+                            // explicit so a future node type isn't silently dropped here: wire
+                            // it into one of the writer maps above (or this branch).
+                        }
+                    }
+                    break;
+                }
+            }
+            if (pending)
+                await pending;
+        }
+        // Finish all node writers
+        const allWriters = [
+            fileWriter,
+            folderWriter,
+            functionWriter,
+            classWriter,
+            interfaceWriter,
+            methodWriter,
+            codeElemWriter,
+            communityWriter,
+            processWriter,
+            sectionWriter,
+            routeWriter,
+            toolWriter,
+            basicBlockWriter,
+            externalServiceWriter,
+            ...multiLangWriters.values(),
+        ];
+        await Promise.all(allWriters.map((w) => w.finish()));
+        // Build the node-file manifest now (all writers are flushed; `.rows` is
+        // final). Hoisted above the relationship pass so `onNodePhaseComplete` can
+        // hand the caller a complete node manifest to start COPY-ing while we keep
+        // generating relationship CSVs below (#2203 overlap). The same map is
+        // returned, so the result is unchanged when no callback is supplied.
+        const nodeFiles = new Map();
+        const tableMap = [
+            ['File', fileWriter],
+            ['Folder', folderWriter],
+            ['Function', functionWriter],
+            ['Class', classWriter],
+            ['Interface', interfaceWriter],
+            ['Method', methodWriter],
+            ['CodeElement', codeElemWriter],
+            ['Community', communityWriter],
+            ['Process', processWriter],
+            ['Section', sectionWriter],
+            ['Route', routeWriter],
+            ['Tool', toolWriter],
+            ['BasicBlock', basicBlockWriter],
+            ['ExternalService', externalServiceWriter],
+            ...Array.from(multiLangWriters.entries()).map(([name, w]) => [name, w]),
+        ];
+        for (const [name, writer] of tableMap) {
+            if (writer.rows > 0) {
+                nodeFiles.set(name, {
+                    csvPath: path_1.default.join(csvDir, `${name.toLowerCase()}.csv`),
+                    rows: writer.rows,
+                });
+            }
+        }
+        // Node CSVs are on disk; relationship CSVs have not been touched yet. Hand
+        // the manifest to the caller (not awaited — the rel pass runs concurrently).
+        onNodePhaseComplete?.(nodeFiles);
+        // --- Stream relationships directly to per-FROM→TO-label-pair files ---
+        // (#2203 U2) Route every edge to its pair file in this single pass. The old
+        // monolithic relations.csv — and its line-by-line re-read + per-edge regex
+        // re-split in loadGraphToLbug — are gone, so the ~1M-edge set is written and
+        // read once instead of twice. The router applies the SAME label-derivation +
+        // validTables filter as the legacy splitRelCsvByLabelPair, so the per-pair
+        // files are byte-identical (asserted by the differential test).
+        const relRouter = new rel_pair_routing_js_1.RelPairRouter(csvDir, exports.REL_CSV_HEADER, rel_pair_routing_js_1.VALID_NODE_TABLES, exports.DECLARED_RELATION_PAIRS);
+        try {
+            let emitted = 0;
+            for (const rel of orderedRelationships(graph, sortOutput)) {
+                const pending = relRouter.route(rel.sourceId, rel.targetId, (0, exports.buildRelRow)(rel), rel.type);
+                if (pending)
+                    await pending;
+                // Periodically hand the event loop back so the overlapped node COPY and
+                // write-stream drains run instead of starving behind this synchronous
+                // loop (#2226 F4). No effect on emitted bytes — pure scheduling.
+                if (++emitted % REL_YIELD_EVERY === 0)
+                    await new Promise((r) => setImmediate(r));
+            }
+            await relRouter.close();
+        }
+        catch (err) {
+            relRouter.destroy();
+            // Rethrow the real stream error (EMFILE / disk-full) rather than the generic
+            // AbortError a pending drain-await rejects with — mirrors the retained
+            // splitRelCsvByLabelPair's `throw streamError ?? err`.
+            throw relRouter.lastError ?? err;
+        }
+        return {
+            nodeFiles,
+            relsByPair: relRouter.byPair,
+            relHeader: exports.REL_CSV_HEADER,
+            skippedRels: relRouter.skipped,
+            totalValidRels: relRouter.total,
+        };
+    }
+    finally {
+        // Restore original process listener limit on every path (success or throw).
+        process.setMaxListeners(prevMax);
+    }
+};
+exports.streamAllCSVsToDisk = streamAllCSVsToDisk;