@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.e38f7bd

package/analyzer-template/project/loadReadyToBeCaptured.ts

@@ -1,5 +1,9 @@
 import { AnalysisContext, discoverDirectDependencies } from '~codeyam/analyze';
-import { loadAnalysis, loadReadyToBeCapturedAnalyses } from '~codeyam/supabase';
+import {
+  loadAnalysis,
+  loadEntities,
+  loadReadyToBeCapturedAnalyses,
+} from '~codeyam/database';
 import { Analysis, Project } from '~codeyam/types';
 import { LazyFileStore } from './LazyFileStore';
 
@@ -11,6 +15,116 @@ interface LoadReadyToBeCapturedArgs {
   fileStore?: LazyFileStore;
 }
 
+/**
+ * Recursively gather all entities referenced in importedExports of entities already in context.
+ * This fills the gap where discoverDirectDependencies skips mocked/type/implicit imports,
+ * but writeScenarioComponents still needs those entities in the context.
+ */
+async function gatherAllReferencedEntities(
+  context: AnalysisContext,
+  project: Project,
+): Promise<void> {
+  const processedKeys = new Set<string>();
+  let iterationCount = 0;
+  const MAX_ITERATIONS = 20; // Safety limit to prevent infinite loops
+
+  const getAllEntities = () =>
+    Object.values(context.getMutableEntityMap()).flatMap(Object.values);
+
+  while (iterationCount < MAX_ITERATIONS) {
+    iterationCount++;
+
+    // Collect all (filePath, entityName) pairs from importedExports of entities in context
+    const missingEntities = new Map<
+      string,
+      { filePath: string; name: string }
+    >();
+
+    for (const entity of getAllEntities()) {
+      for (const ie of entity.metadata?.importedExports ?? []) {
+        const filePath = ie.resolvedFilePath ?? ie.filePath;
+        const entityName = ie.resolvedName ?? ie.name;
+        const key = `${filePath}:${entityName}`;
+
+        // Skip if already in context or already processed
+        if (context.getEntity(filePath, entityName) || processedKeys.has(key)) {
+          continue;
+        }
+
+        missingEntities.set(key, { filePath, name: entityName });
+      }
+    }
+
+    if (missingEntities.size === 0) {
+      break; // No more missing entities
+    }
+
+    console.log(
+      `CodeYam: Entity gathering iteration ${iterationCount}: Loading ${missingEntities.size} missing entities`,
+    );
+
+    // Mark all as processed before loading to prevent re-processing
+    for (const key of missingEntities.keys()) {
+      processedKeys.add(key);
+    }
+
+    // Group by file path for batch loading
+    const byFilePath = new Map<string, string[]>();
+    for (const { filePath, name } of missingEntities.values()) {
+      if (!byFilePath.has(filePath)) {
+        byFilePath.set(filePath, []);
+      }
+      byFilePath.get(filePath)!.push(name);
+    }
+
+    // Batch load entities by file path
+    const loadPromises = Array.from(byFilePath.entries()).map(
+      async ([filePath, names]) => {
+        const entities = await loadEntities({
+          projectId: project.id,
+          filePaths: [filePath],
+        });
+
+        if (!entities) return [];
+
+        // Filter to only the entities we need (loadEntities returns all for the file)
+        return entities.filter((e) => names.includes(e.name));
+      },
+    );
+
+    const results = await Promise.all(loadPromises);
+    const loadedEntities = results.flat();
+
+    // Add loaded entities to context
+    for (const entity of loadedEntities) {
+      context.addEntity(entity);
+
+      // Also register under 'default' alias if it's a default export
+      if (
+        entity.metadata &&
+        !entity.metadata.notExported &&
+        !entity.metadata.namedExport
+      ) {
+        context.addEntity(entity, 'default');
+      }
+    }
+
+    console.log(
+      `CodeYam: Loaded ${loadedEntities.length} entities in iteration ${iterationCount}`,
+    );
+  }
+
+  if (iterationCount >= MAX_ITERATIONS) {
+    console.log(
+      `CodeYam Warning: Entity gathering reached max iterations (${MAX_ITERATIONS}), some entities may be missing`,
+    );
+  }
+
+  console.log(
+    `CodeYam: Entity gathering complete after ${iterationCount} iteration(s), context has ${getAllEntities().length} entities`,
+  );
+}
+
 /**
  * Load the minimal set of analyses required to successfully run scenario capture.
  * This includes the root analyses (with scenarios) plus all recursive mock dependencies.
@@ -145,7 +259,7 @@ export default async function loadReadyToBeCaptured({
     `CodeYam: Loaded ${allRequiredAnalyses.size} total analyses for scenario capture`,
   );
 
-  // Populate the provided analysis context
+  // Populate the provided analysis context with analyses and their direct entities
   for (const analysis of allRequiredAnalyses.values()) {
     // Add the entity if it exists
     if (analysis.entity) {
@@ -156,6 +270,12 @@ export default async function loadReadyToBeCaptured({
     context.addAnalysis(analysis, analysis.filePath, analysis.entityName);
   }
 
+  // Recursively gather ALL entities referenced in importedExports.
+  // This is necessary because discoverDirectDependencies only finds entities that need
+  // ANALYSES loaded (skipping mocked imports, type imports, etc.), but writeScenarioComponents
+  // needs ALL entities in the context for import path rewriting and recursion.
+  await gatherAllReferencedEntities(context, project);
+
   // Extract the root analyses with scenarios from allRequiredAnalyses (they were reloaded with mocks)
   const finalReadyToBeCaptured = readyToBeCapturedAnalyses.map(
     (originalAnalysis) => {

package/analyzer-template/project/orchestrateCapture/KyselyAnalysisLoader.ts

@@ -1,5 +1,5 @@
 import type { Commit, Project } from '~codeyam/types';
-import { getDatabase } from '~codeyam/supabase';
+import { getDatabase } from '~codeyam/database';
 import { sql } from 'kysely';
 import type { AnalysisLoader, ReadyAnalysisData } from './taskRunner';
 
@@ -56,11 +56,7 @@ export default class KyselyAnalysisLoader implements AnalysisLoader {
 
         // Optional: branch commit SHA filter
         if (this.config.commit?.metadata?.baseline) {
-          query = query.where(
-            'branch_commit_sha',
-            '=',
-            this.config.commit.sha,
-          );
+          query = query.where('branch_commit_sha', '=', this.config.commit.sha);
         }
 
         // Optional: commit ID filter

package/analyzer-template/project/orchestrateCapture/SequentialCaptureTaskRunner.ts

@@ -37,7 +37,10 @@ import {
 export interface SequentialCaptureTaskRunnerContext {
   absoluteProjectRootPath: string;
   absoluteTempPath?: string;
-  startArgs: StartArgs;
+  startArgs: Omit<
+    StartArgs,
+    'absoluteProjectRootPath' | 'absoluteTempPath' | 'noServer' | 'fast'
+  >;
   /** Universal mocks to apply to the capturer's project directory */
   universalMocks?: UniversalMock[];
   /** Environment variables to pass to the spawned processes */
@@ -72,8 +75,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
     config: TaskRunnerConfig,
     context: SequentialCaptureTaskRunnerContext,
   ): Promise<SequentialCaptureTaskRunner> {
-    console.log('CodeYam DEBUG: Creating SequentialCaptureTaskRunner...');
-
     // Validate that cwd and project path share parent directory
     // Use realpathSync to resolve symlinks (e.g., /tmp -> /private/tmp on macOS)
     const parentOfCodeyam = fs.realpathSync(path.dirname(process.cwd()));
@@ -96,9 +97,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // Create capturer base directory
     if (!fs.existsSync(capturerPath)) {
-      console.log(
-        `CodeYam DEBUG: Creating capturer directory at ${capturerPath}`,
-      );
       fs.mkdirSync(capturerPath, { recursive: true });
     }
 
@@ -111,22 +109,17 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
       excludes: ['codeyam/log.txt', 'capturer-*'],
       silent: false,
     });
-    console.log('CodeYam DEBUG: Directory copy completed');
 
     // Sanitize env files in capturer project (replaces real values with mock placeholders)
     const capturerProjectPath = path.join(capturerPath, 'project');
     console.log('CodeYam: Sanitizing env files in capturer project...');
-    console.log(`CodeYam DEBUG: capturerProjectPath = ${capturerProjectPath}`);
     const sanitizeResult = sanitizeEnvFiles({
       projectPath: capturerProjectPath,
       log: (msg) => console.log(`CodeYam Sanitize: ${msg}`),
     });
-    console.log(
-      `CodeYam DEBUG: Env files sanitized - created: ${sanitizeResult.createdFiles.length}, sanitized: ${sanitizeResult.sanitizedFiles.length}`,
-    );
     if (sanitizeResult.sanitizedFiles.length > 0) {
       console.log(
-        `CodeYam DEBUG: Sanitized files: ${sanitizeResult.sanitizedFiles.join(', ')}`,
+        `CodeYam: Env files sanitized: ${sanitizeResult.sanitizedFiles.join(', ')}`,
       );
     }
 
@@ -139,7 +132,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
         mocks: context.universalMocks,
         projectPath: capturerProjectPath,
       });
-      console.log('CodeYam DEBUG: Universal mocks applied');
     }
 
     const runner = new SequentialCaptureTaskRunner(
@@ -150,12 +142,8 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
 
     // Start background processing loop
     // Each batch will spawn its own paired start+capture processes
-    console.log('CodeYam DEBUG: Starting processing loop...');
     runner.startProcessingLoop();
 
-    console.log(
-      'CodeYam DEBUG: SequentialCaptureTaskRunner created successfully',
-    );
     return runner;
   }
 
@@ -179,23 +167,18 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
   }
 
   private async runProcessingLoop(): Promise<void> {
-    console.log('CodeYam DEBUG: Processing loop started');
     while (!this.isCleanedUp) {
       if (this.queue.length === 0) {
         await new Promise((resolve) => setTimeout(resolve, 1000));
         continue;
       }
 
-      console.log(
-        `CodeYam DEBUG: Processing queue - ${this.queue.length} batches waiting`,
-      );
       this.isProcessing = true;
       const batch = this.queue.shift()!;
 
       try {
         await this.processBatch(batch);
 
-        console.log(`CodeYam DEBUG: Batch completed successfully`);
         // Notify callback of completion
         if (this.batchCompletedCallback) {
           this.batchCompletedCallback(batch);
@@ -210,7 +193,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
         this.isProcessing = false;
       }
     }
-    console.log('CodeYam DEBUG: Processing loop exited');
   }
 
   private async processBatch(analysisIds: string[]): Promise<void> {
@@ -330,9 +312,6 @@ export default class SequentialCaptureTaskRunner implements CaptureTaskRunner {
   }
 
   enqueueWork(analysisIds: string[]): Promise<void> {
-    console.log(
-      `CodeYam DEBUG: Enqueueing batch of ${analysisIds.length} analyses`,
-    );
     this.queue.push(analysisIds);
     return Promise.resolve();
   }

package/analyzer-template/project/orchestrateCapture/SupabaseAnalysisLoader.ts

@@ -1,5 +1,5 @@
 import type { Commit, Project } from '~codeyam/types';
-import { getSupabase } from '~codeyam/supabase';
+import { getSupabase } from '~codeyam/database';
 import type { AnalysisLoader, ReadyAnalysisData } from './taskRunner';
 
 interface SupabaseAnalysisLoaderConfig {
@@ -48,7 +48,7 @@ export default class SupabaseAnalysisLoader implements AnalysisLoader {
     let pageOffset = 0;
 
     while (true) {
-      const query = getSupabase()
+      const { data, error } = await getSupabase()
         .rpc('get_ready_to_be_captured_analyses', args)
         .select(
           'id, commit_id, branch_commit_sha, status->processingForCaptureAt',
@@ -56,7 +56,7 @@ export default class SupabaseAnalysisLoader implements AnalysisLoader {
         .range(pageOffset, pageOffset + pageSize - 1)
         .returns<ReadyAnalysisData[]>();
 
-      const { data, error } = await query;
+      const rows = data as ReadyAnalysisData[] | null;
 
       if (error) {
         console.error(
@@ -67,13 +67,13 @@ export default class SupabaseAnalysisLoader implements AnalysisLoader {
         return null;
       }
 
-      if (!data || data.length === 0) {
+      if (!rows || rows.length === 0) {
         break;
       }
 
-      allData.push(...data);
+      allData.push(...rows);
 
-      if (data.length < pageSize) {
+      if (rows.length < pageSize) {
         break;
       }
 

package/analyzer-template/project/orchestrateCapture.ts

@@ -23,7 +23,7 @@
  */
 
 import type { Commit, Project } from '~codeyam/types';
-import { updateCommitMetadata } from '~codeyam/supabase';
+import { updateCommitMetadata } from '~codeyam/database';
 
 import type {
   AnalysisLoader,

package/analyzer-template/project/prepareRepo.ts

@@ -39,7 +39,7 @@ export default async function prepareRepo(args: PrepareRepoArgs) {
       throw new Error(`Local project path does not exist: ${localProjectPath}`);
     }
 
-    awsLogDebugLevel(1, 'Rsyncing repo...');
+    awsLogDebugLevel(1, 'Syncing repo...');
 
     // Rsync project files respecting .gitignore to avoid copying secrets
     // (.env files, credentials, private keys, etc.) while preserving node_modules

package/analyzer-template/project/runAnalysis.ts

@@ -16,7 +16,7 @@ import {
   loadEntity,
   loadScenario,
   updateCommitMetadata,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import analyzeReadyToBeCaptured from './analyzeReadyToBeCaptured';
 import analyzeBaselineCommit from './analyzeBaselineCommit';
 import analyzeRegularCommit from './analyzeRegularCommit';

package/analyzer-template/project/runMultiScenarioServer.ts

@@ -11,7 +11,7 @@ import { startServer } from './startServer';
 import { awsLog, safeFileName } from '~codeyam/utils';
 import { recordErrorMessageForScenario } from './utils/errorHandling';
 import { Controller, TaskCompleteType } from './controller/startController';
-import { updateFreshAnalysisStatus, loadAnalysis } from '~codeyam/supabase';
+import { updateFreshAnalysisStatus, loadAnalysis } from '~codeyam/database';
 import getScenarioUrl from './getScenarioUrl';
 import { chromium } from 'playwright';
 import { ScenarioIterator } from './ScenarioIterator';
@@ -515,7 +515,7 @@ export async function runMultiScenarioServer({
       }
 
       // Advance iterator to next scenario
-      awsLog('CodeYam SERVER DEBUG: Advancing to next scenario', {
+      awsLog('CodeYam: Advancing to next scenario', {
         analysisId: analysis.id,
         currentScenarioName: scenario.name,
         nextScenarioIndex: i + 1,

package/analyzer-template/project/runScenarioServer.ts

@@ -11,7 +11,7 @@ import { startServer } from './startServer';
 import { awsLog, safeFileName } from '~codeyam/utils';
 import { recordErrorMessageForScenario } from './utils/errorHandling';
 import { Controller, TaskCompleteType } from './controller/startController';
-import { updateFreshAnalysisStatus, loadAnalysis } from '~codeyam/supabase';
+import { updateFreshAnalysisStatus, loadAnalysis } from '~codeyam/database';
 import getScenarioUrl from './getScenarioUrl';
 
 const closedScenarios: string[] = [];

package/analyzer-template/project/start.ts

@@ -5,7 +5,8 @@ import {
   loadBackgroundJob,
   loadProject,
   updateBackgroundJobProgress,
-} from '~codeyam/supabase';
+  updateCommitMetadata,
+} from '~codeyam/database';
 import { Commit, ProjectFramework, ServerCommand } from '~codeyam/types';
 import runCaptureOrchestration from './orchestrateCapture';
 import AwsCaptureTaskRunner from './orchestrateCapture/AwsCaptureTaskRunner';
@@ -172,6 +173,24 @@ async function main({
         awsLog(
           'CodeYam Capture: analysis completed, signaling orchestration to begin draining...',
         );
+
+        // Update commit metadata to mark analysis as complete
+        // This allows the UI to show the "Capturing..." state
+        // With orchestration, the same process handles both phases,
+        // so we clear analyzerPid and set capturePid for a clean state transition
+        if (sharedContext.commit?.sha) {
+          await updateCommitMetadata({
+            commitSha: sharedContext.commit.sha,
+            runStatusUpdate: {
+              analysisCompletedAt: new Date().toISOString(),
+              analyzerPid: undefined,
+              capturePid: process.pid,
+            },
+          }).catch((error) => {
+            awsLog(`Warning: Failed to update commit metadata: ${error}`);
+          });
+        }
+
         if (sendControlMessage) {
           sendControlMessage('drain');
         } else {
@@ -213,12 +232,8 @@ async function main({
               absoluteTempPath,
               startArgs: {
                 packageManager,
-                absoluteProjectRootPath,
-                absoluteTempPath,
                 framework,
-                noServer: false,
                 steps,
-                fast,
               },
               // Pass universal mocks so they're applied to the capturer's project directory
               universalMocks: sharedContext.project.metadata?.universalMocks,
@@ -253,6 +268,9 @@ async function main({
               : (sharedContext.commit ?? sharedContext.branchCommit),
           analysisIds: envConfig.analysisIds,
           entityShas: envConfig.entityShas,
+          // In local-sequential mode, use full=true to query all ready analyses for the project
+          // since we don't have specific analysisIds/entityShas and commit is null.
+          full: orchestrateCapture === 'local-sequential',
           taskRunner,
         });
         awsLog('CodeYam Capture: runCaptureOrchestration() completed');

package/analyzer-template/project/startScenarioCapture.ts

@@ -13,7 +13,7 @@ import {
 import removeScenario from './removeScenario';
 import { recordErrorMessageForScenario } from './utils/errorHandling';
 import { Controller } from './controller/startController';
-import { loadFile, updateFreshAnalysisStatus } from '~codeyam/supabase';
+import { loadFile, updateFreshAnalysisStatus } from '~codeyam/database';
 import {
   awsLog,
   awsLogDebugLevel,

package/analyzer-template/project/updateCommitBackgroundJob.ts

@@ -1,4 +1,4 @@
-import { updateBackgroundJobProgress } from '~codeyam/supabase';
+import { updateBackgroundJobProgress } from '~codeyam/database';
 import { BackgroundJob } from '~codeyam/types';
 export default async function updateCommitBackgroundJob(
   backgroundJob: BackgroundJob,

package/analyzer-template/project/utils/errorHandling.ts

@@ -1,6 +1,6 @@
 import { Analysis, Scenario } from '~codeyam/types';
 import emailErrorReport from '../emailErrorReport';
-import { updateFreshAnalysisStatus } from '~codeyam/supabase';
+import { updateFreshAnalysisStatus } from '~codeyam/database';
 
 export async function recordErrorMessageForScenario(
   analysis: Analysis,

package/analyzer-template/project/writeMockDataTsx.ts

@@ -101,16 +101,25 @@ const shouldBeMap = (mockKey: string, mergedDataStructure: any): boolean => {
 };
 
 /**
- * Normalize a function call key by stripping arguments and type parameters.
+ * Normalize a function call key by stripping arguments and type parameters,
+ * but preserving variable qualifiers (::variableName suffix).
  * e.g., "useLastLogLine(projectSlug, !!simulatingEntitySha)" -> "useLastLogLine()"
  * e.g., "useLoaderData<typeof loader>()" -> "useLoaderData()"
+ * e.g., "useFetcher()::entityDiffFetcher" -> "useFetcher()::entityDiffFetcher" (preserved)
+ * e.g., "useFetcher<T>()::entityDiffFetcher" -> "useFetcher()::entityDiffFetcher"
  */
 const normalizeKey = (key: string): string => {
-  if (key.endsWith(')') && key.includes('(')) {
+  // Check for variable qualifier (::variableName)
+  const qualifierMatch = key.match(/::[a-zA-Z_][a-zA-Z0-9_]*$/);
+  const qualifier = qualifierMatch ? qualifierMatch[0] : '';
+  const keyWithoutQualifier = qualifier ? key.slice(0, -qualifier.length) : key;
+
+  // Check if key ends with ) - indicating a function call (after removing qualifier)
+  if (keyWithoutQualifier.endsWith(')') && keyWithoutQualifier.includes('(')) {
     // Strip arguments: "foo(a, b)" -> "foo()"
-    const normalized = key.split('(')[0] + '()';
+    const normalized = keyWithoutQualifier.split('(')[0] + '()';
     // Strip type parameters: "foo<T>()" -> "foo()"
-    return cleanOutTypes(normalized);
+    return cleanOutTypes(normalized) + qualifier;
   }
   return key;
 };
@@ -162,11 +171,46 @@ function extractAllKeys(obj: JsonTypeDefinition | undefined): string[] {
   return keys;
 }
 
+/**
+ * Bare type markers that indicate a function was detected but has no actual return data.
+ * These should be filtered out of mock data output since they're just type hints.
+ */
+const BARE_TYPE_MARKERS = ['function', 'async-function'];
+
+/**
+ * Check if a value is a bare function type marker that should be filtered out.
+ * These markers indicate the LLM detected a function but couldn't generate meaningful mock data.
+ *
+ * Also catches TypeScript union types containing function, like:
+ * - "function | null"
+ * - "function | undefined"
+ * - "async-function | null"
+ */
+const isBareTypeMarker = (value: unknown): boolean => {
+  if (typeof value !== 'string') return false;
+
+  // Check for exact bare type markers
+  if (BARE_TYPE_MARKERS.includes(value)) return true;
+
+  // Check for TypeScript union types containing function type markers
+  // e.g., "function | null", "function | undefined", "async-function | null"
+  if (value.includes('|')) {
+    const parts = value.split('|').map((p) => p.trim());
+    // If any part is a bare type marker, treat the whole thing as a type marker
+    return parts.some((part) => BARE_TYPE_MARKERS.includes(part));
+  }
+
+  return false;
+};
+
 /**
  * Normalize mock data by merging entries that have the same normalized function name.
  * e.g., "useLastLogLine(projectSlug, !!simulatingEntitySha)" and
  *       "useLastLogLine(projectSlug, currentRunActive)" both become "useLastLogLine()"
  * Their values are deep-merged to ensure all attributes are accounted for.
+ *
+ * Also filters out bare function type markers like "validateInputs()": "function"
+ * which are just type hints without actual mock data.
  */
 const normalizeMockData = (
   mockData: Record<string, unknown>,
@@ -183,16 +227,40 @@ const normalizeMockData = (
     keyMapping.get(normKey)!.push(key);
   }
 
+  // Helper to check if a value is an empty object
+  const isEmptyObject = (value: unknown): boolean => {
+    return (
+      value !== null &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      Object.keys(value as object).length === 0
+    );
+  };
+
   // Second pass: merge values for duplicate normalized keys
   for (const [normKey, originalKeys] of keyMapping) {
     if (originalKeys.length === 1) {
       // No duplicates, use the original key (may be normalized or not based on safeString)
-      normalized[normKey] = mockData[originalKeys[0]];
+      const value = mockData[originalKeys[0]];
+      // Skip bare type markers like "function" or "async-function"
+      if (isBareTypeMarker(value)) {
+        continue;
+      }
+      // Skip empty objects - these cause "Objects are not valid as a React child" errors
+      // when mock functions return them (e.g., CheckCircle2() from lucide-react)
+      if (isEmptyObject(value)) {
+        continue;
+      }
+      normalized[normKey] = value;
     } else {
       // Multiple keys normalize to the same value - merge them
       let mergedValue: unknown = {};
       for (const origKey of originalKeys) {
         const value = mockData[origKey];
+        // Skip bare type markers when merging
+        if (isBareTypeMarker(value)) {
+          continue;
+        }
         if (
           value &&
           typeof value === 'object' &&
@@ -210,7 +278,17 @@ const normalizeMockData = (
           mergedValue = value;
         }
       }
-      normalized[normKey] = mergedValue;
+      // Only add if we have actual data (not just filtered type markers)
+      if (
+        mergedValue !== undefined &&
+        !isBareTypeMarker(mergedValue) &&
+        !(
+          typeof mergedValue === 'object' &&
+          Object.keys(mergedValue as object).length === 0
+        )
+      ) {
+        normalized[normKey] = mergedValue;
+      }
     }
   }
 
@@ -264,7 +342,14 @@ const jsonToCode = (
       }
 
       for (const key of Object.keys(jsonObj)) {
-        if (jsonObj[key] === undefined || jsonObj[key] === null) continue;
+        if (jsonObj[key] === undefined) continue;
+
+        // Preserve explicit null values - components check `value !== null`
+        // to distinguish "not loaded" (undefined) from "explicitly null"
+        if (jsonObj[key] === null) {
+          keyStrings.push(`${levelSpacing}"${safeString(key, level)}": null`);
+          continue;
+        }
 
         if (Array.isArray(jsonObj[key])) {
           if (key === '~~codeyam-jsx~~') {
@@ -437,6 +522,17 @@ const jsonToCode = (
             if (seenNormalizedFuncNames.has(funcName)) {
               continue;
             }
+
+            // Skip TypeScript union type markers like "function | null" - these are type hints
+            // that would produce invalid JavaScript if output as-is.
+            // Note: We only skip UNION types here (containing '|'), not bare 'function'
+            // because bare 'function' is transformed to () => {} below.
+            // Note: This must come BEFORE seenNormalizedFuncNames.add() so that
+            // if another key with the same funcName has actual data, it can be used.
+            if (stringValue.includes('|') && isBareTypeMarker(stringValue)) {
+              continue;
+            }
+
             seenNormalizedFuncNames.add(funcName);
 
             // Check if the string value looks like a function expression
@@ -483,6 +579,12 @@ const jsonToCode = (
               );
               continue;
             }
+            // Skip bare type markers like "function", "function | null", etc.
+            // For plain keys (not function signatures), these are just type hints
+            // that would produce invalid JavaScript if output as-is.
+            if (isBareTypeMarker(stringValue)) {
+              continue;
+            }
             keyStrings.push(
               `${levelSpacing}"${safeString(key, level)}": "${safeString(stringValue, level)}"`,
             );

package/analyzer-template/project/writeScenario.ts

@@ -1,6 +1,6 @@
 import { Analysis, ProjectFramework, Scenario } from '~codeyam/types';
 import { CODEYAM_MOCKS_DIRNAME, pushAnalysisError } from '~codeyam/utils';
-import { loadFile, upsertAnalysesWithScenarios } from '~codeyam/supabase';
+import { loadFile, upsertAnalysesWithScenarios } from '~codeyam/database';
 import writeScenarioFiles from './writeScenarioFiles';
 import { ImmutableAnalysisContext, ProjectAnalyzer } from '~codeyam/analyze';
 import getAppPath from './getAppPath';