tests/vitest-angular/src/sourcemap/vitest.project.ts (1)

10-10: 💤 Low value

Double cast hides that angular() returns Plugin[], not Plugin.

angular(options) is typed as Plugin[]. Wrapping it in [...as unknown as Plugin] produces a Plugin[] whose first element is itself an array — Vite flattens nested plugin arrays at runtime so this works, but the cast obscures it and disables type checking. Spreading is clearer and keeps the type system honest:

-  plugins: [angular({ jit: false }) as unknown as Plugin],
+  plugins: [...angular({ jit: false })] as Plugin[],

Skip if the sibling projects already use the same as unknown as Plugin shape — repo consistency wins.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/vitest-angular/src/sourcemap/vitest.project.ts` at line 10, The plugins
array currently wraps angular({ jit: false }) with a double-cast to Plugin,
hiding that angular(...) actually returns Plugin[] and producing a nested array;
replace the casted single entry with a spread of the returned array (use
plugins: [...angular({ jit: false })]) and remove the unnecessary as unknown as
Plugin cast so TypeScript preserves the correct Plugin[] type for angular(),
unless you intentionally must match sibling projects' existing cast convention
for consistency.

tests/vitest-angular/src/sourcemap/sourcemap.spec.ts (2)

31-44: 💤 Low value

Test regression-bound to native Error.stack format — confirm the cross-runner story.

Error.stack line/column formatting differs between V8 (Chromium) and JavaScriptCore/Gecko. The Vitest browser config in vitest.config.ts only registers chromium, so today this is fine, but if anyone ever adds webkit/firefox instances the stack frame won't match sourcemap.spec.ts<...>:LINE and the test will start asserting not.toBeNull() against null. Worth a brief comment near the regex pinning the assumption to V8 stacks, or a fallback parser.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/vitest-angular/src/sourcemap/sourcemap.spec.ts` around lines 31 - 44,
The test "error stack maps back to the original TypeScript line" and the helper
parseSpecLine assume V8-style Error.stack formatting; update the code so this
assumption is explicit and robust: either add a brief comment next to
parseSpecLine explaining it pins to V8/Chromium stacks (so future contributors
know the limitation) and reference THROW_LINE/MAX_OFFSET in that comment, or
enhance parseSpecLine to detect and fall back to parsing WebKit/Gecko
stack-frame formats (accepting alternate regexes and returning the same line
number semantics) so the expect(...) checks remain valid across
chromium/firefox/webkit runners; modify parseSpecLine (and the test description
if needed) to reflect the chosen approach.

---

23-23: ⚡ Quick win

Hard-coded THROW_LINE = 34 is a maintenance trip-wire.

Any future reformatting (Prettier rule change, added import, edited block comment) of lines 1–33 silently shifts the throw line and either masks a regression or fails for the wrong reason. Since the goal is "stack reports a line close to the actual throw," capture the expected line at runtime instead — e.g., throw a probe error one line above and add 1. Keeps the test self-contained and resilient.

♻️ Self-anchoring throw line

-const THROW_LINE = 34;
-const MAX_OFFSET = 6;
+const MAX_OFFSET = 6;
+
+function currentLine(): number {
+  const m = /:(\d+)(?::\d+)?\)?$/.exec(new Error().stack?.split('\n')[2] ?? '');
+  return m ? Number(m[1]) : NaN;
+}
@@
 test('error stack maps back to the original TypeScript line', () => {
   let stack = '';
+  const expectedLine = currentLine() + 2;
   try {
     throw new Error('sourcemap probe');
   } catch (e) {
     stack = (e as Error).stack ?? '';
   }
   const reportedLine = parseSpecLine(stack);
   expect(reportedLine, `no spec frame in stack:\n${stack}`).not.toBeNull();
   expect(
-    Math.abs((reportedLine as number) - THROW_LINE),
-    `reported line ${reportedLine}, expected within ${MAX_OFFSET} of ${THROW_LINE}\n${stack}`,
+    Math.abs((reportedLine as number) - expectedLine),
+    `reported line ${reportedLine}, expected within ${MAX_OFFSET} of ${expectedLine}\n${stack}`,
   ).toBeLessThanOrEqual(MAX_OFFSET);
 });

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/vitest-angular/src/sourcemap/sourcemap.spec.ts` at line 23, Replace the
hard-coded THROW_LINE constant with a runtime-computed value: create a probe
Error thrown exactly one line above the real throw, parse its stack to extract
the probe's line number, and set the expected throw line to (probeLine + 1);
update any references to THROW_LINE to use this computed value so the test
remains stable against edits/reformatting (target the existing THROW_LINE
constant and the test block that performs the actual throw).

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes