@codeyam/codeyam-cli 0.1.0-staging.323686 → 0.1.0-staging.4684848

package/analyzer-template/project/writeMockDataTsx.ts

@@ -192,6 +192,36 @@ const safeString = (s: string, level: number) => {
   return s?.replace ? s.replace(/"/g, "'").replace(/\n/g, '\\n') : s;
 };
 
+/**
+ * Clean up malformed LLM-generated function values.
+ * The LLM sometimes generates function values with an invalid "(function)" prefix like:
+ * - "(function)() => {}"
+ * - "(function)(event) => {}"
+ * - "(function)(id) => {}"
+ *
+ * This strips the prefix and adds TypeScript `any` type annotations to parameters.
+ * Returns null if the value doesn't match the malformed pattern.
+ */
+const cleanMalformedFunctionValue = (value: string): string | null => {
+  // Match "(function)" followed by optional params in parens, then "=>"
+  const match = value.match(/^\(function\)(\([^)]*\))\s*=>\s*(.*)$/);
+  if (!match) return null;
+
+  const [, paramsWithParens, body] = match;
+
+  // Extract parameter names and add `: any` type annotation
+  // e.g., "(event)" -> "(event: any)", "()" -> "()"
+  const params = paramsWithParens.slice(1, -1).trim(); // Remove outer parens
+  const typedParams = params
+    ? params
+        .split(',')
+        .map((p) => `${p.trim()}: any`)
+        .join(', ')
+    : '';
+
+  return `(${typedParams}) => ${body}`;
+};
+
 /**
  * Check if a mock key's schema indicates it should be instantiated as a Map.
  * A Map is indicated by:
@@ -310,6 +340,38 @@ function extractAllKeys(obj: JsonTypeDefinition | undefined): string[] {
  */
 const BARE_TYPE_MARKERS = ['function', 'async-function'];
 
+/**
+ * Check if a string is a TypeScript arrow function type annotation rather than
+ * a valid JavaScript arrow function expression.
+ *
+ * TypeScript arrow types look like function expressions (they contain '=>') but
+ * their "body" is a type name, not a JS expression:
+ * - "() => void"
+ * - "(event: MouseEvent) => void"
+ * - "() => string"
+ * - "() => Promise<void>"
+ * - "(id: string, name: string) => boolean"
+ *
+ * Valid JS arrow functions have actual expression bodies:
+ * - "() => {}"
+ * - "() => 'hello'"
+ * - "(x) => x + 1"
+ * - "() => { console.log('hi'); }"
+ */
+const ARROW_TYPE_RETURN_TYPES =
+  /^(void|string|number|boolean|any|unknown|never|null|undefined|object|Date|Promise<\w+>)$/i;
+
+const isArrowFunctionTypeAnnotation = (value: string): boolean => {
+  const arrowIndex = value.indexOf('=>');
+  if (arrowIndex === -1) return false;
+
+  const body = value.slice(arrowIndex + 2).trim();
+
+  // A real JS function would have {}, an expression, a string literal, etc.
+  // A type annotation has a bare type keyword as the "body".
+  return ARROW_TYPE_RETURN_TYPES.test(body);
+};
+
 /**
  * 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.
@@ -336,6 +398,59 @@ const isBareTypeMarker = (value: unknown): boolean => {
   return false;
 };
 
+/**
+ * Escape newlines that appear inside string literals within a code string,
+ * while preserving structural newlines (those between statements/lines of code).
+ *
+ * This handles cases where LLM generates function bodies like:
+ * - "() => { console.log('line1\nline2'); }" - escape the \n inside the string
+ * - "() => {\n  console.log('x');\n}" - preserve structural \n between statements
+ * - "() => Promise.resolve('a\nb')" - escape the \n inside the string argument
+ *
+ * The algorithm tracks whether we're inside a string literal (single, double, or
+ * backtick quotes) and only escapes newlines that appear within quotes.
+ */
+const escapeNewlinesInStringLiterals = (code: string): string => {
+  let result = '';
+  let inString = false;
+  let stringChar = ''; // The quote character that started the current string
+
+  for (let i = 0; i < code.length; i++) {
+    const char = code[i];
+    const prevChar = i > 0 ? code[i - 1] : '';
+
+    // Check for string literal boundaries (single, double, or backtick quotes)
+    // Skip escaped quotes (preceded by backslash)
+    if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
+      if (!inString) {
+        // Starting a string literal
+        inString = true;
+        stringChar = char;
+      } else if (char === stringChar) {
+        // Ending the current string literal
+        inString = false;
+        stringChar = '';
+      }
+      // If char is a different quote type while in a string, it's just a character
+    }
+
+    // Escape newlines only when inside a string literal
+    if (char === '\n') {
+      if (inString) {
+        // Inside a string literal - escape the newline
+        result += '\\n';
+      } else {
+        // Outside string - keep the structural newline
+        result += char;
+      }
+    } else {
+      result += char;
+    }
+  }
+
+  return result;
+};
+
 /**
  * Normalize mock data by merging entries that have the same normalized function name.
  * e.g., "useLastLogLine(projectSlug, !!simulatingEntitySha)" and
@@ -734,13 +849,19 @@ const jsonToCode = (
               stringValue.startsWith('Promise.') ||
               stringValue.startsWith('new Promise');
 
+            // Check if the string contains newlines (potential issue for string literals)
+            const hasNewlines = stringValue.includes('\n');
+
             // Handle special type indicators that need transformation
             let outputValue: string;
             if (stringValue === 'promise' || looksLikePromise) {
               // The key is a function call (e.g., "revalidate()"), so output a function
               // that returns a Promise, not the Promise itself
+              // Important: Escape newlines inside Promise expressions to avoid
+              // "unterminated string literal" errors when the Promise contains
+              // multi-line string arguments like Promise.resolve('line1\nline2')
               const promiseExpr = looksLikePromise
-                ? stringValue
+                ? stringValue.replace(/\n/g, '\\n')
                 : 'Promise.resolve()';
               outputValue = `() => ${promiseExpr}`;
               console.log(
@@ -752,10 +873,49 @@ const jsonToCode = (
                 `CodeYam: Nested func transform (string->function): "${key}" -> "${funcName}": () => {}`,
               );
             } else if (looksLikeFunction) {
-              outputValue = stringValue;
-              console.log(
-                `CodeYam: Nested func transform (string): "${key}" -> "${funcName}": ${stringValue.substring(0, 30)}...`,
-              );
+              // Check for "[native code]" in function body — this is what
+              // Function.prototype.toString() returns for built-in functions.
+              // The LLM sometimes generates "function () { [native code] }" which
+              // is not valid JavaScript (the "[" is parsed as array destructuring).
+              if (stringValue.includes('[native code]')) {
+                outputValue = '() => {}';
+                console.log(
+                  `CodeYam: Nested func transform (native-code->noop): "${key}" -> "${funcName}": () => {}`,
+                );
+              } else if (cleanMalformedFunctionValue(stringValue)) {
+                // Check for malformed LLM-generated function values like "(function)() => {}"
+                // These have an invalid "(function)" prefix that must be stripped
+                outputValue = cleanMalformedFunctionValue(stringValue)!;
+                console.log(
+                  `CodeYam: Nested func transform (malformed->clean): "${key}" -> "${funcName}": ${outputValue}`,
+                );
+              } else if (isArrowFunctionTypeAnnotation(stringValue)) {
+                // TypeScript arrow function type annotations like "() => void",
+                // "(event: MouseEvent) => void", "() => Promise<void>" contain '=>'
+                // so they pass the looksLikeFunction check, but they are TYPE syntax,
+                // not valid JavaScript expressions. Convert to a no-op function.
+                outputValue = '() => {}';
+                console.log(
+                  `CodeYam: Nested func transform (type-annotation->function): "${key}" -> "${funcName}": () => {}`,
+                );
+              } else {
+                // Handle newlines in function expressions:
+                // - Newlines inside string literals must be escaped to avoid
+                //   "unterminated string literal" errors
+                // - Structural newlines (between statements) should be kept as-is
+                //   to produce valid multi-line JavaScript
+                //
+                // We escape ONLY newlines that appear inside string literals (single,
+                // double, or template quotes). Structural newlines are preserved.
+                if (hasNewlines) {
+                  outputValue = escapeNewlinesInStringLiterals(stringValue);
+                } else {
+                  outputValue = stringValue;
+                }
+                console.log(
+                  `CodeYam: Nested func transform (string): "${key}" -> "${funcName}": ${stringValue.substring(0, 30)}...`,
+                );
+              }
             } else {
               // Plain string value - must be quoted
               outputValue = `"${safeString(stringValue, level)}"`;
@@ -783,9 +943,22 @@ const jsonToCode = (
             if (isBareTypeMarker(stringValue)) {
               continue;
             }
-            keyStrings.push(
-              `${levelSpacing}"${safeString(key, level)}": "${safeString(stringValue, level)}"`,
-            );
+            // Check for malformed LLM-generated function values like "(function)(id) => {}"
+            // These can appear on plain keys (e.g., "closeToast") and need to be output as
+            // actual functions, not quoted strings
+            const cleanedPlainKeyFn = cleanMalformedFunctionValue(stringValue);
+            if (cleanedPlainKeyFn) {
+              keyStrings.push(
+                `${levelSpacing}"${safeString(key, level)}": ${cleanedPlainKeyFn}`,
+              );
+              console.log(
+                `CodeYam: Plain key func transform (malformed->clean): "${key}": ${cleanedPlainKeyFn}`,
+              );
+            } else {
+              keyStrings.push(
+                `${levelSpacing}"${safeString(key, level)}": "${safeString(stringValue, level)}"`,
+              );
+            }
           }
         } else {
           // Skip plain keys that have function-call versions (at the same nesting level where

package/analyzer-template/project/writeScenarioComponents.ts

@@ -987,10 +987,19 @@ function addMockToContent(
           /[.*+?^${}()|[\]\\]/g,
           '\\$&',
         );
-        // Create regex that matches the call (with optional whitespace variations)
+        // Create regex that matches the call (with optional whitespace variations).
+        // TypeScript formatters commonly break type parameters across lines, e.g.:
+        //   useLoaderData<
+        //     typeof loader
+        //   >()
+        // So we allow optional whitespace around < and > delimiters, not just
+        // where whitespace already exists in the call signature string.
         const callRegex = new RegExp(
-          escapedCallSignature.replace(/\s+/g, '\\s*'),
-          'g',
+          escapedCallSignature
+            .replace(/\s+/g, '\\s*')
+            .replace(/</g, '\\s*<\\s*')
+            .replace(/>/g, '\\s*>\\s*'),
+          'gs',
         );
         fileContent = fileContent.replace(callRegex, `${mockFunctionName}()`);
       }
@@ -1012,15 +1021,29 @@ function addMockToContent(
         rootAnalysis.metadata?.scenariosDataStructure?.dataForMocks;
 
       // Find matching call signature key in dataForMocks
+      // IMPORTANT: First try exact match with type parameters (e.g., "useLoaderData<LoaderData>()")
+      // to avoid picking the wrong variant (e.g., "useLoaderData<typeof loader>()" which may
+      // have different properties). Fall back to base name matching only if exact match fails.
       const hookBaseName = importedExport.name.split(/[<(]/)[0];
-      const callSignatureKey = dataForMocks
-        ? Object.keys(dataForMocks).find((key) => {
+      const expectedKey = importedExport.calls?.[0];
+      let callSignatureKey: string | undefined;
+
+      if (dataForMocks) {
+        const keys = Object.keys(dataForMocks);
+
+        // First try exact match with the expected call signature
+        if (expectedKey && keys.includes(expectedKey)) {
+          callSignatureKey = expectedKey;
+        } else {
+          // Fall back to base name matching
+          callSignatureKey = keys.find((key) => {
             // Split on ., <, or ( to get the true base name
             // This handles both "useFlags()" -> "useFlags" and "trpc.useUtils()" -> "trpc"
             const keyBaseName = key.split(/[.<(]/)[0];
             return keyBaseName === hookBaseName;
-          })
-        : undefined;
+          });
+        }
+      }
 
       // Use the call signature if found, otherwise construct it
       const dataKey =
@@ -1061,18 +1084,36 @@ function addMockToContent(
       // IMPORTANT: We inline scenarios().data() inside the function rather than
       // storing in a const - see comment in constructMockCode.ts for why.
       if (!mockCode) {
-        mockCode = `function ${importedExport.name}(...args) {
-  return scenarios().data()?.["${dataKey}"];
+        mockCode = `// PATCHED: memoize to return stable reference (prevents infinite useEffect re-triggers)
+const _${importedExport.name}Ref = {
+  current: null,
+};
+function ${importedExport.name}(...args) {
+  if (!_${importedExport.name}Ref.current) {
+    _${importedExport.name}Ref.current = scenarios().data()?.["${dataKey}"];
+  }
+  return _${importedExport.name}Ref.current;
 }`;
       }
     } else {
       // Helper to find matching call signature key from dataForMocks
+      // IMPORTANT: First try exact match with type parameters (e.g., "useLoaderData<LoaderData>()")
+      // to avoid picking the wrong variant. Fall back to base name matching only if needed.
       const hookBaseName = importedExport.name.split(/[<(]/)[0];
+      const expectedKey = importedExport.calls?.[0];
       const findMatchingKey = (
         dataForMocks: Record<string, unknown> | undefined,
       ): string | undefined => {
         if (!dataForMocks) return undefined;
-        return Object.keys(dataForMocks).find((key) => {
+        const keys = Object.keys(dataForMocks);
+
+        // First try exact match with the expected call signature
+        if (expectedKey && keys.includes(expectedKey)) {
+          return expectedKey;
+        }
+
+        // Fall back to base name matching
+        return keys.find((key) => {
           // Split on ., <, or ( to get the true base name
           // This handles both "useFlags()" -> "useFlags" and "trpc.useUtils()" -> "trpc"
           const keyBaseName = key.split(/[.<(]/)[0];
@@ -1131,8 +1172,15 @@ function addMockToContent(
       // IMPORTANT: We inline scenarios().data() inside the function rather than
       // storing in a const - see comment in constructMockCode.ts for why.
       if (!mockCode && dataKey) {
-        mockCode = `function ${importedExport.name}(...args) {
-  return scenarios().data()?.["${dataKey}"];
+        mockCode = `// PATCHED: memoize to return stable reference (prevents infinite useEffect re-triggers)
+const _${importedExport.name}Ref = {
+  current: null,
+};
+function ${importedExport.name}(...args) {
+  if (!_${importedExport.name}Ref.current) {
+    _${importedExport.name}Ref.current = scenarios().data()?.["${dataKey}"];
+  }
+  return _${importedExport.name}Ref.current;
 }`;
       }
     }

package/analyzer-template/project/writeSimpleRoot.ts

@@ -277,16 +277,17 @@ export default async function writeSimpleRoot(
               let mockKey: string | undefined;
 
               if (matchingKeys.length > 1) {
-                // Parse root.tsx to find how this hook is used
-                // Look for patterns like: const { prop1, prop2 } = useLoaderData()
-                // or: const result = useLoaderData()
+                // Parse root.tsx to find how this hook is used, INCLUDING type parameters
+                // Look for patterns like: const { prop1, prop2 } = useLoaderData<LoaderData>()
+                // or: const result = useLoaderData<typeof loader>()
                 const hookUsageRegex = new RegExp(
-                  `(?:const|let|var)\\s+(?:\\{([^}]+)\\}|([a-zA-Z_][a-zA-Z0-9_]*))\\s*=\\s*${entityName}(?:<[^>]*>)?\\s*\\(`,
+                  `(?:const|let|var)\\s+(?:\\{([^}]+)\\}|([a-zA-Z_][a-zA-Z0-9_]*))\\s*=\\s*${entityName}(<[^>]+>)?\\s*\\(`,
                   'g',
                 );
 
                 const matches = [...newContent.matchAll(hookUsageRegex)];
                 const rootPropertyNames: string[] = [];
+                const typeParamsUsed: Set<string> = new Set();
 
                 for (const match of matches) {
                   if (match[1]) {
@@ -300,17 +301,26 @@ export default async function writeSimpleRoot(
                     // Simple assignment: const result = ...
                     rootPropertyNames.push(match[2]);
                   }
+                  // Capture type parameters used (e.g., "<LoaderData>", "<typeof loader>")
+                  if (match[3]) {
+                    typeParamsUsed.add(match[3]);
+                  }
                 }
 
-                // Find a key that matches by call signature
-                // For call signature format (e.g., "useLoaderData()"), just use the first match
-                mockKey = matchingKeys[0];
+                // First, try to find a key that matches the exact type parameters used in the source
+                // e.g., if source has useLoaderData<LoaderData>(), prefer "useLoaderData<LoaderData>()" key
+                if (typeParamsUsed.size > 0) {
+                  for (const typeParam of typeParamsUsed) {
+                    const exactKey = `${entityName}${typeParam}()`;
+                    if (matchingKeys.includes(exactKey)) {
+                      mockKey = exactKey;
+                      break;
+                    }
+                  }
+                }
 
-                // Fallback: if no match found but there are multiple keys,
-                // exclude the route's key (which we can identify from mockedImports variable names)
+                // Fallback: if no exact type parameter match, use the first match
                 if (!mockKey) {
-                  // The route's variable names would be in its own analysis
-                  // For simplicity, just use the first key that's different from the most common pattern
                   mockKey = matchingKeys[0];
                 }
               } else if (matchingKeys.length === 1) {

package/background/src/lib/local/createLocalAnalyzer.js

@@ -16,7 +16,7 @@ export async function createAnalyzerTemplate(absoluteCodeyamRootPath) {
         await copyFolderToArchive({
             source: folder,
             destination: `${absoluteCodeyamRootPath}/${folderName}`,
-            exclude: ['__tests__'],
+            exclude: ['__tests__', 'node_modules'],
             recursive: true,
         });
     }

package/background/src/lib/local/createLocalAnalyzer.js.map

@@ -1 +1 @@
-{"version":3,"file":"createLocalAnalyzer.js","sourceRoot":"","sources":["../../../../../../background/src/lib/local/createLocalAnalyzer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"createLocalAnalyzer.js","sourceRoot":"","sources":["../../../../../../background/src/lib/local/createLocalAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,wBAAwB,CAAC;AACzD,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,SAAS,EAAE,EAEhB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AAErB,OAAO,YAAY,MAAM,qCAAqC,CAAC;AAC/D,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AAGzB;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,uBAA+B;IAC1E,MAAM,OAAO,GAAG,CAAC,QAAQ,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;IACpD,KAAK,MAAM,UAAU,IAAI,OAAO,EAAE,CAAC;QACjC,MAAM,MAAM,GAAG,yBAAyB,UAAU,EAAE,CAAC;QACrD,MAAM,mBAAmB,CAAC;YACxB,MAAM,EAAE,MAAM;YACd,WAAW,EAAE,GAAG,uBAAuB,IAAI,UAAU,EAAE;YACvD,OAAO,EAAE,CAAC,WAAW,EAAE,cAAc,CAAC;YACtC,SAAS,EAAE,IAAI;SAChB,CAAC,CAAC;IACL,CAAC;IAED,MAAM,mBAAmB,CAAC;QACxB,MAAM,EAAE,aAAa;QACrB,WAAW,EAAE,GAAG,uBAAuB,WAAW;QAClD,SAAS,EAAE,IAAI;QACf,OAAO,EAAE,CAAC,cAAc,EAAE,WAAW,EAAE,eAAe,CAAC;KACxD,CAAC,CAAC;IAEH,MAAM,mBAAmB,CAAC;QACxB,MAAM,EAAE,yBAAyB;QACjC,WAAW,EAAE,GAAG,uBAAuB,EAAE;KAC1C,CAAC,CAAC;IAEH,MAAM,mBAAmB,CAAC;QACxB,MAAM,EAAE,2BAA2B;QACnC,WAAW,EAAE,GAAG,uBAAuB,UAAU;KAClD,CAAC,CAAC;IAEH,MAAM,SAAS,CAAC;QACd,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,CAAC,KAAK,EAAE,mBAAmB,CAAC;QAClC,UAAU,EAAE,uBAAuB;KACpC,CAAC,CAAC;AACL,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC5C,uBAA+B;IAE/B,MAAM,SAAS,CAAC;QACd,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,CAAC,GAAG,CAAC;QACX,UAAU,EAAE,uBAAuB;KACpC,CAAC,CAAC;IAEH,MAAM,SAAS,CAAC;QACd,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,CAAC,YAAY,EAAE,SAAS,CAAC;QAC/B,UAAU,EAAE,uBAAuB;KACpC,CAAC,CAAC;IAEH,MAAM,SAAS,CAAC;QACd,OAAO,EAAE,KAAK;QACd,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC;QACtB,UAAU,EAAE,uBAAuB;KACpC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,uBAA+B,EAC/B,gBAAgB,GAAG,KAAK;IAExB,MAAM,sBAAsB,CAAC,uBAAuB,CAAC,CAAC;IAEtD,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,MAAM,wBAAwB,CAAC,uBAAuB,CAAC,CAAC;IAC1D,CAAC;AACH,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,uBAA+B,EAC/B,QAAgC,EAChC,SAAoB;IAEpB,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC;SACjC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC;SACxC,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,MAAM,SAAS,CAAC,GAAG,uBAAuB,OAAO,EAAE,GAAG,CAAC,CAAC;IACxD,OAAO,CAAC,GAAG,CAAC,6BAA6B,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC;IAEtE,MAAM,OAAO,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;IAExC,OAAO,MAAM,SAAS,CAAC;QACrB,OAAO,EAAE,MAAM;QACf,IAAI,EAAE,CAAC,sBAAsB,EAAE,yBAAyB,EAAE,GAAG,OAAO,CAAC;QACrE,UAAU,EAAE,uBAAuB;KACpC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAC3C,WAAmB,EACnB,uBAA+B;IAE/B,OAAO,MAAM,SAAS,CAAC;QACrB,OAAO,EAAE,MAAM;QACf,IAAI,EAAE;YACJ,sBAAsB;YACtB,8BAA8B;YAC9B,QAAQ;YACR,WAAW;SACZ;QACD,UAAU,EAAE,uBAAuB;KACpC,CAAC,CAAC;AACL,CAAC;AASD,MAAM,UAAU,gCAAgC,CAAC,EAC/C,uBAAuB,EACvB,QAAQ,EACR,SAAS,EACT,aAAa,GACiB;IAI9B,qEAAqE;IACrE,MAAM,GAAG,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC;SACjC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC;SACxC,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,EAAE,CAAC,aAAa,CAAC,GAAG,uBAAuB,OAAO,EAAE,GAAG,CAAC,CAAC;IAEzD,MAAM,OAAO,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;IAExC,OAAO,oBAAoB,CAAC;QAC1B,OAAO,EAAE,MAAM;QACf,IAAI,EAAE,CAAC,sBAAsB,EAAE,yBAAyB,EAAE,GAAG,OAAO,CAAC;QACrE,UAAU,EAAE,uBAAuB;QACnC,aAAa;QACb,WAAW,EAAE,UAAU;QACvB,GAAG,EAAE,QAAQ,EAAE,oDAAoD;KACpE,CAAC,CAAC;AACL,CAAC;AAQD,MAAM,UAAU,kCAAkC,CAAC,EACjD,WAAW,EACX,uBAAuB,EACvB,aAAa,GACmB;IAIhC,OAAO,oBAAoB,CAAC;QAC1B,OAAO,EAAE,MAAM;QACf,IAAI,EAAE;YACJ,sBAAsB;YACtB,8BAA8B;YAC9B,QAAQ;YACR,WAAW;SACZ;QACD,UAAU,EAAE,uBAAuB;QACnC,aAAa;QACb,WAAW,EAAE,SAAS;KACvB,CAAC,CAAC;AACL,CAAC"}

package/background/src/lib/virtualized/project/constructMockCode.js

@@ -957,11 +957,19 @@ options) {
                                     // Valid patterns where arrow function is NOT bare:
                                     // 1. Property value: "key: (arg) => ..." - ends with ':'
                                     // 2. Function argument: ".map((arg) => ..." - ends with '('
+                                    // 3. Method call: "?.map" followed directly by the arrow function
+                                    //    In this case, the '(' is consumed by the arrow function regex match,
+                                    //    so beforeTrimmed ends with the method name (e.g., 'map'), not '('.
+                                    //    We detect this by checking if beforeTrimmed ends with an identifier
+                                    //    that could be a method name (preceded by '.' or '?.').
                                     // NOTE: We don't include ',' because "{ prop, () => {} }" is invalid
                                     // (can't distinguish function argument from object property context)
                                     const isPropertyValue = beforeTrimmed.endsWith(':');
                                     const isFunctionArg = beforeTrimmed.endsWith('(');
-                                    const hasPropertyName = isPropertyValue || isFunctionArg;
+                                    // Check if before ends with a method call pattern like ".map" or "?.map"
+                                    // The '(' after the method name is consumed by the arrow function regex
+                                    const isMethodCallArg = /\??\.\w+$/.test(beforeTrimmed);
+                                    const hasPropertyName = isPropertyValue || isFunctionArg || isMethodCallArg;
                                     if (!hasPropertyName) {
                                         // This is a bare arrow function - filter it out
                                         // Found arrow function start, need to find its end
@@ -1162,6 +1170,16 @@ options) {
                                     returnValueContents = `${arrayBasePath}?.map((__item__, __idx__) => (\n${indent(trimmedContent)}\n))`;
                                 }
                                 else {
+                                    // When generating object-wrapped .map(), ensure original item data is preserved.
+                                    // If no data spread was included (e.g., because this is a plain array property,
+                                    // not a function return), add ...__item__ to spread the original item properties.
+                                    // Without this, the .map() would create new objects with only nested function
+                                    // properties, losing data like filePath, frontmatter, body, etc.
+                                    const hasDataSpread = mappedContents.includes('...scenarios()') ||
+                                        mappedContents.includes('...__item__');
+                                    if (!hasDataSpread) {
+                                        mappedContents = `...__item__,\n${mappedContents}`;
+                                    }
                                     returnValueContents = `${arrayBasePath}?.map((__item__, __idx__) => ({\n${indent(mappedContents)}\n}))`;
                                 }
                             } // Close the empty content check else block
@@ -1223,6 +1241,13 @@ options) {
                             mappedContents = filterOutArrowFunctions(mappedContents);
                             mappedContents = filterOutBareObjects(mappedContents, true);
                             mappedContents = cleanupContent(mappedContents);
+                            // Same as needsWrapper branch: ensure item data is preserved in .map()
+                            const hasDataSpreadInner = mappedContents.includes('...scenarios()') ||
+                                mappedContents.includes('...__item__');
+                            if (!hasDataSpreadInner && mappedContents.trim().length > 0) {
+                                // Insert ...__item__ after the opening brace
+                                mappedContents = mappedContents.replace(/^\s*\{/, '{\n...__item__,');
+                            }
                             returnValueContents = `${arrayBasePath}?.map((__item__, __idx__) => (\n${indent(mappedContents)}\n))`;
                         }
                     }
@@ -1423,6 +1448,36 @@ options) {
         }
         return 0;
     });
+    // OPTIMIZATION: Pre-compute prefix indexes for O(1) lookups instead of O(n) scans.
+    // This reduces complexity from O(n²) to O(n) for large schemas (9k+ keys).
+    //
+    // 1. extendedReturnValuePrefixes: Set of all path prefixes that have a .functionCallReturnValue extension
+    //    Used by hasExtendedFunctionCallReturnValue check at line ~1754
+    // 2. functionCallsWithReturnValue: Set of function call paths where .functionCallReturnValue IMMEDIATELY follows
+    //    Used by hasProperFunctionCallPath check at line ~1787
+    //    IMPORTANT: Only includes paths where the function call is directly followed by .functionCallReturnValue
+    //    e.g., "a.b().functionCallReturnValue" -> adds "a.b()" but NOT "a" even if "a" ends with ")"
+    const extendedReturnValuePrefixes = new Set();
+    const functionCallsWithReturnValue = new Set();
+    for (const k of relevantKeys) {
+        const parts = splitOutsideParenthesesAndArrays(k);
+        const returnValueIndex = parts.findIndex((part) => part.startsWith(RETURN_VALUE));
+        if (returnValueIndex !== -1) {
+            // Add all prefixes of k up to (but not including) functionCallReturnValue
+            const prefix = joinParenthesesAndArrays(parts.slice(0, returnValueIndex));
+            extendedReturnValuePrefixes.add(prefix);
+            // ONLY add to functionCallsWithReturnValue if functionCallReturnValue IMMEDIATELY follows
+            if (prefix.endsWith(')')) {
+                functionCallsWithReturnValue.add(prefix);
+            }
+            // Also add intermediate prefixes for nested paths to extendedReturnValuePrefixes
+            // This helps hasExtendedFunctionCallReturnValue which checks key + '.'
+            for (let i = 1; i < returnValueIndex; i++) {
+                const partialPrefix = joinParenthesesAndArrays(parts.slice(0, i));
+                extendedReturnValuePrefixes.add(partialPrefix);
+            }
+        }
+    }
     for (const key of sortedKeys) {
         const value = relevantReturnValueSchema[key];
         const parts = splitOutsideParenthesesAndArrays(key);
@@ -1468,7 +1523,9 @@ options) {
         // nested inside (e.g., methods on array elements passed as arguments).
         if (hasSignaturePath)
             continue;
-        const hasExtendedFunctionCallReturnValue = Object.keys(relevantReturnValueSchema).some((k) => k.startsWith(key + '.') && k.includes(`.${RETURN_VALUE}`));
+        // OPTIMIZATION: Use pre-computed index instead of O(n) scan
+        // Old code: Object.keys(relevantReturnValueSchema).some((k) => k.startsWith(key + '.') && k.includes('.functionCallReturnValue'))
+        const hasExtendedFunctionCallReturnValue = extendedReturnValuePrefixes.has(key);
         // Skip JSX components - they look like function calls (e.g., Context.Provider())
         // but they're React components used in JSX, not functions that need mocking
         // Check both the value type and whether the functionCallReturnValue is jsx-component
@@ -1493,7 +1550,9 @@ options) {
                     // This part is a function call, and the next part is NOT .functionCallReturnValue
                     // Check if there's any path with .functionCallReturnValue for this function call
                     const functionCallPath = joinParenthesesAndArrays(parts.slice(0, i + 1));
-                    const hasProperFunctionCallPath = Object.keys(relevantReturnValueSchema).some((k) => k.startsWith(functionCallPath + '.functionCallReturnValue'));
+                    // OPTIMIZATION: Use pre-computed index instead of O(n) scan
+                    // Old code: Object.keys(relevantReturnValueSchema).some((k) => k.startsWith(functionCallPath + '.functionCallReturnValue'))
+                    const hasProperFunctionCallPath = functionCallsWithReturnValue.has(functionCallPath);
                     if (hasProperFunctionCallPath) {
                         // Skip this path - the .functionCallReturnValue path will handle it correctly
                         shouldSkipKey = true;
@@ -2005,7 +2064,19 @@ options) {
         const safeReturnValue = isSimpleDataPath
             ? `${returnValue} ?? {}`
             : returnValue;
-        return `${isRootAsyncFunction ? 'async ' : ''}function ${safeFunctionName}(...args) {\n${indent(`return ${safeReturnValue};`)}\n}`;
+        const refName = `_${safeFunctionName}Ref`;
+        const assignment = `${refName}.current = ${safeReturnValue};`;
+        const ifBlock = `if (!${refName}.current) {\n${indent(assignment)}\n}`;
+        const body = `${ifBlock}\nreturn ${refName}.current;`;
+        return [
+            `// PATCHED: memoize to return stable reference (prevents infinite useEffect re-triggers)`,
+            `const ${refName} = {`,
+            `  current: null,`,
+            `};`,
+            `${isRootAsyncFunction ? 'async ' : ''}function ${safeFunctionName}(...args) {`,
+            indent(body),
+            `}`,
+        ].join('\n');
     }
     else {
         // Generate safe const name: