@codeyam/codeyam-cli 0.1.0-staging.c9dc00c → 0.1.0-staging.d3e886e

package/analyzer-template/packages/ai/src/lib/mergeJsonTypeDefinitions.ts

@@ -11,6 +11,11 @@ export default function mergeJsonTypeDefinitions(
     if (!typeDef) continue;
     if (typeof typeDef === 'string') continue;
     for (const [key, value] of Object.entries(typeDef)) {
+      // Preserve _nullable boolean markers set by convertDotNotation
+      if (key === '_nullable' && typeof value === 'boolean') {
+        mergedDef[key] = value;
+        continue;
+      }
       if (typeof value === 'string') {
         if (!mergedDef[key]) {
           mergedDef[key] = value;

package/analyzer-template/packages/ai/src/lib/promptGenerators/collapseNullableObjects.ts

@@ -0,0 +1,118 @@
+import { JsonTypeDefinition } from '~codeyam/types';
+
+/**
+ * Check whether all non-`_nullable` children of an object are simple strings.
+ * "Leaf-like" nullable objects (all-string children) get collapsed to
+ * `"object | null"` so the LLM knows the field can be null.
+ * Objects with nested structure (object/array children) keep their shape
+ * so the LLM can still generate proper data when the field is truthy.
+ */
+function isLeafLikeObject(obj: Record<string, any>): boolean {
+  for (const key of Object.keys(obj)) {
+    if (key === '_nullable') continue;
+    const value = obj[key];
+    if (typeof value !== 'string') return false;
+  }
+  return true;
+}
+
+/**
+ * Collapse *leaf-like* nullable objects/arrays in the data structure to type strings.
+ *
+ * When convertDotNotation marks an object or array as `_nullable: true`
+ * (meaning the schema had `object | undefined`, `object | null`, etc.),
+ * we decide whether to collapse it:
+ *
+ * - **Leaf-like** (all children are simple strings): collapse to `"object | null"`.
+ *   Example: `{ _nullable: true, type: "string", path: "string" }` → `"object | null"`
+ *
+ * - **Rich** (has object/array children): strip `_nullable` and keep the structure
+ *   so the LLM can generate proper nested data when the field is truthy.
+ *   Example: `{ _nullable: true, items: [...], name: "string" }` → `{ items: [...], name: "string" }`
+ *
+ * Non-nullable objects are recursively processed but left as nested structures.
+ */
+export default function collapseNullableObjects(
+  data: JsonTypeDefinition,
+): JsonTypeDefinition {
+  if (typeof data !== 'object' || data === null) {
+    return data;
+  }
+
+  if (Array.isArray(data)) {
+    return data.map((item: any) =>
+      typeof item === 'object' && item !== null
+        ? collapseNullableObjects(item as JsonTypeDefinition)
+        : item,
+    ) as any as JsonTypeDefinition;
+  }
+
+  const result: JsonTypeDefinition = {};
+
+  for (const key of Object.keys(data)) {
+    // Skip the _nullable marker itself (shouldn't appear at top level, but be safe)
+    if (key === '_nullable') continue;
+
+    const value = data[key];
+
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      const hasNullable = (value as any)._nullable === true;
+      if (hasNullable && isLeafLikeObject(value as Record<string, any>)) {
+        // Leaf-like nullable object → collapse to type string
+        const childKeys = Object.keys(value as any).filter(
+          (k) => k !== '_nullable',
+        );
+        console.log(
+          `[collapseNullableObjects] collapsed "${key}" → "object | null" (leaf-like, children: [${childKeys.join(', ')}])`,
+        );
+        result[key] = 'object | null';
+      } else if (hasNullable) {
+        // Rich nullable object → strip _nullable, keep structure
+        const childKeys = Object.keys(value as any).filter(
+          (k) => k !== '_nullable',
+        );
+        console.log(
+          `[collapseNullableObjects] kept structure for nullable "${key}" (rich, children: [${childKeys.join(', ')}])`,
+        );
+        result[key] = collapseNullableObjects(value as JsonTypeDefinition);
+      } else {
+        // Non-nullable → recurse
+        result[key] = collapseNullableObjects(value as JsonTypeDefinition);
+      }
+    } else if (Array.isArray(value)) {
+      const hasNullable = (value as any)._nullable === true;
+      if (
+        hasNullable &&
+        value.length <= 1 &&
+        value.every((v) => typeof v === 'string')
+      ) {
+        // Leaf-like nullable array → collapse to type string
+        console.log(
+          `[collapseNullableObjects] collapsed "${key}" → "array | null" (leaf-like)`,
+        );
+        result[key] = 'array | null';
+      } else if (hasNullable) {
+        // Rich nullable array → strip _nullable, keep structure
+        console.log(
+          `[collapseNullableObjects] kept structure for nullable array "${key}" (${value.length} elements)`,
+        );
+        result[key] = value.map((item) =>
+          typeof item === 'object' && item !== null
+            ? collapseNullableObjects(item as JsonTypeDefinition)
+            : item,
+        ) as JsonTypeDefinition[];
+      } else {
+        // Non-nullable → recurse elements
+        result[key] = value.map((item) =>
+          typeof item === 'object' && item !== null
+            ? collapseNullableObjects(item as JsonTypeDefinition)
+            : item,
+        ) as JsonTypeDefinition[];
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateEntityScenarioDataGenerator.ts

@@ -7,6 +7,7 @@ import {
 } from '~codeyam/types';
 import noErrorAttributes from './noErrorAttributes';
 import simplifyKeysForLLM from './simplifyKeysForLLM';
+import collapseNullableObjects from './collapseNullableObjects';
 
 /**
  * Sort object keys by the size of their JSON-stringified values (smallest first).
@@ -99,11 +100,17 @@ ${JSON.stringify(defaultScenarioData.data, null, 2)}
   // while the reconcileMockDataKeys function will still match the simplified response back to original keys.
   // Then sort keys by size (smallest first) so small keys appear before large keys,
   // increasing the chance the LLM generates all keys for large schemas.
-  const cleanedDataForMocks = structure.dataForMocks
-    ? simplifyKeysForLLM(
-        noErrorAttributes(structure.dataForMocks) as JsonTypeDefinition,
-      )
+
+  const afterNoError = structure.dataForMocks
+    ? (noErrorAttributes(structure.dataForMocks) as JsonTypeDefinition)
+    : null;
+
+  const afterSimplify = afterNoError ? simplifyKeysForLLM(afterNoError) : null;
+
+  const cleanedDataForMocks = afterSimplify
+    ? collapseNullableObjects(afterSimplify)
     : null;
+
   const sortedDataForMocks =
     cleanedDataForMocks &&
     typeof cleanedDataForMocks === 'object' &&
@@ -111,6 +118,19 @@ ${JSON.stringify(defaultScenarioData.data, null, 2)}
       ? sortKeysBySize(cleanedDataForMocks as Record<string, any>)
       : cleanedDataForMocks;
 
+  // Log nullable-related content in final prompt JSON
+  if (sortedDataForMocks) {
+    const finalJson = JSON.stringify(sortedDataForMocks, null, 2);
+    const hasNullableMarker = finalJson.includes('_nullable');
+    const nullCollapsed = (finalJson.match(/"object \| null"/g) || []).length;
+    const arrayCollapsed = (finalJson.match(/"array \| null"/g) || []).length;
+    if (hasNullableMarker || nullCollapsed > 0 || arrayCollapsed > 0) {
+      console.log(
+        `[generateEntityScenarioDataGenerator] final prompt: ${nullCollapsed} "object | null", ${arrayCollapsed} "array | null"${hasNullableMarker ? ', WARNING: _nullable still present!' : ''}`,
+      );
+    }
+  }
+
   // When mockData has already been generated via chunks, skip it in the main call
   const mockDataSection = options?.mockDataAlreadyGenerated
     ? '## mockData Structure\nmockData has been pre-generated—return `{}` for mockData.'

package/analyzer-template/packages/analyze/src/lib/files/analyze/analyzeEntities/prepareDataStructures.ts

@@ -18,6 +18,7 @@ import {
   getCompoundConditionals,
   getChildBoundaryGatingConditions,
   getJsxRenderingUsages,
+  skipWorkerPool,
 } from '~codeyam/ai';
 import type { AnalysisOptions } from '../analyzeEntities';
 
@@ -271,6 +272,23 @@ export default async function prepareEntityDataStructures(
   };
 
   const entities = Array.from(allEntities);
+
+  // The worker thread creates its own ProjectAnalyzer (ts.Program) on first use,
+  // which takes 50-70s. For small entity counts the overhead far exceeds the actual
+  // processing time (<2s). Skip the worker and run on the main thread instead,
+  // reusing the existing ProjectAnalyzer.
+  const entitiesNeedingGeneration = entities.filter(
+    (e) =>
+      !e.metadata?.isolatedDataStructure || options.force || options.forceAll,
+  ).length;
+  const WORKER_ENTITY_THRESHOLD = 500;
+  if (entitiesNeedingGeneration < WORKER_ENTITY_THRESHOLD) {
+    console.log(
+      `CodeYam: Skipping worker thread for DS prep (${entitiesNeedingGeneration} entities < ${WORKER_ENTITY_THRESHOLD} threshold)`,
+    );
+    skipWorkerPool();
+  }
+
   const sequential =
     DEBUG_SEQUENTIAL_EXECUTION || options.sequentialDataStructurePrep;
 

package/analyzer-template/packages/analyze/src/lib/files/scenarios/gatherDataForMocks.ts

@@ -353,8 +353,6 @@ function processCall(
   // Preprocess to filter signatures and extract functionCallReturnValue
   let preprocessedSchema = preprocessSchemaForMocks(mergedSchema);
 
-  const functionNames: string[] = [];
-
   const isFunctionNameWithoutFunction = (
     path: string,
     functionName: string,
@@ -439,31 +437,58 @@ function processCall(
     }
   }
 
-  const relevantMergedDependencySchema = Object.keys(preprocessedSchema).reduce(
-    (acc, path) => {
-      if (path.endsWith(')')) {
-        const pathParts = splitOutsideParenthesesAndArrays(path);
-        const functionName = joinParenthesesAndArrays([
-          ...pathParts.slice(0, -1),
-          pathParts[pathParts.length - 1].split('(')[0],
-        ]);
-        functionNames.push(functionName);
-        for (const existingPath in acc) {
-          if (isFunctionNameWithoutFunction(existingPath, functionName)) {
-            delete acc[existingPath];
-          }
-        }
-      }
+  // Two-pass function name filtering to avoid O(k²) retroactive deletion.
+  // Pass 1: Discover all unique function names from paths ending with ')'
+  const functionNameSet = new Set<string>();
+  const schemaKeys = Object.keys(preprocessedSchema);
+  for (const path of schemaKeys) {
+    if (path.endsWith(')')) {
+      const pathParts = splitOutsideParenthesesAndArrays(path);
+      const functionName = joinParenthesesAndArrays([
+        ...pathParts.slice(0, -1),
+        pathParts[pathParts.length - 1].split('(')[0],
+      ]);
+      functionNameSet.add(functionName);
+    }
+  }
 
-      if (functionNames.some((fn) => isFunctionNameWithoutFunction(path, fn))) {
-        return acc;
-      }
+  // Index function names by first segment for O(1) bucket lookup instead of
+  // checking all function names for every path. Most paths only need to check
+  // 1-2 function names instead of all F.
+  const fnByFirstSegment = new Map<string, string[]>();
+  for (const fn of functionNameSet) {
+    const dotIdx = fn.indexOf('.');
+    const firstSeg = dotIdx >= 0 ? fn.slice(0, dotIdx) : fn;
+    let bucket = fnByFirstSegment.get(firstSeg);
+    if (!bucket) {
+      bucket = [];
+      fnByFirstSegment.set(firstSeg, bucket);
+    }
+    bucket.push(fn);
+  }
 
-      acc[path] = preprocessedSchema[path];
-      return acc;
-    },
-    {} as Record<string, string>,
-  );
+  // Pass 2: Filter paths that match any discovered function name prefix.
+  // Use indexed lookup: extract path's first segment, check only matching function names.
+  const relevantMergedDependencySchema: Record<string, string> = {};
+  for (const path of schemaKeys) {
+    // Extract first segment of path (before first '.', '(', or '<')
+    const dotIdx = path.indexOf('.');
+    const parenIdx = path.indexOf('(');
+    const angleIdx = path.indexOf('<');
+    let minIdx = path.length;
+    if (dotIdx >= 0 && dotIdx < minIdx) minIdx = dotIdx;
+    if (parenIdx >= 0 && parenIdx < minIdx) minIdx = parenIdx;
+    if (angleIdx >= 0 && angleIdx < minIdx) minIdx = angleIdx;
+    const firstSeg = path.slice(0, minIdx);
+
+    const candidates = fnByFirstSegment.get(firstSeg);
+    if (
+      !candidates ||
+      !candidates.some((fn) => isFunctionNameWithoutFunction(path, fn))
+    ) {
+      relevantMergedDependencySchema[path] = preprocessedSchema[path];
+    }
+  }
 
   const filledSchema = fillInDirectSchemaGapsAndUnknowns({
     scopeName: importedExport.name,

package/analyzer-template/packages/analyze/src/lib/files/scenarios/mergeInDependentDataStructure.ts

@@ -210,6 +210,23 @@ export default function mergeInDependentDataStructure({
     equivalentPostfixes: Record<string, string>;
   }[] = [];
 
+  // O(1) index for findOrCreateEquivalentSchemaPathsEntry.
+  // Maps "(rootPath)::(normalizedFuncName)" → the entry containing that root.
+  // This replaces the O(E) linear search that was causing O(E²) gather performance.
+  const espIndex = new Map<string, (typeof equivalentSchemaPaths)[0]>();
+  const espIndexKey = (path: string, functionName: string | undefined) => {
+    const normalized = cleanFunctionName(functionName);
+    const funcKey =
+      normalized === rootScopeName ? '__self__' : normalized || '__self__';
+    return `${path}::${funcKey}`;
+  };
+  const updateEspIndex = (entry: (typeof equivalentSchemaPaths)[0]) => {
+    for (const root of entry.equivalentRoots) {
+      const funcName = root.function?.name ?? rootScopeName;
+      espIndex.set(espIndexKey(root.schemaRootPath, funcName), entry);
+    }
+  };
+
   // Pre-build a lookup map from cleaned function name to dependency for O(1) lookups.
   // This avoids O(n) linear search in findRelevantDependency which was causing O(n²) performance.
   const dependencyByCleanedName = new Map<
@@ -324,6 +341,54 @@ export default function mergeInDependentDataStructure({
   ) => {
     if (!sourceAndUsageEquivalencies) return;
 
+    // Pre-computed normalized schema index cache.
+    // Avoids repeated splitOutsideParenthesesAndArrays calls and function-name
+    // normalization for the same schema paths across multiple equivalency iterations.
+    // The normalization depends on `functionName` (constant per gatherAllEquivalentSchemaPaths call),
+    // so this cache is scoped to this call.
+    type NormalizedEntry = { path: string; parts: string[] };
+    const normalizedSchemaCache = new Map<
+      object,
+      {
+        byFirstPart: Map<string, NormalizedEntry[]>;
+      }
+    >();
+    const getSchemaIndex = (
+      schema: Record<string, string> | undefined,
+    ): { byFirstPart: Map<string, NormalizedEntry[]> } => {
+      if (!schema) return { byFirstPart: new Map() };
+      const cached = normalizedSchemaCache.get(schema);
+      if (cached) return cached;
+      const byFirstPart = new Map<string, NormalizedEntry[]>();
+      for (const path in schema) {
+        let parts = splitOutsideParenthesesAndArrays(path);
+        if (parts[0].startsWith(functionName)) {
+          const baseName = cleanFunctionName(parts[0]);
+          if (!functionsWithMultipleTypeParams.has(baseName)) {
+            parts =
+              parts[1] === 'functionCallReturnValue'
+                ? ['returnValue', ...parts.slice(2)]
+                : parts.slice(1);
+          }
+        }
+        const entry: NormalizedEntry = { path, parts };
+        // Index by the base of the first part (before any function call args)
+        const firstPart = parts[0] ?? '';
+        const parenIdx = firstPart.indexOf('(');
+        const firstPartBase =
+          parenIdx >= 0 ? firstPart.slice(0, parenIdx) : firstPart;
+        let bucket = byFirstPart.get(firstPartBase);
+        if (!bucket) {
+          bucket = [];
+          byFirstPart.set(firstPartBase, bucket);
+        }
+        bucket.push(entry);
+      }
+      const result = { byFirstPart };
+      normalizedSchemaCache.set(schema, result);
+      return result;
+    };
+
     const findOrCreateEquivalentSchemaPathsEntry = (
       allPaths: { path: string; functionName?: string }[],
     ) => {
@@ -354,62 +419,52 @@ export default function mergeInDependentDataStructure({
         }
       }
 
+      // Use espIndex Map for O(1) lookup instead of O(E) linear search.
+      // Falls back to linear search only when Map hit has a signature index conflict.
       for (const pathInfo of allPaths) {
-        if (!equivalentSchemaPathsEntry) {
-          equivalentSchemaPathsEntry = equivalentSchemaPaths.find((esp) => {
-            // First check: does this entry have a matching root?
-            const hasMatchingRoot = esp.equivalentRoots.some(
-              (er) =>
-                er.schemaRootPath === pathInfo.path &&
-                (er.function?.name ===
-                  cleanFunctionName(pathInfo.functionName) ||
-                  (!er.function &&
-                    cleanFunctionName(pathInfo.functionName) ===
-                      rootScopeName)),
-            );
-            if (!hasMatchingRoot) return false;
-
-            // Second check: would adding our new roots create a signature index conflict?
-            // An entry should NOT contain roots with different signature indices from the same function.
-            if (newRootSignatureIndices.size > 0) {
-              // Get all signature indices in the existing entry (grouped by function)
-              const existingIndicesByFunction = new Map<string, Set<number>>();
-              for (const er of esp.equivalentRoots) {
-                const funcKey = er.function
-                  ? `${er.function.name}::${er.function.filePath}`
-                  : '__self__';
-                const idx = extractSignatureIndex(er.schemaRootPath);
-                if (idx !== undefined) {
-                  if (!existingIndicesByFunction.has(funcKey)) {
-                    existingIndicesByFunction.set(funcKey, new Set());
-                  }
-                  existingIndicesByFunction.get(funcKey)!.add(idx);
-                }
+        if (equivalentSchemaPathsEntry) break;
+        const candidate = espIndex.get(
+          espIndexKey(pathInfo.path, pathInfo.functionName),
+        );
+        if (!candidate) continue;
+
+        // Verify no signature index conflict with the candidate entry
+        if (newRootSignatureIndices.size > 0) {
+          const existingIndicesByFunction = new Map<string, Set<number>>();
+          for (const er of candidate.equivalentRoots) {
+            const funcKey = er.function
+              ? `${er.function.name}::${er.function.filePath}`
+              : '__self__';
+            const idx = extractSignatureIndex(er.schemaRootPath);
+            if (idx !== undefined) {
+              if (!existingIndicesByFunction.has(funcKey)) {
+                existingIndicesByFunction.set(funcKey, new Set());
               }
+              existingIndicesByFunction.get(funcKey)!.add(idx);
+            }
+          }
 
-              // Check if adding our new roots would create a conflict
-              for (const newRoot of equivalentRoots) {
-                const funcKey = newRoot.function
-                  ? `${newRoot.function.name}::${newRoot.function.filePath}`
-                  : '__self__';
-                const newIdx = extractSignatureIndex(newRoot.schemaRootPath);
-                if (newIdx !== undefined) {
-                  const existingIndices =
-                    existingIndicesByFunction.get(funcKey);
-                  if (existingIndices && existingIndices.size > 0) {
-                    // If this function already has signature indices, check for conflict
-                    if (!existingIndices.has(newIdx)) {
-                      // Conflict: entry has indices like [1] but we want to add [2]
-                      return false;
-                    }
-                  }
+          let hasConflict = false;
+          for (const newRoot of equivalentRoots) {
+            const funcKey = newRoot.function
+              ? `${newRoot.function.name}::${newRoot.function.filePath}`
+              : '__self__';
+            const newIdx = extractSignatureIndex(newRoot.schemaRootPath);
+            if (newIdx !== undefined) {
+              const existingIndices = existingIndicesByFunction.get(funcKey);
+              if (existingIndices && existingIndices.size > 0) {
+                if (!existingIndices.has(newIdx)) {
+                  hasConflict = true;
+                  break;
                 }
               }
             }
+          }
 
-            return true;
-          });
+          if (hasConflict) continue;
         }
+
+        equivalentSchemaPathsEntry = candidate;
       }
 
       if (!equivalentSchemaPathsEntry) {
@@ -467,6 +522,9 @@ export default function mergeInDependentDataStructure({
           return true;
         });
 
+      // Keep the espIndex in sync after adding/deduplicating roots
+      updateEspIndex(equivalentSchemaPathsEntry);
+
       return equivalentSchemaPathsEntry;
     };
 
@@ -535,6 +593,8 @@ export default function mergeInDependentDataStructure({
         );
 
         const derivedBasePaths: { path: string; functionName?: string }[] = [];
+        const allPathSet = new Set(allPaths.map((p) => p.path));
+        const derivedBasePathSet = new Set<string>();
 
         // For each child path, find its equivalent parent path and derive bases
         for (const childPathInfo of childPaths) {
@@ -611,26 +671,28 @@ export default function mergeInDependentDataStructure({
                   !childHasArrayIterator &&
                   !childBaseIsGenericSignature
                 ) {
-                  // Add child base if not already present
-                  const childBaseExists =
-                    allPaths.some((p) => p.path === childBase) ||
-                    derivedBasePaths.some((p) => p.path === childBase);
-                  if (!childBaseExists) {
+                  // Add child base if not already present (O(1) Set lookup)
+                  if (
+                    !allPathSet.has(childBase) &&
+                    !derivedBasePathSet.has(childBase)
+                  ) {
                     derivedBasePaths.push({
                       path: childBase,
                       functionName: childPathInfo.functionName,
                     });
+                    derivedBasePathSet.add(childBase);
                   }
 
-                  // Add parent base if not already present
-                  const parentBaseExists =
-                    allPaths.some((p) => p.path === parentBase) ||
-                    derivedBasePaths.some((p) => p.path === parentBase);
-                  if (!parentBaseExists) {
+                  // Add parent base if not already present (O(1) Set lookup)
+                  if (
+                    !allPathSet.has(parentBase) &&
+                    !derivedBasePathSet.has(parentBase)
+                  ) {
                     derivedBasePaths.push({
                       path: parentBase,
                       functionName: parentPathInfo.functionName,
                     });
+                    derivedBasePathSet.add(parentBase);
                   }
                 }
               }
@@ -708,21 +770,20 @@ export default function mergeInDependentDataStructure({
           }
 
           for (const schema of schemas) {
-            for (const schemaPath in schema) {
-              let schemaPathParts =
-                splitOutsideParenthesesAndArrays(schemaPath);
-
-              if (schemaPathParts[0].startsWith(functionName)) {
-                // Only normalize if the function doesn't have multiple different type parameters
-                const baseName = cleanFunctionName(schemaPathParts[0]);
-                if (!functionsWithMultipleTypeParams.has(baseName)) {
-                  schemaPathParts =
-                    schemaPathParts[1] === 'functionCallReturnValue'
-                      ? ['returnValue', ...schemaPathParts.slice(2)]
-                      : schemaPathParts.slice(1);
-                }
-              }
-
+            // Use pre-computed index to only iterate schema entries whose
+            // normalized first part matches pathParts[0], instead of all entries.
+            const schemaIndex = getSchemaIndex(schema);
+            const lookupPart = pathParts[0] ?? '';
+            const lookupParenIdx = lookupPart.indexOf('(');
+            const lookupBase =
+              lookupParenIdx >= 0
+                ? lookupPart.slice(0, lookupParenIdx)
+                : lookupPart;
+            const candidates = schemaIndex.byFirstPart.get(lookupBase) || [];
+            for (const {
+              path: schemaPath,
+              parts: schemaPathParts,
+            } of candidates) {
               if (schemaPathParts.length < pathParts.length) continue;
 
               // Check if all path parts match (allowing function call variants)
@@ -850,10 +911,17 @@ export default function mergeInDependentDataStructure({
         const entry = findOrCreateEquivalentSchemaPathsEntry([
           { path: translatedBasePath, functionName: functionName },
         ]);
-        entry.equivalentRoots.push({
+        const newRoot = {
           schemaRootPath: translatedBasePath,
           function: findRelevantDependency(functionName),
-        });
+        };
+        entry.equivalentRoots.push(newRoot);
+        // Update index for the newly added root
+        const newRootFuncName = newRoot.function?.name ?? rootScopeName;
+        espIndex.set(
+          espIndexKey(newRoot.schemaRootPath, newRootFuncName),
+          entry,
+        );
 
         const basePathParts = splitOutsideParenthesesAndArrays(basePath);
         for (const schemaPath in dataStructure.returnValueSchema) {
@@ -1113,6 +1181,10 @@ export default function mergeInDependentDataStructure({
 
   equivalentSchemaPaths = mergeAllEquivalentSchemaPaths();
 
+  // Collect schemas that need cleaning — batch the calls for the end instead of
+  // calling cleanSchema inside the inner root loop (which was O(roots * schemaSize)).
+  const schemasToClean = new Set<{ [key: string]: string }>();
+
   for (const esp of equivalentSchemaPaths) {
     // Pre-compute which postfixes have children to avoid O(n²) lookups in the inner loop.
     // A postfix "has children" if there are other postfixes that extend it.
@@ -1290,10 +1362,15 @@ export default function mergeInDependentDataStructure({
         schema[newSchemaPath] = postfixValue;
       }
 
-      cleanSchema(schema, { stage: 'afterMergePostfix' });
+      schemasToClean.add(schema);
     }
   }
 
+  // Batch-clean all modified schemas once (instead of once per root per ESP entry)
+  for (const schema of schemasToClean) {
+    cleanSchema(schema, { stage: 'afterMergePostfix' });
+  }
+
   // Propagate equivalency-derived attributes to generic function call variants.
   // When attributes are traced via equivalencies (e.g., fileComparisons from buildDataMap.signature[2]),
   // they get written to non-generic paths (returnValue.data.x or funcName().functionCallReturnValue.data.x).

package/analyzer-template/packages/database/src/lib/kysely/tables/debugReportsTable.ts

@@ -6,7 +6,7 @@ import { schemaField, defaultNow } from '../schemaHelpers';
 /**
  * Metadata for a debug bundle upload.
  * Note: "bundle" refers to the tarball upload (base + delta).
- * The markdown "debug report" from /codeyam:diagnose is stored in feedback.debugReport.
+ * The markdown "debug report" from /codeyam-diagnose is stored in feedback.debugReport.
  */
 interface DebugBundleMetadata {
   timestamp: string;

package/analyzer-template/packages/github/dist/database/src/lib/kysely/tables/debugReportsTable.d.ts

@@ -3,7 +3,7 @@ import type { Generated, JSONColumnType } from 'kysely';
 /**
  * Metadata for a debug bundle upload.
  * Note: "bundle" refers to the tarball upload (base + delta).
- * The markdown "debug report" from /codeyam:diagnose is stored in feedback.debugReport.
+ * The markdown "debug report" from /codeyam-diagnose is stored in feedback.debugReport.
  */
 interface DebugBundleMetadata {
     timestamp: string;

package/analyzer-template/packages/utils/dist/utils/src/lib/fs/rsyncCopy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rsyncCopy.d.ts","sourceRoot":"","sources":["../../../../../src/lib/fs/rsyncCopy.ts"],"names":[],"mappings":"AAEA,wBAA8B,SAAS,CAAC,EACtC,UAAU,EACV,eAAe,EACf,QAAa,EACb,YAAoB,EACpB,MAAc,EACd,SAAc,GACf,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+ChB"}
+{"version":3,"file":"rsyncCopy.d.ts","sourceRoot":"","sources":["../../../../../src/lib/fs/rsyncCopy.ts"],"names":[],"mappings":"AAqFA,wBAA8B,SAAS,CAAC,EACtC,UAAU,EACV,eAAe,EACf,QAAa,EACb,YAAoB,EACpB,MAAc,EACd,SAAc,GACf,EAAE;IACD,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsEhB"}