@codeyam/codeyam-cli 0.1.0-staging.323686 → 0.1.0-staging.4813bf3

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

@@ -19,7 +19,7 @@ export interface GenerateFlowsFromJsxUsagesArgs {
   /** Map of controllable paths to their types */
   attributesMap: Record<string, string>;
   /** Map from local variable names to data sources */
-  equivalentSignatureVariables: Record<string, string>;
+  equivalentSignatureVariables: Record<string, string | string[]>;
   /** Map from full paths to short paths */
   fullToShortPathMap: Record<string, string>;
   /** Structure map for type lookup */

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

@@ -743,6 +743,48 @@ function processScope({
   };
 }
 
+/**
+ * Check if a code string contains only type declarations (type aliases, interfaces, etc.)
+ * that don't contribute to runtime behavior. This is used to determine if the root scope
+ * should be considered "empty" for scope extraction purposes.
+ */
+function containsOnlyTypeDeclarations(code: string): boolean {
+  try {
+    const sourceFile = ts.createSourceFile(
+      'temp.ts',
+      code,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TS,
+    );
+
+    // Check each statement - if any is NOT a type-only declaration, return false
+    for (const statement of sourceFile.statements) {
+      if (
+        ts.isTypeAliasDeclaration(statement) ||
+        ts.isInterfaceDeclaration(statement) ||
+        ts.isEnumDeclaration(statement) ||
+        // Import declarations that are type-only
+        (ts.isImportDeclaration(statement) &&
+          statement.importClause?.isTypeOnly) ||
+        // Export declarations that are type-only
+        (ts.isExportDeclaration(statement) && statement.isTypeOnly)
+      ) {
+        // This is a type-only declaration, continue checking
+        continue;
+      }
+      // Found a non-type statement
+      return false;
+    }
+
+    // All statements are type-only (or there are no statements)
+    return sourceFile.statements.length > 0;
+  } catch {
+    // If parsing fails, assume it's not type-only
+    return false;
+  }
+}
+
 /**
  * Main entry point.
  *
@@ -792,9 +834,15 @@ export default function isolateScopes(
   const jsxLimit = options?.jsxLimit ?? 10;
   processJSXForScope(isolatedScopes, generateSyntheticName, jsxLimit);
 
-  // If the root scope text is empty and there's only one child scope,
-  // return that child scope as the root scope
-  if (isolatedScopes.text.trim().length === 0) {
+  // If the root scope text is empty (or only contains type declarations) and there's
+  // only one child scope, return that child scope as the root scope.
+  // Type declarations (type aliases, interfaces) don't contribute to runtime behavior,
+  // so we treat them as "empty" for scope extraction purposes.
+  const rootTextIsEffectivelyEmpty =
+    isolatedScopes.text.trim().length === 0 ||
+    containsOnlyTypeDeclarations(isolatedScopes.text);
+
+  if (rootTextIsEffectivelyEmpty) {
     const childScopeArray = Object.values(isolatedScopes.childScopes);
     if (childScopeArray.length === 1) {
       return childScopeArray[0];

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/mergeStatements.ts

@@ -7,58 +7,12 @@ import {
 
 export interface Statement {
   structure: { [key: string]: string };
-  equivalentVariables: { [key: string]: string };
+  // Supports multiple equivalencies per key for OR expressions (e.g., x = a || b)
+  equivalentVariables: { [key: string]: string | string[] };
   llmCall?: LlmCall;
 }
 
 export default function mergeStatements(statements: Statement[]) {
-  // Debug: Log input statements to understand what we're merging
-  const hasStateStructure = statements.some((s) =>
-    Object.keys(s.structure || {}).some(
-      (k) => k === 'state' || k.includes('state'),
-    ),
-  );
-  const hasStateEquiv = statements.some((s) =>
-    Object.keys(s.equivalentVariables || {}).some(
-      (k) => k === 'state' || k.includes('state'),
-    ),
-  );
-  if (hasStateStructure || hasStateEquiv) {
-    console.log(
-      `[UNION-TYPE] mergeStatements INPUT: ${statements.length} statements`,
-    );
-    statements.forEach((s, i) => {
-      const stateInStructure = Object.entries(s.structure || {}).filter(
-        ([k]) => k === 'state' || k.includes('state'),
-      );
-      const stateInEquiv = Object.entries(s.equivalentVariables || {}).filter(
-        ([k]) => k === 'state' || k.includes('state'),
-      );
-      const sigInEquiv = Object.entries(s.equivalentVariables || {}).filter(
-        ([k, v]) => k === 'state' || v === 'signature[0]',
-      );
-      if (
-        stateInStructure.length > 0 ||
-        stateInEquiv.length > 0 ||
-        sigInEquiv.length > 0
-      ) {
-        console.log(`[UNION-TYPE]   Statement ${i}:`);
-        if (stateInStructure.length > 0)
-          console.log(
-            `[UNION-TYPE]     structure: ${JSON.stringify(Object.fromEntries(stateInStructure))}`,
-          );
-        if (stateInEquiv.length > 0)
-          console.log(
-            `[UNION-TYPE]     equivalentVariables (state): ${JSON.stringify(Object.fromEntries(stateInEquiv))}`,
-          );
-        if (sigInEquiv.length > 0)
-          console.log(
-            `[UNION-TYPE]     equivalentVariables (sig): ${JSON.stringify(Object.fromEntries(sigInEquiv))}`,
-          );
-      }
-    });
-  }
-
   // This should be handled by the AST Analyzer but it currently has a bug
   const ensureFunctionCallReturnValue = (path: string, value: string) => {
     if (path.endsWith(')') && value !== 'function') {
@@ -172,12 +126,54 @@ export default function mergeStatements(statements: Statement[]) {
   // settingsData → fetcher.data.data uses fetcher::cyDuplicateKey1::.data.data
   const activeRemappings: Record<string, string> = {};
 
+  // Helper to normalize value to array and process
+  const normalizeValue = (value: string | string[]): string[] =>
+    Array.isArray(value) ? value : [value];
+
   const equivalentVariables = statements.reduce((acc: any, result) => {
-    for (const [key, value] of Object.entries(
+    for (const [key, rawValue] of Object.entries(
       result.equivalentVariables ?? {},
     )) {
+      // Handle arrays from AST analyzer (OR expressions like x = a || b)
+      // These should be preserved as arrays to track all sources
+      if (Array.isArray(rawValue)) {
+        const keyOptions = deBinaryPath(key);
+        const validValues = rawValue.filter(
+          (v): v is string => typeof v === 'string' && v.length > 0,
+        );
+        if (validValues.length === 0) continue;
+
+        // Process each array value through deBinaryPath
+        const allValueOptions: string[] = [];
+        for (const value of validValues) {
+          const valueOptions = deBinaryPath(value);
+          allValueOptions.push(...valueOptions);
+        }
+
+        // Remove duplicates while preserving order
+        const uniqueValueOptions = [...new Set(allValueOptions)];
+        const finalValue =
+          uniqueValueOptions.length === 1
+            ? uniqueValueOptions[0]
+            : uniqueValueOptions;
+
+        delete result.equivalentVariables[key];
+        if (keyOptions.length >= 2) {
+          for (const keyOption of keyOptions) {
+            result.equivalentVariables[keyOption] = finalValue;
+          }
+        } else {
+          result.equivalentVariables[keyOptions[0]] = finalValue;
+        }
+        continue;
+      }
+
+      // Original logic for string values with potential binary expressions in the string
+      const firstValue = rawValue;
+      if (!firstValue) continue;
+
       const keyOptions = deBinaryPath(key);
-      const valueOptions = deBinaryPath(value);
+      const valueOptions = deBinaryPath(firstValue);
       delete result.equivalentVariables[key];
       if (keyOptions.length === 2) {
         if (valueOptions.length === 2) {
@@ -199,27 +195,38 @@ export default function mergeStatements(statements: Statement[]) {
       }
     }
 
-    for (const [key, value] of Object.entries(
+    for (const [key, rawValue] of Object.entries(
       result.equivalentVariables ?? {},
     )) {
+      // Normalize to array for consistent handling
+      const values = normalizeValue(rawValue);
+
       // Apply any active remappings to the VALUE, but ONLY for property paths
       // e.g., if fetcher was remapped to fetcher::cyDuplicateKey1::,
       // then "fetcher.data.data" should become "fetcher::cyDuplicateKey1::.data.data"
       // However, we should NOT remap standalone variable references like "description"
       // because that would lose type information from the original variable.
-      let remappedValue = value;
-      for (const [originalKey, remappedKey] of Object.entries(
-        activeRemappings,
-      )) {
-        // Only remap if the value is a property path (contains a dot after the key)
-        // This preserves type information for simple variable references
-        const keyRegex = new RegExp(
-          `^${originalKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=\\.)`,
-        );
-        if (keyRegex.test(remappedValue)) {
-          remappedValue = remappedValue.replace(keyRegex, remappedKey);
+      const remappedValues = values.map((value) => {
+        let remappedValue = value;
+        for (const [originalKey, remappedKey] of Object.entries(
+          activeRemappings,
+        )) {
+          // Only remap if the value is a property path (contains a dot after the key)
+          // This preserves type information for simple variable references
+          const keyRegex = new RegExp(
+            `^${originalKey.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=\\.)`,
+          );
+          if (keyRegex.test(remappedValue)) {
+            remappedValue = remappedValue.replace(keyRegex, remappedKey);
+          }
         }
-      }
+        return remappedValue;
+      });
+
+      // Use array if multiple values, string if single
+      const remappedValue =
+        remappedValues.length === 1 ? remappedValues[0] : remappedValues;
+      const firstRemappedValue = remappedValues[0];
 
       if (acc[key]) {
         if (acc[key] === remappedValue) continue;
@@ -247,45 +254,32 @@ export default function mergeStatements(statements: Statement[]) {
   // If we have equivalentVariables[A] = B, and structure[A] is more specific than structure[B],
   // then update structure[B] to match structure[A]
   // This handles cases like: "state" -> "signature[0]" where "state" has a union type
-
-  // Debug: Log union types in merged structure
-  const unionTypesInStructure = Object.entries(structure).filter(
-    ([_, v]) => typeof v === 'string' && v.includes("'") && v.includes(' | '),
-  );
-  if (unionTypesInStructure.length > 0) {
-    console.log(
-      `[UNION-TYPE] mergeStatements: Found ${unionTypesInStructure.length} union types in merged structure`,
-    );
-    unionTypesInStructure.forEach(([k, v]) =>
-      console.log(`[UNION-TYPE]   structure["${k}"] = ${v}`),
-    );
-    console.log(
-      `[UNION-TYPE] mergeStatements: equivalentVariables = ${JSON.stringify(equivalentVariables)}`,
-    );
-  }
-
-  for (const [source, target] of Object.entries(equivalentVariables) as [
-    string,
+  for (const [source, rawTarget] of Object.entries(equivalentVariables) as [
     string,
+    string | string[],
   ][]) {
+    // Normalize to array for consistent handling
+    const targets = Array.isArray(rawTarget) ? rawTarget : [rawTarget];
     const sourceType = structure[source];
-    const targetType = structure[target];
 
-    // Check if source has a more specific type (union type vs generic type)
-    if (sourceType) {
-      const sourceIsUnion =
-        sourceType.includes("'") && sourceType.includes(' | ');
+    for (const target of targets) {
+      if (typeof target !== 'string') continue;
 
-      if (sourceIsUnion) {
-        // Target doesn't exist or is generic - propagate the union type
-        const targetIsGeneric =
-          !targetType || targetType === 'string' || targetType === 'unknown';
+      const targetType = structure[target];
 
-        if (targetIsGeneric) {
-          console.log(
-            `[UNION-TYPE] mergeStatements: Propagating "${source}" (${sourceType}) -> "${target}"`,
-          );
-          structure[target] = sourceType;
+      // Check if source has a more specific type (union type vs generic type)
+      if (sourceType) {
+        const sourceIsUnion =
+          sourceType.includes("'") && sourceType.includes(' | ');
+
+        if (sourceIsUnion) {
+          // Target doesn't exist or is generic - propagate the union type
+          const targetIsGeneric =
+            !targetType || targetType === 'string' || targetType === 'unknown';
+
+          if (targetIsGeneric) {
+            structure[target] = sourceType;
+          }
         }
       }
     }

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/gatherAttributesMap.ts

@@ -139,16 +139,19 @@ export function gatherAttributesMap(
       // Use merged type if available, otherwise fall back to isolated type
       const typeValue =
         mergedSignatureSchema[key] ?? isolatedSignatureSchema[key];
-      const equivalentSignatureVariable =
-        equivalentSignatureVariables[keyParts[0]];
-      const equivalentSignatureVariableParts = splitOutsideParenthesesAndArrays(
-        equivalentSignatureVariable,
-      );
+      // Handle array case (OR expressions) - use first element if array
+      const rawEquivalent = equivalentSignatureVariables[keyParts[0]];
+      const equivalentSignatureVariable = Array.isArray(rawEquivalent)
+        ? rawEquivalent[0]
+        : rawEquivalent;
+      const equivalentSignatureVariableParts = equivalentSignatureVariable
+        ? splitOutsideParenthesesAndArrays(equivalentSignatureVariable)
+        : [];
       if (
         equivalentSignatureVariable &&
-        !equivalentSignatureVariableParts[0].includes('(')
+        !equivalentSignatureVariableParts[0]?.includes('(')
       ) {
-        const equivalentKey = equivalentSignatureVariables[keyParts[0]];
+        const equivalentKey = equivalentSignatureVariable;
         const equivalentPath = joinParenthesesAndArrays([
           equivalentKey,
           ...keyParts.slice(1),

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/ai/src/lib/resolvePathToControllable.ts

@@ -525,7 +525,7 @@ function findControllableBaseForDerivedPath(
 export default function resolvePathToControllable(
   localPath: string,
   attributesMap: Record<string, string>,
-  equivalentSignatureVariables: Record<string, string>,
+  equivalentSignatureVariables: Record<string, string | string[]>,
   fullToShortPathMap: Record<string, string>,
 ): PathResolutionResult {
   const chain: string[] = [localPath];
@@ -600,7 +600,11 @@ export default function resolvePathToControllable(
 
   // 4. Equivalent variable resolution
   const localVarName = extractLocalVariableName(localPath);
-  const dataSourceBase = equivalentSignatureVariables[localVarName];
+  // Handle array case (OR expressions) - use first element if array
+  const rawDataSourceBase = equivalentSignatureVariables[localVarName];
+  const dataSourceBase = Array.isArray(rawDataSourceBase)
+    ? rawDataSourceBase[0]
+    : rawDataSourceBase;
 
   if (dataSourceBase) {
     chain.push(`equivalent var: ${localVarName} → ${dataSourceBase}`);
@@ -626,18 +630,26 @@ export default function resolvePathToControllable(
         baseVarName in equivalentSignatureVariables &&
         baseVarName !== localVarName
       ) {
-        const baseDataSource = equivalentSignatureVariables[baseVarName];
-        chain.push(`transitive resolution: ${baseVarName} → ${baseDataSource}`);
-        // Append the array access suffix to the resolved base
-        if (baseDataSource.endsWith('()')) {
-          fullResolvedPath =
-            baseDataSource + '.functionCallReturnValue' + accessSuffix;
-        } else if (baseDataSource.endsWith('.functionCallReturnValue')) {
-          fullResolvedPath = baseDataSource + accessSuffix;
-        } else {
-          fullResolvedPath = baseDataSource + accessSuffix;
+        // Handle array case (OR expressions) - use first element if array
+        const rawBaseDataSource = equivalentSignatureVariables[baseVarName];
+        const baseDataSource = Array.isArray(rawBaseDataSource)
+          ? rawBaseDataSource[0]
+          : rawBaseDataSource;
+        if (baseDataSource) {
+          chain.push(
+            `transitive resolution: ${baseVarName} → ${baseDataSource}`,
+          );
+          // Append the array access suffix to the resolved base
+          if (baseDataSource.endsWith('()')) {
+            fullResolvedPath =
+              baseDataSource + '.functionCallReturnValue' + accessSuffix;
+          } else if (baseDataSource.endsWith('.functionCallReturnValue')) {
+            fullResolvedPath = baseDataSource + accessSuffix;
+          } else {
+            fullResolvedPath = baseDataSource + accessSuffix;
+          }
+          chain.push(`transitively resolved: ${fullResolvedPath}`);
         }
-        chain.push(`transitively resolved: ${fullResolvedPath}`);
       }
     }
 

package/analyzer-template/packages/ai/src/lib/worker/SerializableDataStructure.ts

@@ -63,7 +63,7 @@ export interface EnrichedConditionalUsage {
   /** For comparison conditions, the literal values being compared against */
   comparedValues?: string[];
   /** Where this conditional usage occurs */
-  location: 'if' | 'ternary' | 'logical-and' | 'switch';
+  location: 'if' | 'ternary' | 'logical-and' | 'switch' | 'unconditional';
   /**
    * The traced source data path in the format "scopeName.path"
    * e.g., "useParams().functionCallReturnValue['*']"
@@ -120,7 +120,8 @@ export interface SerializableDataStructure {
   functionResults: Record<string, SerializableFunctionResult>;
 
   // Equivalent signature variables for root scope
-  equivalentSignatureVariables: Record<string, string>;
+  // Values can be arrays for OR expressions where a variable maps to multiple sources
+  equivalentSignatureVariables: Record<string, string | string[]>;
 
   environmentVariables: string[];
 
@@ -296,7 +297,7 @@ export function getSourceEquivalencies(
 
 export function getEquivalentSignatureVariables(
   dataStructure: SerializableDataStructure,
-): Record<string, string> {
+): Record<string, string | string[]> {
   return dataStructure.equivalentSignatureVariables;
 }
 

package/analyzer-template/packages/analyze/index.ts

@@ -41,6 +41,8 @@ export { default as mergeValidatedDataStructures } from './src/lib/files/scenari
 
 export { discoverDirectDependencies } from './src/lib/files/analyze/dependencyResolver';
 
+export { transformationTracer } from './src/lib/files/scenarios/TransformationTracer';
+
 export { default as getAnalysisError } from './src/lib/utils/getAnalysisError';
 export { default as measureAndReportExecutionTime } from './src/lib/utils/measureAndReportExecutionTime';