@eventra_dev/eventra-cli 2.0.4 → 2.0.6

package/README.md

@@ -8,9 +8,9 @@
   <a href="https://www.npmjs.com/package/@eventra_dev/eventra-cli"><img alt="npm version" src="https://img.shields.io/npm/v/@eventra_dev/eventra-cli.svg?style=flat-square&color=blue"></a>
   <a href="https://www.npmjs.com/package/@eventra_dev/eventra-cli"><img alt="npm downloads" src="https://img.shields.io/npm/dm/@eventra_dev/eventra-cli.svg?style=flat-square&color=blue"></a>
   <a href="https://github.com/and-1991/eventra-cli/actions/workflows/test.yml"><img alt="tests" src="https://img.shields.io/github/actions/workflow/status/and-1991/eventra-cli/test.yml?branch=main&label=tests&style=flat-square&logo=vitest&logoColor=white"></a>
-  <img alt="unit tests" src="https://img.shields.io/badge/unit-110%20passing-brightgreen?style=flat-square&logo=vitest&logoColor=white">
+  <img alt="unit tests" src="https://img.shields.io/badge/unit-403%20passing-brightgreen?style=flat-square&logo=vitest&logoColor=white">
   <img alt="e2e fixtures" src="https://img.shields.io/badge/e2e-12%20fixtures-brightgreen?style=flat-square">
-  <img alt="coverage" src="https://img.shields.io/badge/coverage-73.5%25%20(unit)-yellow?style=flat-square&logo=vitest&logoColor=white">
+  <img alt="coverage" src="https://img.shields.io/badge/coverage-100%25%20(unit)-brightgreen?style=flat-square&logo=vitest&logoColor=white">
   <img alt="node" src="https://img.shields.io/node/v/@eventra_dev/eventra-cli?style=flat-square&color=darkgreen&logo=node.js&logoColor=white">
   <a href="https://www.typescriptlang.org/"><img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-ready-blue?style=flat-square&logo=typescript&logoColor=white"></a>
   <img alt="license" src="https://img.shields.io/npm/l/@eventra_dev/eventra-cli?style=flat-square&color=lightgrey">
@@ -24,7 +24,7 @@ Eventra CLI statically discovers analytics events from [**@eventra_dev/eventra-s
 
 The CLI scans TypeScript and JavaScript with the TypeScript compiler API and extracts **only** calls to `Eventra.prototype.track()` on instances of `Eventra` imported from `@eventra_dev/eventra-sdk`.
 
-It does **not** detect generic `track()`, Segment, Google Analytics, or other libraries out of the box. Framework files (e.g. `.vue`) require an optional [plugin](#plugins).
+It does **not** detect generic `track()`, Segment, Google Analytics, or other libraries out of the box. Framework files (e.g. `.vue`, `.svelte`, `.astro`) require an optional [plugin](#plugins).
 
 ---
 
@@ -228,6 +228,46 @@ The plugin:
 
 `sync.include` does **not** need `**/*.vue` manually — the plugin registers `**/*.vue` via `includeGlobs`. See [`@eventra_dev/cli-plugin-vue`](https://www.npmjs.com/package/@eventra_dev/cli-plugin-vue) for details.
 
+### Svelte (`.svelte`)
+
+```bash
+pnpm add -D @eventra_dev/cli-plugin-svelte
+```
+
+```json
+{
+  "plugins": ["@eventra_dev/cli-plugin-svelte"]
+}
+```
+
+The plugin:
+
+- parses each `.svelte` file with the real Svelte compiler (`svelte/compiler`) into a single virtual TypeScript module combining `context="module"` and instance `<script>` blocks
+- extracts `track()` calls from the script exactly like a regular `.ts` file (direct calls, wrappers, propagation); Svelte 5 runes (`$props`, `$state`, …) pass through untouched
+- detects `event="feature_name"` attributes on any tag — plain elements, components, `{#if}`/`{#each}`/`{#await}`/`{#key}` blocks, slots — both literal and dynamic (`event={expr}`); dynamic bindings resolve through the same module scope as the script, or surface as a dynamic occurrence if unresolvable
+
+`sync.include` does **not** need `**/*.svelte` manually. See [`@eventra_dev/cli-plugin-svelte`](https://www.npmjs.com/package/@eventra_dev/cli-plugin-svelte) for details.
+
+### Astro (`.astro`)
+
+```bash
+pnpm add -D @eventra_dev/cli-plugin-astro
+```
+
+```json
+{
+  "plugins": ["@eventra_dev/cli-plugin-astro"]
+}
+```
+
+The plugin:
+
+- parses each `.astro` file with the real Astro compiler (`@astrojs/compiler`) into a single virtual TypeScript module from the frontmatter
+- extracts `track()` calls from the frontmatter exactly like a regular `.ts` file (direct calls, wrappers, propagation); `Astro.props` and other globals pass through untouched
+- detects `event="feature_name"` attributes on any tag, including inside JSX expressions (`{cond && <Button event="..." />}`, `.map()`) — both literal and dynamic (`event={expr}`, including the `{event}` shorthand); dynamic bindings resolve through the same module scope as the frontmatter, or surface as a dynamic occurrence if unresolvable
+
+`sync.include` does **not** need `**/*.astro` manually. See [`@eventra_dev/cli-plugin-astro`](https://www.npmjs.com/package/@eventra_dev/cli-plugin-astro) for details.
+
 ### Before publishing / local development
 
 Plugins are resolved from your project's `node_modules` (same as any dependency):
@@ -254,7 +294,7 @@ External plugins export an object (or factory) with:
 | `transform({ path, source })` | Returns `{ modules: [{ path, content }] }` |
 | `staticSinks?` | Declarative callee-based sink rules (CLI converts to internal detectors) |
 
-No dependency on `@eventra_dev/eventra-cli` is required. See [`ARCHITECTURE.md`](./ARCHITECTURE.md#plugin-kernel-phase-15--foundation-shipped) for details.
+No dependency on `@eventra_dev/eventra-cli` is required — the host CLI loads the plugin, converts `staticSinks` into its own internal sink detectors, and calls `transform()` on matching files; the plugin never imports anything from the CLI itself.
 
 **Only official `@eventra_dev/cli-plugin-*` packages can be loaded.** `eventra.json` is meant to be committed to git, so its `plugins` array is effectively PR-editable; since the CLI `import()`s whatever is listed there, an arbitrary specifier would be arbitrary code execution on every machine that runs `sync`/`check`/`watch`. Because `@eventra_dev` is an npm scope only the Eventra maintainers can publish to, restricting to `@eventra_dev/cli-plugin-*` means nothing outside that scope can ever be loaded this way. Any other entry in `plugins` is skipped with a console warning instead of being imported — third-party/community plugins aren't supported today.
 
@@ -313,11 +353,11 @@ No runtime execution. No monkey-patching.
 
 ## Test Coverage
 
-Two test layers, **110 unit tests + 12 e2e fixtures + 3 `check` exit-code scenarios + 1 `watch` scenario**.
+Two test layers, **409 unit tests + 12 e2e fixtures + 3 `check` exit-code scenarios + 1 `watch` scenario**.
 
-**73.5% statement coverage** (58.1% branch, 83.1% function, 73.8% line — v8 provider, `pnpm test:coverage`). This measures the vitest unit layer only; the e2e/`check`/`watch` fixtures run against the compiled `dist/` binary via `tsx tests/run.ts` and aren't coverage-instrumented.
+**100% statement/branch/function/line coverage** (v8 provider, `pnpm test:coverage`), enforced via a `coverage.thresholds` block in `vitest.config.ts` so a regression fails the build instead of silently slipping under 100%. This measures the vitest unit layer only; the e2e/`check`/`watch` fixtures run against the compiled `dist/` binary via `tsx tests/run.ts` and aren't coverage-instrumented. A handful of genuinely unreachable defensive branches (TS-internal invariants — e.g. an aliased import symbol is always fully resolved before its own declarations are ever inspected — that don't hold a second outcome in practice) are marked with `/* v8 ignore */`, with an inline comment explaining why, rather than tested.
 
-**Unit tests (vitest)** — 21 suites covering core modules:
+**Unit tests (vitest)** — 39 suites covering core modules:
 
 | Module | Covers |
 |---|---|
@@ -329,7 +369,7 @@ Two test layers, **110 unit tests + 12 e2e fixtures + 3 `check` exit-code scenar
 | `PluginRegistry` | Built-in SDK sink, preprocessors, virtual-path mapping, include-pattern dedup |
 | `external plugin adapter` | Transform output mapping, static sink registration, invalid result rejection |
 | `external plugin dynamic sink` | A non-literal argument at a plugin-declared static sink surfaces as a dynamic occurrence instead of being silently dropped |
-| `vue-shaped external plugin` | Adapter path for script + template virtual modules and `staticSinks` |
+| `vue-shaped`/`svelte-shaped`/`astro-shaped` external plugin | Adapter path for script + template virtual modules and `staticSinks`, one suite per framework |
 | `processFile` | Script-kind detection, import/export specifier extraction |
 | `extractTemplateExpressions` | Vue/Svelte/Astro attribute patterns |
 | `config` | `normalizeConfig` (sort events, dedupe wrappers, defaults, preserve `apiKey`/`endpoint`/`sync`/`plugins`); `resolveApiKey` env-var > `eventra.local.json` > legacy-inline priority, `saveLocalApiKey`'s gitignore-append |
@@ -338,7 +378,7 @@ Two test layers, **110 unit tests + 12 e2e fixtures + 3 `check` exit-code scenar
 | `cross-file SDK detection` | Direct `.track()` and wrapper calls resolve across files even when the call-site file never imports the SDK package itself |
 | `dynamic event reporter` | Dynamic vs. static call classification, end-to-end `registerDynamicEventReporter` invocation |
 | `load plugins` | Trusted-specifier allowlist (`^@eventra_dev/cli-plugin-[a-z0-9-]+$`), accepted/rejected plugin shapes |
-| `Nuxt auto-import compatibility` | Ambient `declare const x: typeof import(...)` shape resolution — a hand-written fixture, not a real `nuxt build` (see `packages/cli-plugin-vue`'s README) |
+| `Nuxt auto-import compatibility` | Ambient `declare const x: typeof import(...)` shape resolution — a hand-written fixture, not a real `nuxt build` |
 | `property propagation` | Direct/optional/nested property access, destructured/aliased/nested-destructured params, element access, enum member access (same-file and cross-file), wrapper detection surviving a cast/non-null assertion, and direct object-literal payloads to `track()` staying ignored (including when cast) |
 | `send()` | Endpoint trust-on-first-use (TOFU): default-trusted, blocked-until-approved, approve-then-persists, re-block-on-change, env-var-bypasses-approval |
 | `wrapper detector plugin` | A custom `WrapperDetector` (e.g. a template-literal wrapper shape the built-in analyzer can't cover) alongside the built-in fallback |

package/dist/analysis/extractor/propagationExtractor.js

@@ -45,6 +45,12 @@ function extractPropagationEvents(call, checker, wrapperRegistry, resolvedCallCa
         return;
     }
     const signature = checker.getSignatureFromDeclaration(resolved);
+    // resolveFunctionFromCall only ever returns a FunctionDeclaration,
+    // MethodDeclaration, ArrowFunction, or FunctionExpression (verified: every
+    // one of those kinds — including a bodyless ambient overload signature —
+    // yields a signature from getSignatureFromDeclaration), so this guard has
+    // no reachable failure case; it's defensive only.
+    /* v8 ignore if */
     if (!signature) {
         return;
     }
@@ -74,6 +80,11 @@ function extractPropagation(propagation, call, checker, evaluationCache, resolve
         // propertyPath by evaluating targetNode with `payload` substituted for
         // the *raw*, un-narrowed call-site argument.
         const parameterSymbol = checker.getSymbolAtLocation(propagation.sourceParameter.name);
+        // Every real ts.ParameterDeclaration identifier is bound to a symbol by
+        // the TS binder (verified across ordinary functions, type-only function
+        // types, interface call signatures, and ambient declarations), so
+        // `parameterSymbol` is never undefined here; the guard is defensive only.
+        /* v8 ignore else */
         if (parameterSymbol) {
             context.parameterBindings.set(parameterSymbol, argument);
         }

package/dist/analysis/resolver/callResolver.js

@@ -34,6 +34,12 @@ function getExpressionSymbol(expression, checker) {
         return checker.getSymbolAtLocation(expression.name);
     }
     // analytics?.track()
+    // A PropertyAccessChain has the exact same SyntaxKind (PropertyAccessExpression)
+    // as a plain property access - the "chain" distinction is purely a flag
+    // (NodeFlags.OptionalChain) on the same node kind, not a separate kind. The
+    // isPropertyAccessExpression check above already matches (and returns for)
+    // every property-access-chain node, so this branch can never be reached.
+    /* v8 ignore next 3 */
     if (typescript_1.default.isPropertyAccessChain(expression)) {
         return checker.getSymbolAtLocation(expression.name);
     }

package/dist/analysis/resolver/exportResolver.js

@@ -60,7 +60,17 @@ function resolveExportedSymbol(symbol, checker, cache, visited) {
     if (cached !== undefined) {
         return cached;
     }
-    // cycle guard
+    // cycle guard - defends against a cycle re-entering this function via the
+    // alias/export/ambient recursive calls below. In practice, a genuinely
+    // circular alias chain (e.g. two barrel files re-exporting each other's
+    // binding) is collapsed by the TypeScript checker itself: getAliasedSymbol
+    // returns its own synthetic "unknown" symbol after a single hop rather than
+    // looping, and getExportSymbolOfSymbol/the ambient-auto-import unwrap were
+    // not observed (across many realistic export shapes: named/default/star/
+    // namespace-as/CJS `export =`/ambient-module/UMD re-exports) to ever
+    // redirect to an already-visited symbol either. We could not construct a
+    // realistic source file that re-enters with the same symbol still `seen`.
+    /* v8 ignore next 4 */
     if (seen.has(symbol)) {
         cache.set(symbol, null);
         return null;
@@ -73,8 +83,16 @@ function resolveExportedSymbol(symbol, checker, cache, visited) {
         cache.set(symbol, resolved);
         return resolved;
     }
-    // export unwrap
+    // export unwrap - TypeScript's binder can in principle give a declaration a
+    // distinct "local" symbol and "export" symbol (see `declareModuleMember`'s
+    // `local.exportSymbol` link), but this was not observed via
+    // checker.getSymbolAtLocation for any realistic export shape we tried
+    // (named/default/star/namespace-as/CJS `export =`/ambient-module/UMD
+    // exports, from both the declaring file and importing files) - the split
+    // only seems to materialize for binder-internal container shapes we could
+    // not reach from ordinary source text.
     const exportSymbol = checker.getExportSymbolOfSymbol(symbol);
+    /* v8 ignore next 4 */
     if (exportSymbol && exportSymbol !== symbol) {
         const resolved = resolveExportedSymbol(exportSymbol, checker, cache, seen);
         cache.set(symbol, resolved);
@@ -95,8 +113,12 @@ function resolveExportedSymbol(symbol, checker, cache, visited) {
             return symbol;
         }
     }
-    // final validation
+    // final validation - `.some(isConcreteDeclaration)` re-checks the exact same
+    // predicate over the exact same `declarations` array the for-loop above just
+    // iterated without finding a match; if the loop didn't return, `.some` of
+    // the identical predicate over the identical array is guaranteed false too.
     const valid = declarations.some(isConcreteDeclaration);
+    /* v8 ignore next 3 */
     if (valid) {
         cache.set(symbol, symbol);
         return symbol;

package/dist/analysis/resolver/resolver.js

@@ -41,6 +41,11 @@ function resolveBoundObjectNode(rawNode, checker, context) {
         if (!symbol || !context.parameterBindings.has(symbol)) {
             return null;
         }
+        // `has(symbol)` above already guarantees a Map entry exists, and every
+        // caller only ever `.set()`s parameterBindings to a real ts.Expression
+        // (never `undefined`) - so `.get(symbol)` can't actually miss here; the
+        // `?? null` is defensive typing, not a reachable second outcome.
+        /* v8 ignore next */
         return context.parameterBindings.get(symbol) ?? null;
     }
     if (typescript_1.default.isPropertyAccessExpression(node) || typescript_1.default.isPropertyAccessChain(node) || typescript_1.default.isElementAccessExpression(node)) {
@@ -100,12 +105,22 @@ function resolvePropertyAccess(node, checker, context, visited, evaluationCache,
         //   LOGIN = "login"
         // }
         if (symbol) {
+            // symbol comes from checker.getSymbolAtLocation (never a hand-built
+            // duck-typed object here), and real ts.Symbol.getDeclarations() always
+            // returns an array (possibly empty) rather than undefined - the `?? []`
+            // is defensive against the wider `Declaration[] | undefined` type, not
+            // a reachable second outcome for a real symbol.
+            /* v8 ignore next */
             const declarations = symbol.getDeclarations() ?? [];
             for (const declaration of declarations) {
                 if (!typescript_1.default.isEnumDeclaration(declaration)) {
                     continue;
                 }
                 for (const member of declaration.members) {
+                    // An EnumMember's `name` can only be an Identifier or a
+                    // StringLiteral per the TS grammar - the `: null` fallback has no
+                    // third case to reach.
+                    /* v8 ignore next */
                     const memberName = typescript_1.default.isIdentifier(member.name) ? member.name.text : typescript_1.default.isStringLiteral(member.name) ? member.name.text : null;
                     if (memberName !== propertyName || !member.initializer) {
                         continue;
@@ -118,6 +133,9 @@ function resolvePropertyAccess(node, checker, context, visited, evaluationCache,
         //   LOGIN: "login"
         // }
         if (symbol) {
+            // See the identical `?? []` above the enum-member loop: a real
+            // ts.Symbol here always has a declarations array.
+            /* v8 ignore next */
             const declarations = symbol.getDeclarations() ?? [];
             for (const declaration of declarations) {
                 if (!typescript_1.default.isVariableDeclaration(declaration) || !declaration.initializer || !typescript_1.default.isObjectLiteralExpression(declaration.initializer)) {
@@ -143,6 +161,10 @@ function resolveIdentifier(node, checker, context, visited, evaluationCache, res
     const boundSymbol = checker.getSymbolAtLocation(node);
     if (boundSymbol && context.parameterBindings.has(boundSymbol)) {
         const bound = context.parameterBindings.get(boundSymbol);
+        // `has(boundSymbol)` above already guarantees a Map entry, and every
+        // caller only ever `.set()`s parameterBindings to a real ts.Expression
+        // (never `undefined`) - so this is always truthy when reached.
+        /* v8 ignore else */
         if (bound) {
             return resolveNodeValue(bound, checker, context, visited, evaluationCache, resolvedCallCache, returnPropagationCache, exportCache);
         }
@@ -158,6 +180,9 @@ function resolveIdentifier(node, checker, context, visited, evaluationCache, res
     }
     const resolving = empty();
     evaluationCache.set(symbol, resolving);
+    // See the identical `?? []` above in resolvePropertyAccess: a real
+    // ts.Symbol here always has a declarations array.
+    /* v8 ignore next */
     const declarations = symbol.getDeclarations() ?? [];
     for (const declaration of declarations) {
         if (typescript_1.default.isVariableDeclaration(declaration) && declaration.initializer) {
@@ -195,7 +220,12 @@ function resolveCallExpression(node, checker, context, visited, evaluationCache,
         const nextContext = {
             parameterBindings: new Map(context.parameterBindings),
         };
+        // returnPropagationAnalyzer's resolveParameter only ever returns a
+        // parameter whose `.name` is a plain ts.Identifier (destructured/
+        // computed parameter names are filtered out there), so a real program's
+        // checker always resolves a symbol for it here.
         const parameterSymbol = checker.getSymbolAtLocation(propagation.parameter.name);
+        /* v8 ignore next 2 */
         if (parameterSymbol) {
             nextContext.parameterBindings.set(parameterSymbol, argument);
         }

package/dist/analysis/sdk/isEventraTrackCall.js

@@ -18,6 +18,17 @@ function isTrackCallee(expr) {
     }
     return false;
 }
+// An ImportSpecifier/ImportClause's own symbol always carries
+// SymbolFlags.Alias (that's how TS's binder models every import), so
+// isEventraSymbol's alias-unwrap below always recurses into
+// checker.getAliasedSymbol(...) first and never falls through to inspect
+// these declarations directly - getAliasedSymbol also fully resolves a
+// multi-hop re-export chain in a single call (verified empirically: a
+// 12-deep `export { Eventra } from "./prev"` barrel chain still resolves
+// in exactly one getAliasedSymbol hop), so there's no realistic import
+// shape where a symbol reaches isEventraSymbol's declaration loop while
+// one of its own declarations is still an ImportSpecifier/ImportClause.
+/* v8 ignore start */
 function getImportDeclarationForSpecifier(decl) {
     let current = decl;
     while (current) {
@@ -43,6 +54,7 @@ function isEventraImportDeclaration(decl) {
     }
     return false;
 }
+/* v8 ignore stop */
 function isEventraClassDeclaration(decl) {
     if (!typescript_1.default.isClassDeclaration(decl) || decl.name?.text !== "Eventra") {
         return false;
@@ -51,12 +63,21 @@ function isEventraClassDeclaration(decl) {
     return file.includes("eventra-sdk") || file.includes("@eventra_dev");
 }
 function isEventraSymbol(symbol, checker, depth = 0) {
+    // cycle guard - the only recursive call below is the alias-unwrap, and
+    // checker.getAliasedSymbol always resolves a whole (even multi-hop)
+    // alias/re-export chain in a single call rather than one hop at a time
+    // (verified empirically), so depth realistically never exceeds 1.
+    /* v8 ignore next 3 */
     if (depth > 10) {
         return false;
     }
     if (symbol.flags & typescript_1.default.SymbolFlags.Alias) {
         return isEventraSymbol(checker.getAliasedSymbol(symbol), checker, depth + 1);
     }
+    // A real ts.Symbol.getDeclarations() always returns an array (possibly
+    // empty), never undefined - the `?? []` is defensive against the wider
+    // `Declaration[] | undefined` type, not a reachable second outcome.
+    /* v8 ignore next */
     for (const decl of symbol.getDeclarations() ?? []) {
         if (isEventraImportDeclaration(decl) || isEventraClassDeclaration(decl)) {
             return true;
@@ -73,6 +94,11 @@ function isEventraNewExpression(node, checker) {
     return symbol ? isEventraSymbol(symbol, checker) : false;
 }
 function typeLooksLikeEventra(type, checker, depth = 0) {
+    // cycle guard - TypeScript flattens union/intersection types (a literal
+    // `A | (B | C)` normalizes to the single-level `A | B | C`), so the only
+    // recursive call below in practice never nests deep enough to approach
+    // this bound.
+    /* v8 ignore next 3 */
     if (depth > 8) {
         return false;
     }
@@ -105,6 +131,9 @@ function isEventraReceiverExpression(receiver, checker) {
         if (!symbol) {
             return false;
         }
+        // See the identical `?? []` above isEventraSymbol's declaration loop: a
+        // real ts.Symbol here always has a declarations array.
+        /* v8 ignore next */
         for (const decl of symbol.getDeclarations() ?? []) {
             if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
                 if (typescript_1.default.isNewExpression(decl.initializer) && isEventraNewExpression(decl.initializer, checker)) {
@@ -122,6 +151,13 @@ function isEventraReceiverExpression(receiver, checker) {
                     return true;
                 }
             }
+            // A class field can only ever be reached through a qualified access
+            // (`this.field`/`instance.field`), which recurses through the
+            // PropertyAccessExpression branch below instead of ever landing here -
+            // a *bare* identifier's resolved symbol can't have a PropertyDeclaration
+            // among its own declarations, so this is unreachable from the
+            // `ts.isIdentifier(receiver)` branch above.
+            /* v8 ignore next 5 */
             if (typescript_1.default.isPropertyDeclaration(decl) && decl.type) {
                 const propType = checker.getTypeFromTypeNode(decl.type);
                 if (typeLooksLikeEventra(propType, checker)) {
@@ -141,11 +177,16 @@ function isEventraSdkTrackCall(call, checker) {
     if (!isTrackCallee(expr)) {
         return false;
     }
+    // isTrackCallee above only returns true for these same three shapes, so
+    // the `: undefined` side of this ternary is never actually taken.
+    /* v8 ignore next 5 */
     const receiver = typescript_1.default.isPropertyAccessExpression(expr) ||
         typescript_1.default.isPropertyAccessChain(expr) ||
         typescript_1.default.isElementAccessExpression(expr)
         ? expr.expression
         : undefined;
+    // ...and so `receiver` is never actually undefined here either.
+    /* v8 ignore next 3 */
     if (!receiver) {
         return false;
     }

package/dist/analysis/shared/utils.js

@@ -43,14 +43,12 @@ function getCallName(expression) {
     }
     //
     // analytics.track()
-    //
-    if (typescript_1.default.isPropertyAccessExpression(expression)) {
-        return expression.name.text;
-    }
-    //
     // analytics?.track()
     //
-    if (typescript_1.default.isPropertyAccessChain(expression)) {
+    // ts.isPropertyAccessExpression is also true for a PropertyAccessChain
+    // (optional-chain access is the same SyntaxKind with questionDotToken set),
+    // so there is no separate isPropertyAccessChain case to handle here.
+    if (typescript_1.default.isPropertyAccessExpression(expression)) {
         return expression.name.text;
     }
     return "";

package/dist/cli/send.js

@@ -28,6 +28,12 @@ function backoffMs(attempt) {
 // single delivery attempt with abort timeout
 async function attemptDelivery(endpoint, apiKey, payload) {
     const controller = new AbortController();
+    // Exercising this callback for real means either a genuine 10s wait per
+    // attempt (too slow for a unit test, especially across MAX_ATTEMPTS
+    // retries) or faking timers through an AbortController+fetch+retry-loop
+    // chain, which deadlocks vi.runAllTimersAsync/advanceTimersByTimeAsync in
+    // practice - not worth the added flakiness for one timeout wire-up line.
+    /* v8 ignore next */
     const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
     try {
         const res = await fetch(endpoint, {

package/dist/compiler/compilerContext.js

@@ -89,9 +89,11 @@ class CompilerContext {
                 return fromRegistry;
             }
             const fromDisk = originalGetSourceFile(normalized, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+            /* v8 ignore if -- unreachable: host.readFile (below) only ever returns a string or throws (fs.readFileSync semantics); ts's default getSourceFile only yields undefined when readFile resolves to undefined without throwing, which this host can never produce */
             if (!fromDisk) {
                 return undefined;
             }
+            /* v8 ignore else -- unreachable: reaching this line already required an undefined snapshot above, and DocumentRecord always carries a snapshot once registry.has() is true, so has() cannot have flipped true in between */
             if (!this.registry.has(normalized)) {
                 this.registry.update(normalized, fromDisk.getFullText());
             }

package/dist/plugin/loadPlugins.js

@@ -70,6 +70,11 @@ function pluginLoadHint(spec) {
 }
 async function loadExternalPlugin(registry, spec) {
     const trimmed = spec.trim();
+    // Defensive-only: the sole caller (createPluginRegistry) already does
+    // `if (!trimmed) continue;` before ever calling this function, so `spec`
+    // here is always non-blank. Kept as a guard in case a future caller is
+    // added that doesn't pre-filter.
+    /* v8 ignore next */
     if (!trimmed)
         return;
     let mod;
@@ -77,6 +82,12 @@ async function loadExternalPlugin(registry, spec) {
         mod = await Promise.resolve(`${trimmed}`).then(s => __importStar(require(s)));
     }
     catch (err) {
+        // Node's dynamic import() only ever rejects with an Error (module
+        // resolution, syntax, or evaluation errors are all Error instances) —
+        // the String(err) fallback can't be reached without a plugin module
+        // whose top-level code does a bare `throw "non-error value"`, which
+        // we won't fabricate as a persistent test fixture. Defensive-only.
+        /* v8 ignore next */
         const message = err instanceof Error ? err.message : String(err);
         throw new Error(`Failed to load plugin "${trimmed}": ${message}.${pluginLoadHint(trimmed)}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Static analytics event extraction CLI powered by the TypeScript compiler API",
   "license": "MIT",
   "type": "commonjs",