@veewo/gitnexus 1.3.9 → 1.3.11-rc.1

package/dist/core/ingestion/unity-resource-processor.test.js

@@ -8,7 +8,7 @@ import { processUnityResources } from './unity-resource-processor.js';
 const here = path.dirname(fileURLToPath(import.meta.url));
 const fixtureRoot = path.resolve(here, '../../../src/core/unity/__fixtures__/mini-unity');
 const symbols = ['Global', 'BattleMode', 'PlayerActor', 'MainUIManager'];
-test('processUnityResources adds Unity resource relationships and component payload nodes', async () => {
+test('processUnityResources does not emit UNITY_COMPONENT_IN or synthetic resource File nodes', async () => {
     const graph = createKnowledgeGraph();
     for (const symbol of symbols) {
         const filePath = `Assets/Scripts/${symbol}.cs`;
@@ -41,13 +41,17 @@ test('processUnityResources adds Unity resource relationships and component payl
     }
     const result = await processUnityResources(graph, { repoPath: fixtureRoot });
     const unityFileRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_COMPONENT_IN');
-    const unityInstanceRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_COMPONENT_INSTANCE');
-    const componentNodes = [...graph.iterNodes()].filter((node) => node.label === 'CodeElement' && /\.(unity|prefab)$/.test(String(node.properties.filePath)));
-    assert.ok(unityFileRelations.length > 0);
-    assert.ok(unityInstanceRelations.length > 0);
-    assert.ok(componentNodes.length > 0);
-    assert.ok(componentNodes.some((node) => String(node.properties.description).includes('mainUIDocument')));
+    const unitySummaryRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    const syntheticResourceFiles = [...graph.iterNodes()].filter((node) => node.label === 'File' && /\.(prefab|unity|asset)$/.test(String(node.properties.filePath)));
+    const componentNodes = [...graph.iterNodes()].filter((node) => node.label === 'CodeElement');
+    assert.equal(result.bindingCount > 0, true);
+    assert.equal(unityFileRelations.length, 0);
+    assert.equal(syntheticResourceFiles.length, 0);
+    assert.ok(unitySummaryRelations.length > 0);
+    assert.equal(componentNodes.length, 0);
     assert.ok(result.bindingCount >= symbols.length);
+    assert.equal(result.paritySeed?.version, 1);
+    assert.ok((result.paritySeed?.scriptPathToGuid || {})['Assets/Scripts/MainUIManager.cs']);
     assert.ok(result.timingsMs.scanContext >= 0);
     assert.ok(result.timingsMs.resolve >= 0);
     assert.ok(result.timingsMs.graphWrite > 0);
@@ -248,7 +252,7 @@ test('processUnityResources memoizes resolve results by symbol within one run',
     assert.equal(result.bindingCount, 1);
     assert.ok(result.diagnostics.some((line) => line.includes('skip-non-canonical=1')));
 });
-test('processUnityResources writes UNITY_COMPONENT_INSTANCE only for canonical class node', async () => {
+test('processUnityResources writes UNITY_RESOURCE_SUMMARY only for canonical class node', async () => {
     const graph = createKnowledgeGraph();
     const canonicalPath = 'Assets/Scripts/PlayerActor.cs';
     const partialPath = 'Assets/Scripts/PlayerActor.Visual.cs';
@@ -294,15 +298,15 @@ test('processUnityResources writes UNITY_COMPONENT_INSTANCE only for canonical c
             unityDiagnostics: [],
         }),
     });
-    const instanceRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_COMPONENT_INSTANCE');
-    assert.equal(instanceRelations.length, 1);
-    assert.equal(instanceRelations[0]?.sourceId, canonicalClassId);
+    const summaryRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    assert.equal(summaryRelations.length, 1);
+    assert.equal(summaryRelations[0]?.sourceId, canonicalClassId);
     assert.equal(result.processedSymbols, 1);
     assert.equal(result.bindingCount, 1);
     assert.ok(result.diagnostics.some((line) => line.includes('selected=1')));
     assert.ok(result.diagnostics.some((line) => line.includes('skip-non-canonical=1')));
 });
-test('processUnityResources writes UNITY_SERIALIZED_TYPE_IN for serializable class field matches', async () => {
+test('processUnityResources writes UNITY_RESOURCE_SUMMARY for serializable class field matches', async () => {
     const graph = createKnowledgeGraph();
     const hostPath = 'Assets/Scripts/HostClass.cs';
     const serializablePath = 'Assets/Scripts/AssetRef.cs';
@@ -364,11 +368,11 @@ test('processUnityResources writes UNITY_SERIALIZED_TYPE_IN for serializable cla
             unityDiagnostics: [],
         }),
     });
-    const serializedTypeEdges = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_SERIALIZED_TYPE_IN');
-    assert.equal(serializedTypeEdges.length, 1);
-    assert.equal(serializedTypeEdges[0]?.sourceId, serializableClassId);
+    const summaryRelations = [...graph.iterRelationships()].filter((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    const serializableSummary = summaryRelations.filter((rel) => rel.sourceId === serializableClassId);
+    assert.equal(serializableSummary.length, 1);
 });
-test('processUnityResources writes compact unity payload by default', async () => {
+test('processUnityResources writes compact UNITY_RESOURCE_SUMMARY reason by default', async () => {
     const graph = createKnowledgeGraph();
     const classId = generateId('Class', 'Assets/Scripts/Compact.cs:CompactSymbol');
     graph.addNode({
@@ -407,17 +411,14 @@ test('processUnityResources writes compact unity payload by default', async () =
             unityDiagnostics: [],
         }),
     });
-    const component = [...graph.iterNodes()].find((node) => node.label === 'CodeElement');
-    assert.ok(component);
-    const payload = JSON.parse(String(component.properties.description));
-    assert.equal(payload.bindingKind, 'scene-override');
-    assert.equal(payload.componentObjectId, '11400000');
-    assert.ok(Array.isArray(payload.serializedFields.scalarFields));
-    assert.equal(payload.resourcePath, undefined);
-    assert.equal(payload.resourceType, undefined);
-    assert.equal(payload.evidence, undefined);
+    const summary = [...graph.iterRelationships()].find((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    assert.ok(summary);
+    const reason = JSON.parse(String(summary.reason || '{}'));
+    assert.deepEqual(reason.bindingKinds, ['scene-override']);
+    assert.equal(reason.lightweight, true);
+    assert.equal(reason.resourceType, 'scene');
 });
-test('processUnityResources includes structured assetRefPaths in component payload', async () => {
+test('processUnityResources keeps UNITY_RESOURCE_SUMMARY reason compact when bindings include assetRefPaths', async () => {
     const graph = createKnowledgeGraph();
     const classId = generateId('Class', 'Assets/Scripts/CharacterList.cs:CharacterList');
     graph.addNode({
@@ -464,14 +465,11 @@ test('processUnityResources includes structured assetRefPaths in component paylo
             unityDiagnostics: [],
         }),
     });
-    const component = [...graph.iterNodes()].find((node) => node.label === 'CodeElement');
-    assert.ok(component);
-    const payload = JSON.parse(String(component.properties.description));
-    assert.equal(payload.assetRefPaths?.length, 1);
-    assert.equal(payload.assetRefPaths?.[0]?.fieldName, '_Head_Ref');
-    assert.equal(payload.assetRefPaths?.[0]?.isSprite, true);
+    const summary = [...graph.iterRelationships()].find((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    assert.ok(summary);
+    assert.equal(String(summary.reason).includes('assetRefPaths'), false);
 });
-test('processUnityResources writes full unity payload when payloadMode=full', async () => {
+test('processUnityResources summary-only persistence ignores full payload mode and keeps summary reason', async () => {
     const graph = createKnowledgeGraph();
     const classId = generateId('Class', 'Assets/Scripts/Full.cs:FullSymbol');
     graph.addNode({
@@ -507,12 +505,12 @@ test('processUnityResources writes full unity payload when payloadMode=full', as
             unityDiagnostics: [],
         }),
     });
-    const component = [...graph.iterNodes()].find((node) => node.label === 'CodeElement');
-    assert.ok(component);
-    const payload = JSON.parse(String(component.properties.description));
-    assert.equal(payload.resourcePath, 'Assets/Scene/Test.unity');
-    assert.equal(payload.resourceType, 'scene');
-    assert.equal(payload.evidence?.line, 9);
+    const summary = [...graph.iterRelationships()].find((rel) => rel.type === 'UNITY_RESOURCE_SUMMARY');
+    assert.ok(summary);
+    const reason = JSON.parse(String(summary.reason || '{}'));
+    assert.equal(reason.resourceType, 'scene');
+    assert.deepEqual(reason.bindingKinds, ['scene-override']);
+    assert.equal(String(summary.reason).includes('evidence'), false);
 });
 test('processUnityResources aggregates repetitive diagnostics with capped samples', async () => {
     const graph = createKnowledgeGraph();

package/dist/core/kuzu/csv-generator.d.ts

@@ -11,8 +11,27 @@
  * - Double quotes within fields are escaped by doubling them ("")
  * - All fields are consistently quoted for safety with code content
  */
-import { KnowledgeGraph } from '../graph/types.js';
+import { KnowledgeGraph, GraphNode } from '../graph/types.js';
 import { NodeTableName } from './schema.js';
+/**
+ * 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.
+ */
+export declare class FileContentCache {
+    private repoPath;
+    private maxBytes;
+    private cache;
+    private currentBytes;
+    constructor(repoPath: string, maxBytes?: number);
+    get(relativePath: string): Promise<string>;
+    setForTest(key: string, value: string): void;
+    hasForTest(key: string): boolean;
+    private touch;
+    private set;
+    private evictIfNeeded;
+}
+export declare function toCodeElementCsvRow(node: GraphNode, contentCache?: FileContentCache): Promise<string>;
 export interface StreamedCSVResult {
     nodeFiles: Map<NodeTableName, {
         csvPath: string;

package/dist/core/kuzu/csv-generator.js

@@ -39,6 +39,7 @@ const escapeCSVNumber = (value, defaultValue = -1) => {
         return String(defaultValue);
     return String(value);
 };
+const UNITY_RESOURCE_PATH_PATTERN = /\.(prefab|unity|asset)$/i;
 // ============================================================================
 // CONTENT EXTRACTION (lazy — reads from disk on demand)
 // ============================================================================
@@ -59,21 +60,23 @@ const isBinaryContent = (content) => {
  * symbol defined in it. Sized generously so most files stay cached during
  * the single-pass node iteration.
  */
-class FileContentCache {
-    cache = new Map();
-    accessOrder = [];
-    maxSize;
+export class FileContentCache {
     repoPath;
-    constructor(repoPath, maxSize = 3000) {
+    maxBytes;
+    cache = new Map();
+    currentBytes = 0;
+    constructor(repoPath, maxBytes = 128 * 1024 * 1024) {
         this.repoPath = repoPath;
-        this.maxSize = maxSize;
+        this.maxBytes = maxBytes;
     }
     async get(relativePath) {
         if (!relativePath)
             return '';
         const cached = this.cache.get(relativePath);
-        if (cached !== undefined)
-            return cached;
+        if (cached !== undefined) {
+            this.touch(relativePath, cached);
+            return cached.content;
+        }
         try {
             const fullPath = path.join(this.repoPath, relativePath);
             const content = await fs.readFile(fullPath, 'utf-8');
@@ -85,14 +88,38 @@ class FileContentCache {
             return '';
         }
     }
+    setForTest(key, value) {
+        this.set(key, value);
+    }
+    hasForTest(key) {
+        return this.cache.has(key);
+    }
+    touch(key, value) {
+        this.cache.delete(key);
+        this.cache.set(key, value);
+    }
     set(key, value) {
-        if (this.cache.size >= this.maxSize) {
-            const oldest = this.accessOrder.shift();
-            if (oldest)
-                this.cache.delete(oldest);
+        const prev = this.cache.get(key);
+        if (prev) {
+            this.currentBytes -= prev.sizeBytes;
+            this.cache.delete(key);
+        }
+        const sizeBytes = Buffer.byteLength(value, 'utf-8');
+        this.cache.set(key, { content: value, sizeBytes });
+        this.currentBytes += sizeBytes;
+        this.evictIfNeeded();
+    }
+    evictIfNeeded() {
+        while (this.currentBytes > this.maxBytes && this.cache.size > 0) {
+            const oldestKey = this.cache.keys().next().value;
+            if (!oldestKey)
+                break;
+            const oldest = this.cache.get(oldestKey);
+            this.cache.delete(oldestKey);
+            if (oldest) {
+                this.currentBytes -= oldest.sizeBytes;
+            }
         }
-        this.cache.set(key, value);
-        this.accessOrder.push(key);
     }
 }
 const extractContent = async (node, contentCache) => {
@@ -123,6 +150,56 @@ const extractContent = async (node, contentCache) => {
         ? snippet.slice(0, MAX_SNIPPET) + '\n... [truncated]'
         : snippet;
 };
+function compactUnityComponentDescription(description) {
+    const raw = typeof description === 'string' ? description : '';
+    if (!raw)
+        return '';
+    try {
+        const parsed = JSON.parse(raw);
+        const compact = {};
+        if (parsed.bindingKind)
+            compact.bindingKind = parsed.bindingKind;
+        if (parsed.componentObjectId)
+            compact.componentObjectId = parsed.componentObjectId;
+        if (parsed.lightweight)
+            compact.lightweight = true;
+        const scalarFields = parsed.serializedFields?.scalarFields || [];
+        const referenceFields = parsed.serializedFields?.referenceFields || [];
+        if (scalarFields.length > 0 || referenceFields.length > 0) {
+            compact.serializedFields = { scalarFields, referenceFields };
+        }
+        if (Array.isArray(parsed.resolvedReferences) && parsed.resolvedReferences.length > 0) {
+            compact.resolvedReferences = parsed.resolvedReferences;
+        }
+        if (Array.isArray(parsed.assetRefPaths) && parsed.assetRefPaths.length > 0) {
+            compact.assetRefPaths = parsed.assetRefPaths;
+        }
+        return JSON.stringify(Object.keys(compact).length > 0 ? compact : parsed);
+    }
+    catch {
+        return raw;
+    }
+}
+export async function toCodeElementCsvRow(node, contentCache) {
+    const filePath = String(node.properties.filePath || '');
+    const isUnityComponentRow = node.label === 'CodeElement' && UNITY_RESOURCE_PATH_PATTERN.test(filePath);
+    const content = isUnityComponentRow
+        ? ''
+        : (contentCache ? await extractContent(node, contentCache) : '');
+    const description = isUnityComponentRow
+        ? compactUnityComponentDescription(node.properties.description || '')
+        : String(node.properties.description || '');
+    return [
+        escapeCSVField(node.id),
+        escapeCSVField(node.properties.name || ''),
+        escapeCSVField(filePath),
+        escapeCSVNumber(node.properties.startLine, -1),
+        escapeCSVNumber(node.properties.endLine, -1),
+        node.properties.isExported ? 'true' : 'false',
+        escapeCSVField(content),
+        escapeCSVField(description),
+    ].join(',');
+}
 // ============================================================================
 // BUFFERED CSV WRITER
 // ============================================================================
@@ -266,17 +343,7 @@ export const streamAllCSVsToDisk = async (graph, repoPath, csvDir) => {
                 // Code element nodes (Function, Class, Interface, Method, CodeElement)
                 const writer = codeWriterMap[node.label];
                 if (writer) {
-                    const content = await extractContent(node, contentCache);
-                    await writer.addRow([
-                        escapeCSVField(node.id),
-                        escapeCSVField(node.properties.name || ''),
-                        escapeCSVField(node.properties.filePath || ''),
-                        escapeCSVNumber(node.properties.startLine, -1),
-                        escapeCSVNumber(node.properties.endLine, -1),
-                        node.properties.isExported ? 'true' : 'false',
-                        escapeCSVField(content),
-                        escapeCSVField(node.properties.description || ''),
-                    ].join(','));
+                    await writer.addRow(await toCodeElementCsvRow(node, contentCache));
                 }
                 else {
                     // Multi-language node types (Struct, Impl, Trait, Macro, etc.)

package/dist/core/kuzu/csv-generator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/kuzu/csv-generator.test.js

@@ -0,0 +1,28 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { FileContentCache, toCodeElementCsvRow } from './csv-generator.js';
+test('FileContentCache evicts oldest entries when byte budget is exceeded', async () => {
+    const cache = new FileContentCache('/tmp/repo', 10);
+    cache.setForTest('a.cs', '123456');
+    cache.setForTest('b.cs', '123456');
+    assert.equal(cache.hasForTest('a.cs'), false);
+    assert.equal(cache.hasForTest('b.cs'), true);
+});
+test('Unity component CodeElement rows store compact description and empty content', async () => {
+    const row = await toCodeElementCsvRow({
+        id: 'CodeElement:Assets/A.prefab:114',
+        label: 'CodeElement',
+        properties: {
+            name: 'DoorObj@114',
+            filePath: 'Assets/A.prefab',
+            startLine: 12,
+            endLine: 12,
+            description: JSON.stringify({
+                bindingKind: 'direct',
+                componentObjectId: '114',
+                serializedFields: { scalarFields: [], referenceFields: [] },
+            }),
+        },
+    });
+    assert.match(row, /,\"\"\,\"\{/);
+});

package/dist/core/kuzu/kuzu-adapter.js

@@ -1,10 +1,9 @@
 import fs from 'fs/promises';
-import { createReadStream } from 'fs';
-import { createInterface } from 'readline';
 import path from 'path';
 import kuzu from 'kuzu';
 import { NODE_TABLES, REL_TABLE_NAME, SCHEMA_QUERIES, EMBEDDING_TABLE_NAME, } from './schema.js';
 import { streamAllCSVsToDisk } from './csv-generator.js';
+import { streamRelationshipPairBucketsFromCsv } from './relationship-pair-buckets.js';
 let db = null;
 let conn = null;
 let currentDbPath = null;
@@ -146,45 +145,18 @@ export const loadGraphToKuzu = async (graph, repoPath, storagePath, onProgress)
         }
     }
     // Bulk COPY relationships — split by FROM→TO label pair (KuzuDB requires it)
-    // Stream-read the relation CSV line by line to avoid exceeding V8 max string length
-    let relHeader = '';
-    const relsByPair = new Map();
-    let skippedRels = 0;
-    let totalValidRels = 0;
-    await new Promise((resolve, reject) => {
-        const rl = createInterface({ input: createReadStream(csvResult.relCsvPath, 'utf-8'), crlfDelay: Infinity });
-        let isFirst = true;
-        rl.on('line', (line) => {
-            if (isFirst) {
-                relHeader = line;
-                isFirst = false;
-                return;
-            }
-            if (!line.trim())
-                return;
-            const match = line.match(/"([^"]*)","([^"]*)"/);
-            if (!match) {
-                skippedRels++;
-                return;
-            }
-            const fromLabel = getNodeLabel(match[1]);
-            const toLabel = getNodeLabel(match[2]);
-            if (!validTables.has(fromLabel) || !validTables.has(toLabel)) {
-                skippedRels++;
-                return;
-            }
-            const pairKey = `${fromLabel}|${toLabel}`;
-            let list = relsByPair.get(pairKey);
-            if (!list) {
-                list = [];
-                relsByPair.set(pairKey, list);
-            }
-            list.push(line);
-            totalValidRels++;
-        });
-        rl.on('close', resolve);
-        rl.on('error', reject);
+    // Stream relation CSV into per-pair temporary CSV files to avoid retaining
+    // all relationship lines in memory at once.
+    const pairBucketResult = await streamRelationshipPairBucketsFromCsv({
+        relCsvPath: csvResult.relCsvPath,
+        csvDir,
+        validTables,
+        getNodeLabel,
     });
+    const relHeader = pairBucketResult.relHeader;
+    const relsByPair = pairBucketResult.buckets;
+    const skippedRels = pairBucketResult.skippedRels;
+    const totalValidRels = pairBucketResult.totalValidRels;
     const insertedRels = totalValidRels;
     const warnings = [];
     let fallbackStats = { attempted: 0, succeeded: 0, failed: 0 };
@@ -192,15 +164,13 @@ export const loadGraphToKuzu = async (graph, repoPath, storagePath, onProgress)
         log(`Loading edges: ${insertedRels.toLocaleString()} across ${relsByPair.size} types`);
         let pairIdx = 0;
         let failedPairEdges = 0;
-        const failedPairLines = [];
-        for (const [pairKey, lines] of relsByPair) {
+        const failedPairCsvPaths = [];
+        for (const [pairKey, bucket] of relsByPair) {
             pairIdx++;
             const [fromLabel, toLabel] = pairKey.split('|');
-            const pairCsvPath = path.join(csvDir, `rel_${fromLabel}_${toLabel}.csv`);
-            await fs.writeFile(pairCsvPath, relHeader + '\n' + lines.join('\n'), 'utf-8');
-            const normalizedPath = normalizeCopyPath(pairCsvPath);
+            const normalizedPath = normalizeCopyPath(bucket.csvPath);
             const copyQuery = `COPY ${REL_TABLE_NAME} FROM "${normalizedPath}" (from="${fromLabel}", to="${toLabel}", HEADER=true, ESCAPE='"', DELIM=',', QUOTE='"', PARALLEL=false, auto_detect=false)`;
-            if (pairIdx % 5 === 0 || lines.length > 1000) {
+            if (pairIdx % 5 === 0 || bucket.rowCount > 1000) {
                 log(`Loading edges: ${pairIdx}/${relsByPair.size} types (${fromLabel} -> ${toLabel})`);
             }
             try {
@@ -213,20 +183,31 @@ export const loadGraphToKuzu = async (graph, repoPath, storagePath, onProgress)
                 }
                 catch (retryErr) {
                     const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
-                    warnings.push(`${fromLabel}->${toLabel} (${lines.length} edges): ${retryMsg.slice(0, 80)}`);
-                    failedPairEdges += lines.length;
-                    failedPairLines.push(...lines);
+                    warnings.push(`${fromLabel}->${toLabel} (${bucket.rowCount} edges): ${retryMsg.slice(0, 80)}`);
+                    failedPairEdges += bucket.rowCount;
+                    failedPairCsvPaths.push(bucket.csvPath);
                 }
             }
+        }
+        if (failedPairCsvPaths.length > 0) {
+            const failedPairLines = [relHeader];
+            for (const failedPairPath of failedPairCsvPaths) {
+                const raw = await fs.readFile(failedPairPath, 'utf-8');
+                const lines = raw
+                    .split('\n')
+                    .slice(1)
+                    .filter(line => line.trim().length > 0);
+                failedPairLines.push(...lines);
+            }
+            log(`Inserting ${failedPairEdges} edges individually (missing schema pairs)`);
+            fallbackStats = await fallbackRelationshipInserts(failedPairLines, validTables, getNodeLabel);
+        }
+        for (const [, bucket] of relsByPair) {
             try {
-                await fs.unlink(pairCsvPath);
+                await fs.unlink(bucket.csvPath);
             }
             catch { }
         }
-        if (failedPairLines.length > 0) {
-            log(`Inserting ${failedPairEdges} edges individually (missing schema pairs)`);
-            fallbackStats = await fallbackRelationshipInserts([relHeader, ...failedPairLines], validTables, getNodeLabel);
-        }
     }
     // Cleanup all CSVs
     try {

package/dist/core/kuzu/relationship-pair-buckets.d.ts

@@ -0,0 +1,17 @@
+export interface RelationshipPairBucket {
+    csvPath: string;
+    rowCount: number;
+}
+export interface RelationshipPairBucketResult {
+    relHeader: string;
+    buckets: Map<string, RelationshipPairBucket>;
+    skippedRels: number;
+    totalValidRels: number;
+}
+export declare function bucketRelationshipLines(lines: string[], getNodeLabel: (id: string) => string): Promise<Map<string, string[]>>;
+export declare function streamRelationshipPairBucketsFromCsv(params: {
+    relCsvPath: string;
+    csvDir: string;
+    validTables: Set<string>;
+    getNodeLabel: (nodeId: string) => string;
+}): Promise<RelationshipPairBucketResult>;

package/dist/core/kuzu/relationship-pair-buckets.js

@@ -0,0 +1,79 @@
+import fs from 'fs/promises';
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
+import path from 'path';
+const REL_ENDPOINTS_PATTERN = /"([^"]*)","([^"]*)"/;
+const parseRelationshipEndpoints = (line) => {
+    const match = line.match(REL_ENDPOINTS_PATTERN);
+    if (!match)
+        return null;
+    return { fromId: match[1], toId: match[2] };
+};
+export async function bucketRelationshipLines(lines, getNodeLabel) {
+    const buckets = new Map();
+    for (const line of lines) {
+        const endpoints = parseRelationshipEndpoints(line);
+        if (!endpoints)
+            continue;
+        const key = `${getNodeLabel(endpoints.fromId)}|${getNodeLabel(endpoints.toId)}`;
+        const rows = buckets.get(key) || [];
+        rows.push(line);
+        buckets.set(key, rows);
+    }
+    return buckets;
+}
+export async function streamRelationshipPairBucketsFromCsv(params) {
+    const { relCsvPath, csvDir, validTables, getNodeLabel } = params;
+    let relHeader = '';
+    const buckets = new Map();
+    let skippedRels = 0;
+    let totalValidRels = 0;
+    let isFirst = true;
+    let queue = Promise.resolve();
+    await new Promise((resolve, reject) => {
+        const rl = createInterface({ input: createReadStream(relCsvPath, 'utf-8'), crlfDelay: Infinity });
+        rl.on('line', (line) => {
+            queue = queue.then(async () => {
+                if (isFirst) {
+                    relHeader = line;
+                    isFirst = false;
+                    return;
+                }
+                if (!line.trim())
+                    return;
+                const endpoints = parseRelationshipEndpoints(line);
+                if (!endpoints) {
+                    skippedRels++;
+                    return;
+                }
+                const fromLabel = getNodeLabel(endpoints.fromId);
+                const toLabel = getNodeLabel(endpoints.toId);
+                if (!validTables.has(fromLabel) || !validTables.has(toLabel)) {
+                    skippedRels++;
+                    return;
+                }
+                const pairKey = `${fromLabel}|${toLabel}`;
+                let bucket = buckets.get(pairKey);
+                if (!bucket) {
+                    bucket = {
+                        csvPath: path.join(csvDir, `rel_${fromLabel}_${toLabel}.csv`),
+                        rowCount: 0,
+                    };
+                    buckets.set(pairKey, bucket);
+                    await fs.writeFile(bucket.csvPath, `${relHeader}\n`, 'utf-8');
+                }
+                await fs.appendFile(bucket.csvPath, `${line}\n`, 'utf-8');
+                bucket.rowCount++;
+                totalValidRels++;
+            }).catch((error) => {
+                rl.close();
+                reject(error);
+            });
+        });
+        rl.on('close', () => {
+            queue.then(() => resolve()).catch(reject);
+        });
+        rl.on('error', reject);
+    });
+    return { relHeader, buckets, skippedRels, totalValidRels };
+}

package/dist/core/kuzu/relationship-pair-buckets.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/kuzu/relationship-pair-buckets.test.js

@@ -0,0 +1,10 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { bucketRelationshipLines } from './relationship-pair-buckets.js';
+test('bucketRelationshipLines groups CSV lines by from/to pair without retaining all lines in one array', async () => {
+    const out = await bucketRelationshipLines([
+        '"Class:a","File:x","UNITY_RESOURCE_SUMMARY",1,"",0',
+        '"Class:a","CodeElement:b","UNITY_COMPONENT_INSTANCE",1,"",0',
+    ], (nodeId) => nodeId.split(':')[0]);
+    assert.deepEqual([...out.keys()].sort(), ['Class|CodeElement', 'Class|File']);
+});

package/dist/core/kuzu/schema.d.ts

@@ -11,7 +11,7 @@
 export declare const NODE_TABLES: readonly ["File", "Folder", "Function", "Class", "Interface", "Method", "CodeElement", "Community", "Process", "Struct", "Enum", "Macro", "Typedef", "Union", "Namespace", "Trait", "Impl", "TypeAlias", "Const", "Static", "Property", "Record", "Delegate", "Annotation", "Constructor", "Template", "Module"];
 export type NodeTableName = typeof NODE_TABLES[number];
 export declare const REL_TABLE_NAME = "CodeRelation";
-export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "MEMBER_OF", "STEP_IN_PROCESS", "UNITY_COMPONENT_IN", "UNITY_COMPONENT_INSTANCE", "UNITY_SERIALIZED_TYPE_IN"];
+export declare const REL_TYPES: readonly ["CONTAINS", "DEFINES", "IMPORTS", "CALLS", "EXTENDS", "IMPLEMENTS", "MEMBER_OF", "STEP_IN_PROCESS", "UNITY_COMPONENT_IN", "UNITY_COMPONENT_INSTANCE", "UNITY_RESOURCE_SUMMARY", "UNITY_SERIALIZED_TYPE_IN"];
 export type RelType = typeof REL_TYPES[number];
 export declare const EMBEDDING_TABLE_NAME = "CodeEmbedding";
 export declare const FILE_SCHEMA = "\nCREATE NODE TABLE File (\n  id STRING,\n  name STRING,\n  filePath STRING,\n  content STRING,\n  PRIMARY KEY (id)\n)";

package/dist/core/kuzu/schema.js

@@ -33,6 +33,7 @@ export const REL_TYPES = [
     'STEP_IN_PROCESS',
     'UNITY_COMPONENT_IN',
     'UNITY_COMPONENT_INSTANCE',
+    'UNITY_RESOURCE_SUMMARY',
     'UNITY_SERIALIZED_TYPE_IN',
 ];
 // ============================================================================

package/dist/core/unity/options.d.ts

@@ -1,2 +1,4 @@
 export type UnityResourcesMode = 'off' | 'on' | 'auto';
+export type UnityHydrationMode = 'parity' | 'compact';
 export declare function parseUnityResourcesMode(raw?: string): UnityResourcesMode;
+export declare function parseUnityHydrationMode(raw?: string): UnityHydrationMode;

package/dist/core/unity/options.js

@@ -7,3 +7,12 @@ export function parseUnityResourcesMode(raw) {
     }
     throw new Error('Invalid unity resources mode. Use off|on|auto.');
 }
+export function parseUnityHydrationMode(raw) {
+    if (!raw)
+        return 'compact';
+    const normalized = raw.trim().toLowerCase();
+    if (normalized === 'parity' || normalized === 'compact') {
+        return normalized;
+    }
+    throw new Error('Invalid unity hydration mode. Use parity|compact.');
+}