snice 7.2.0 → 7.4.0

package/bin/project-analyzer.js

@@ -47,6 +47,11 @@ const LEGACY_LIT_LIFECYCLE = new Set([
   'performUpdate'
 ]);
 
+const NATIVE_ELEMENT_IDL_MEMBERS = new Set([
+  'autofocus', 'dir', 'hidden', 'id', 'inert', 'lang', 'role', 'slot',
+  'title', 'translate'
+]);
+
 const SNICE_REACT_EVENT_PROPS = new Set([
   'onInputChange', 'onSelectChange', 'onTextareaChange', 'onCheckboxChange',
   'onRadioChange', 'onSliderChange', 'onDateChange', 'onTimeChange',
@@ -426,6 +431,200 @@ const RULE_DEFINITIONS = [
       }
     }
   },
+  {
+    id: 'snice/light-render-root-with-styles',
+    severity: 'suggestion',
+    category: 'architecture',
+    description: 'Ask for an explicit integration reason before a styled element gives up shadow-root encapsulation.',
+    check(context) {
+      if (isFrameworkImplementation(context.filename) || isTestFilename(context.filename)) return;
+      for (const declaration of findDecoratedClasses(context.source, 'element')) {
+        const header = context.source.slice(declaration.index, declaration.bodyStart);
+        const option = /\b(?:renderRoot\s*:\s*['"]light['"]|shadow\s*:\s*false)/.exec(header);
+        if (!option || !/(?:@styles\b|\bstatic\s+styles\b)/.test(declaration.body)) continue;
+        context.report(declaration.index + option.index, {
+          message: `${declaration.name} opts into light DOM despite owning component styles, so selectors and internals are no longer encapsulated.`,
+          fix: "Use the default shadow render root. Keep renderRoot: 'light' only for a documented integration requirement such as native parser parentage or intentional global-CSS participation."
+        });
+      }
+    }
+  },
+  {
+    id: 'snice/translator-controller',
+    severity: 'suggestion',
+    category: 'architecture',
+    description: 'Recommend keeping internal-event translation in the element contract instead of a controller.',
+    check(context) {
+      if (isFrameworkImplementation(context.filename)) return;
+      for (const declaration of findDecoratedClasses(context.source, 'controller')) {
+        const onMethods = findDecoratedClassMethods(declaration.body, 'on');
+        const dispatchMethods = findDecoratedClassMethods(declaration.body, 'dispatch');
+        if (!onMethods.length || !dispatchMethods.length) continue;
+        const dispatchNames = new Set(dispatchMethods.map(method => method.name));
+        const translationMethods = new Set([
+          ...onMethods.map(method => method.name),
+          ...dispatchNames,
+          'attach',
+          'detach'
+        ]);
+        const translatesEveryHandler = onMethods.every(method =>
+          [...dispatchNames].some(name => new RegExp(`\\bthis\\.${escapeRegExp(name)}\\s*\\(`).test(method.body)) ||
+          /\bthis\.element(?:\?\.|\.)dispatchEvent\s*\(/.test(method.body)
+        );
+        const ownsState = [...inspectElementMembers(declaration.body).fields]
+          .some(name => name !== 'element');
+        const ownsOtherMethods = findClassMethods(declaration.body)
+          .some(method => !translationMethods.has(method.name));
+        const hasExternalBehavior = /\b(?:fetch|setTimeout|setInterval)\s*\(|\bnew\s+(?:WebSocket|EventSource|Worker)\s*\(|\b(?:localStorage|sessionStorage|indexedDB|caches)\b|@(request|respond|state|property)\b/.test(declaration.body);
+        if (!translatesEveryHandler || ownsState || ownsOtherMethods || hasExternalBehavior) continue;
+        context.report(declaration.index, {
+          message: `${declaration.name} only translates element events into other element events and owns no external behavior or state.`,
+          fix: 'Put visual behavior, internal-part handling, and semantic event dispatch in the element itself. Use a controller only for application behavior specific to a set of elements.'
+        });
+      }
+    }
+  },
+  {
+    id: 'snice/controller-event-origin',
+    severity: 'warning',
+    category: 'events',
+    description: 'Require shared controllers to distinguish their host event from the same event bubbling out of nested hosts.',
+    check(context) {
+      if (isFrameworkImplementation(context.filename)) return;
+      for (const declaration of findDecoratedClasses(context.source, 'controller')) {
+        const dispatched = new Set(
+          findDecoratedClassMethods(declaration.body, 'dispatch')
+            .flatMap(method => firstDecoratorStringArguments(method.decoratorArguments))
+        );
+        if (!dispatched.size) continue;
+        for (const handler of findDecoratedClassMethods(declaration.body, 'on')) {
+          const listened = firstDecoratorStringArguments(handler.decoratorArguments);
+          const onArguments = splitTopLevelArguments(handler.decoratorArguments);
+          const hasSelector = /^\s*(['"])[\s\S]*\1\s*$/.test(onArguments[1] ?? '');
+          if (hasSelector || !listened.some(event => dispatched.has(event))) continue;
+          const parameter = /^\s*([A-Za-z_$][\w$]*)/.exec(handler.parameters)?.[1];
+          if (!parameter || hasHostOriginCheck(handler.body, parameter)) continue;
+          const event = listened.find(name => dispatched.has(name));
+          context.report(declaration.bodyStart + handler.decoratorIndex, {
+            message: `${declaration.name} both listens for and dispatches "${event}" without checking that the event originated on its own host.`,
+            fix: `Guard the handler with if (${parameter}.target !== this.element) return; so the same event from a nested controller host is not handled twice.`
+          });
+        }
+      }
+    }
+  },
+  {
+    id: 'snice/controller-owns-routing',
+    severity: 'warning',
+    category: 'architecture',
+    description: 'Keep route parsing and navigation in routed pages instead of attached controllers.',
+    check(context) {
+      if (isFrameworkImplementation(context.filename)) return;
+      for (const declaration of findDecoratedClasses(context.source, 'controller')) {
+        const routing = /\bnew\s+URLSearchParams\s*\(|\b(?:window\.)?location\.(?:search|hash)\b|\b(?:window\.)?history\.(?:pushState|replaceState)\s*\(/.exec(declaration.body);
+        if (!routing) continue;
+        context.report(declaration.bodyStart + routing.index, {
+          message: `${declaration.name} owns URL parsing or navigation even though routing is page orchestration.`,
+          fix: 'Declare route/query parameters in @page({ routes }), receive them as page properties, and navigate through the Router. Keep the controller element-scoped.'
+        });
+      }
+    }
+  },
+  {
+    id: 'snice/imperative-controller-attach',
+    severity: 'suggestion',
+    category: 'architecture',
+    description: 'Prefer declarative controller bindings in application templates.',
+    check(context) {
+      if (isFrameworkImplementation(context.filename) || isTestFilename(context.filename)) return;
+      for (const localName of localsFor(context.provenance.rootBindings, 'attachController')) {
+        const pattern = new RegExp(`\\b${escapeRegExp(localName)}\\s*\\(`, 'g');
+        for (const match of context.source.matchAll(pattern)) {
+          context.report(match.index, {
+            message: `${localName}() imperatively attaches a controller in application code even though controller bindings own this lifecycle declaratively.`,
+            fix: 'Bind the decorated class in the owning template with controller=${ControllerClass}. Keep imperative attachment for focused framework tests only. Review docs/ai/controllers.md.'
+          });
+        }
+      }
+    }
+  },
+  {
+    id: 'snice/element-member-shadows-native-idl',
+    severity: 'warning',
+    category: 'properties',
+    description: 'Warn when a Snice element redeclares an inherited HTMLElement IDL member.',
+    check(context) {
+      if (isFrameworkImplementation(context.filename)) return;
+      for (const declaration of findSniceElementClasses(context.source)) {
+        const members = inspectElementMembers(declaration.body);
+        for (const name of new Set([...members.fields, ...members.accessors, ...members.reactive])) {
+          if (!NATIVE_ELEMENT_IDL_MEMBERS.has(name)) continue;
+          const relativeIndex = members.memberIndices.get(name) ?? 0;
+          context.report(declaration.bodyStart + relativeIndex, {
+            message: `${declaration.name}.${name} shadows HTMLElement.${name}, so native reflection/accessibility behavior and Snice property binding can conflict.`,
+            fix: `Rename the application-owned member. If native ${name} semantics are intended, use the inherited HTMLElement property/attribute without redeclaring it.`
+          });
+        }
+      }
+    }
+  },
+  {
+    id: 'snice/self-ready-await',
+    severity: 'error',
+    category: 'lifecycle',
+    description: 'Reject awaiting an element\'s own ready promise from one of its @ready handlers.',
+    check(context) {
+      for (const declaration of findSniceElementClasses(context.source)) {
+        for (const method of findDecoratedClassMethods(declaration.body, 'ready', declaration.bodyStart)) {
+          const wait = /\bawait\s+(?:Promise\.resolve\s*\(\s*)?this\.ready\b/.exec(method.body);
+          if (!wait) continue;
+          context.report(method.bodyStart + wait.index, {
+            message: `${declaration.name}.${method.name} awaits this.ready from inside @ready, so each side waits for the other and initialization cannot complete.`,
+            fix: 'Remove the self-wait. @ready already runs after the first render; await a child element\'s ready/rendered promise when child readiness is what the code needs.'
+          });
+        }
+      }
+    }
+  },
+  {
+    id: 'snice/stray-probe-test',
+    severity: 'warning',
+    category: 'testing',
+    description: 'Reject diagnostic test files whose assertions cannot fail.',
+    check(context) {
+      if (!isTestFilename(context.filename)) return;
+      const code = blankStringContents(context.source);
+      for (const match of code.matchAll(/\bexpect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*true\s*\)/g)) {
+        context.report(match.index, {
+          message: 'This test assertion is always true and looks like an abandoned diagnostic probe.',
+          fix: 'Delete the probe file or replace the assertion with an observable behavior or contract that can fail.'
+        });
+      }
+    }
+  },
+  {
+    id: 'snice/test-helper-value-without-event',
+    severity: 'suggestion',
+    category: 'testing',
+    description: 'Warn when a test helper that appears to simulate user input only writes a DOM property.',
+    check(context) {
+      if (!isTestFilename(context.filename)) return;
+      for (const helper of findNamedFunctionBodies(context.source)) {
+        if (!/^(?:(?:type|enter|fill|change|check|uncheck|toggle|select|edit|input)|set(?:Input|Field|Control))/i.test(helper.name)) continue;
+        const write = /\b([A-Za-z_$][\w$]*)\s*\.\s*(value|checked)\s*=(?!=|>)/.exec(helper.body);
+        if (!write) continue;
+        const target = escapeRegExp(write[1]);
+        const userSignal = new RegExp(
+          `\\b${target}\\s*\\.\\s*(?:dispatchEvent|click)\\s*\\(|\\b(?:fireEvent|userEvent)\\b|\\b(?:fill|check|uncheck|selectOption)\\s*\\(`
+        );
+        if (userSignal.test(helper.body)) continue;
+        context.report(helper.bodyStart + write.index, {
+          message: `${helper.name}() writes .${write[2]} but emits no event, so it changes mechanism state without simulating a user action.`,
+          fix: 'Dispatch the control\'s documented input/change event after the write, or use the test runner\'s user-interaction helper. Keep direct writes only in tests of the property API itself.'
+        });
+      }
+    }
+  },
   {
     id: 'snice/observe-target',
     severity: 'error',
@@ -650,6 +849,51 @@ const RULE_DEFINITIONS = [
       }
     }
   },
+  {
+    id: 'snice/live-control-value-binding',
+    severity: 'suggestion',
+    category: 'rendering',
+    description: 'Recommend live property bindings for controlled values on verified self-mutating Snice controls.',
+    check(context) {
+      const components = {
+        'snice-input': 'input',
+        'snice-textarea': 'textarea',
+        'snice-segmented-control': 'segmented-control'
+      };
+      for (const opening of findOpeningTags(context.source, Object.keys(components))) {
+        const binding = /(?:^|\s)value\s*=\s*(?:['"])?\$\{/.exec(opening.text);
+        if (!binding) continue;
+        const valueIndex = opening.index + binding.index + binding[0].indexOf('value');
+        context.report(valueIndex, {
+          message: `${opening.name} receives a dynamic value attribute, but its live value can diverge after user interaction.`,
+          fix: `For a controlled value, import live from 'snice' and use .value=\${live(value)} so an owner render compares with the control's current property. Keep value= only for an authored/reset default. Review docs/ai/components/${components[opening.name]}.md and docs/ai/bindings.md.`
+        });
+      }
+    }
+  },
+  {
+    id: 'snice/prefer-dispatch-decorator',
+    severity: 'suggestion',
+    category: 'events',
+    description: 'Prefer @dispatch for static CustomEvents emitted from a Snice host.',
+    check(context) {
+      if (isFrameworkImplementation(context.filename)) return;
+
+      const declarations = [
+        ...findSniceElementClasses(context.source).map(declaration => ({ declaration, role: 'element' })),
+        ...findDecoratedClasses(context.source, 'controller').map(declaration => ({ declaration, role: 'controller' }))
+      ];
+
+      for (const { declaration, role } of declarations) {
+        for (const dispatch of findManualCustomEventDispatches(declaration.body, role)) {
+          context.report(declaration.bodyStart + dispatch.index, {
+            message: `Manual host dispatch of "${dispatch.eventName}" duplicates the standard @dispatch CustomEvent path.`,
+            fix: `Prefer an emitter method decorated with @dispatch('${dispatch.eventName}') and return the detail payload directly. Keep dispatchEvent() when code needs the Event object, a dynamic event name, or the cancellation boolean. Review docs/ai/events.md.`
+          });
+        }
+      }
+    }
+  },
   {
     id: 'snice/custom-event-contract',
     severity: 'error',
@@ -1245,10 +1489,34 @@ const RULE_DEFINITIONS = [
     check() {}
   },
   {
-    id: 'snice/recommend-page-controller',
+    id: 'snice/recommend-page-decomposition',
     severity: 'suggestion',
     category: 'architecture',
-    description: 'Recommend extracting substantial or repeated non-visual page logic into a controller.',
+    description: 'Recommend decomposing an oversized page without attaching a controller to the page host.',
+    projectOnly: true,
+    check() {}
+  },
+  {
+    id: 'snice/controller-on-page-host',
+    severity: 'warning',
+    category: 'architecture',
+    description: 'Warn when a routed page imperatively attaches a controller to itself.',
+    projectOnly: true,
+    check() {}
+  },
+  {
+    id: 'snice/recommend-route-params',
+    severity: 'suggestion',
+    category: 'router',
+    description: 'Recommend declarative page route/query parameters instead of manual URL parsing and history writes.',
+    projectOnly: true,
+    check() {}
+  },
+  {
+    id: 'snice/shadowed-query-route',
+    severity: 'warning',
+    category: 'router',
+    description: 'Warn when same-page string route order makes a query-parameter variant unreachable.',
     projectOnly: true,
     check() {}
   },
@@ -1293,7 +1561,7 @@ const RULE_DEFINITIONS = [
  */
 export const PROJECT_ANALYZER_RULES = Object.freeze(
   RULE_DEFINITIONS.map(({ id, severity, category, description }) =>
-    Object.freeze({ id, severity, category, description })
+    Object.freeze({ id, code: id, severity, category, description })
   )
 );
 
@@ -1304,6 +1572,7 @@ export const PROJECT_ANALYZER_RULES = Object.freeze(
  * @param {string} [filename=''] Optional filename included in every diagnostic.
  * @returns {Array<{
  *   severity: 'error'|'warning'|'suggestion',
+ *   code: string,
  *   ruleId: string,
  *   message: string,
  *   fix: string,
@@ -1327,6 +1596,7 @@ export function analyzeSource(source, filename = '') {
     const location = sourceLocation(source, Math.max(0, nonSource.index));
     return [{
       severity: 'error',
+      code: 'snice/non-source-content',
       ruleId: 'snice/non-source-content',
       message: nonSource.message,
       fix: nonSource.fix,
@@ -1354,6 +1624,7 @@ export function analyzeSource(source, filename = '') {
         seen.add(key);
         const diagnostic = {
           severity: rule.severity,
+          code: rule.id,
           ruleId: rule.id,
           message: detail.message,
           fix: detail.fix,
@@ -1403,8 +1674,16 @@ export function analyzeProject(files) {
       continue;
     }
     const analyzable = maskComments(file.source);
+    const staleGuardOwners = ['page', 'element', 'controller'].flatMap(kind =>
+      findDecoratedClasses(analyzable, kind).map(declaration => ({
+        kind,
+        start: declaration.bodyStart,
+        end: declaration.bodyStart + declaration.body.length
+      }))
+    );
     for (const guard of analyzable.matchAll(/\b(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*\+\+this\.([A-Za-z_$][\w$]*(?:Id|Version|Token|Generation))\b([\s\S]{0,2000}?)\b(?:\1\s*!==?\s*this\.\2|this\.\2\s*!==?\s*\1)/g)) {
-      staleGuards.push({ file, index: guard.index, field: guard[2] });
+      const owner = staleGuardOwners.find(candidate => guard.index >= candidate.start && guard.index < candidate.end);
+      staleGuards.push({ file, index: guard.index, field: guard[2], owner: owner?.kind });
     }
     const provenance = buildSourceProvenance(analyzable);
     routerConstructions.push(
@@ -1657,6 +1936,59 @@ export function analyzeProject(files) {
     if (!declarationsByClass.has(key)) declarationsByClass.set(key, []);
     declarationsByClass.get(key).push(declaration);
   }
+
+  for (const page of pageClasses) {
+    const selfAttachment = /\battachController\s*\(\s*this\s*,|\bthis\.controller\s*=/.exec(page.body);
+    if (selfAttachment) {
+      const index = page.bodyStart + selfAttachment.index;
+      const location = sourceLocation(page.file.source, index);
+      diagnostics.push({
+        severity: 'warning',
+        ruleId: 'snice/controller-on-page-host',
+        message: `${page.name} attaches a controller to its own page host, coupling two lifecycle owners for one route.`,
+        fix: 'Keep element orchestration in the page. Put application behavior specific to a set of elements in a controller and bind it where the page composes those elements. A host-free reusable function may stay a plain module.',
+        file: page.file.filename,
+        line: location.line,
+        column: location.column
+      });
+    }
+
+    const manualRoute = /\bnew\s+URLSearchParams\s*\(|\b(?:window\.)?location\.search\b|\b(?:window\.)?history\.(?:pushState|replaceState)\s*\(/.exec(page.body);
+    if (manualRoute) {
+      const index = page.bodyStart + manualRoute.index;
+      const location = sourceLocation(page.file.source, index);
+      diagnostics.push({
+        severity: 'suggestion',
+        ruleId: 'snice/recommend-route-params',
+        message: `${page.name} parses or writes URL state manually even though route/query parameters can be declared by the page.`,
+        fix: "Declare parameters in @page({ routes: ['/path?q=:query'] }), receive them as page properties before @ready, and call the Router's navigate(path) to write route state. Review docs/ai/routing.md.",
+        file: page.file.filename,
+        line: location.line,
+        column: location.column
+      });
+    }
+
+    const precedingBareRoutes = new Set();
+    for (const route of findPageStringRoutes(page.file.source, page.index)) {
+      const queryIndex = route.spec.indexOf('?');
+      const pathname = queryIndex >= 0 ? route.spec.slice(0, queryIndex) : route.spec;
+      if (queryIndex < 0) {
+        precedingBareRoutes.add(pathname);
+        continue;
+      }
+      if (!precedingBareRoutes.has(pathname)) continue;
+      const location = sourceLocation(page.file.source, route.index);
+      diagnostics.push({
+        severity: 'warning',
+        ruleId: 'snice/shadowed-query-route',
+        message: `${page.name}'s query route "${route.spec}" is shadowed by an earlier "${pathname}" entry with the same specificity, so its query properties never bind.`,
+        fix: `Move "${route.spec}" before "${pathname}" in the routes array, or use route objects with explicit order values when a more complex tie-break is intentional. Review docs/ai/routing.md.`,
+        file: page.file.filename,
+        line: location.line,
+        column: location.column
+      });
+    }
+  }
   for (const [key, declarations] of declarationsByClass) {
     const page = declarations.find(declaration => declaration.decorator === 'page');
     const element = declarations.find(declaration => declaration.decorator === 'element');
@@ -1751,14 +2083,15 @@ export function analyzeProject(files) {
     }
   }
 
-  if (new Set(staleGuards.map(guard => guard.file.filename)).size >= 2) {
-    for (const guard of staleGuards) {
+  const repeatedStaleGuards = new Set(staleGuards.map(guard => guard.file.filename)).size >= 2;
+  if (repeatedStaleGuards) {
+    for (const guard of staleGuards.filter(candidate => candidate.owner)) {
       const location = sourceLocation(guard.file.source, guard.index);
       diagnostics.push({
         severity: 'suggestion',
         ruleId: 'snice/duplicated-stale-guard',
         message: `A ${guard.field} stale-response guard is repeated across project files.`,
-        fix: 'Extract the shared fetch/loading/error/stale-response lifecycle into a controller under src/controllers/. Review docs/ai/controllers.md.',
+        fix: 'Extract host-free request sequencing into a plain module in the project\'s chosen location. Keep element-specific application behavior in controllers and element orchestration in pages. Review docs/ai/architecture.md.',
         file: guard.file.filename,
         line: location.line,
         column: location.column
@@ -1766,21 +2099,21 @@ export function analyzeProject(files) {
     }
   }
 
-  const pageControllerReported = new Set();
+  const pageDecompositionReported = new Set();
   for (const page of pageClasses) {
     const profile = pageLogicProfile(page.body);
     if (!profile.recommend) continue;
     const location = sourceLocation(page.file.source, page.index);
     diagnostics.push({
       severity: 'suggestion',
-      ruleId: 'snice/recommend-page-controller',
+      ruleId: 'snice/recommend-page-decomposition',
       message: `${page.name} contains substantial non-visual logic (${profile.effectfulMethods} effectful methods, ${profile.effects} external effects, ${profile.decisions} decision points).`,
-      fix: `Keep route orchestration and presentation in the page; move reusable data, business, timer, storage, or server behavior into a controller under src/controllers/. Review docs/ai/controllers.md and docs/ai/architecture.md.`,
+      fix: 'Keep visual behavior in elements, application behavior specific to a set of elements in controllers, and element orchestration in the page. A host-free reusable function may stay a plain module. Review docs/ai/architecture.md.',
       file: page.file.filename,
       line: location.line,
       column: location.column
     });
-    pageControllerReported.add(`${page.file.filename}:${page.index}`);
+    pageDecompositionReported.add(`${page.file.filename}:${page.index}`);
   }
 
   const repeatedPageMethods = new Map();
@@ -1797,18 +2130,18 @@ export function analyzeProject(files) {
     if (files.length < 2) continue;
     for (const { page, method } of occurrences) {
       const reportKey = `${page.file.filename}:${page.index}`;
-      if (pageControllerReported.has(reportKey)) continue;
+      if (pageDecompositionReported.has(reportKey)) continue;
       const location = sourceLocation(page.file.source, method.index);
       diagnostics.push({
         severity: 'suggestion',
-        ruleId: 'snice/recommend-page-controller',
+        ruleId: 'snice/recommend-page-decomposition',
         message: `${method.name}() repeats substantial non-visual logic across ${files.length} page files.`,
-        fix: `Extract the shared behavior into a controller under src/controllers/ and let each page orchestrate it. Also review docs/ai/controllers.md and docs/ai/architecture.md.`,
+        fix: 'Keep visual behavior in elements, application behavior specific to a set of elements in controllers, and element orchestration in pages. Extract this host-free reusable operation into a plain module in the project\'s chosen location. Review docs/ai/architecture.md.',
         file: page.file.filename,
         line: location.line,
         column: location.column
       });
-      pageControllerReported.add(reportKey);
+      pageDecompositionReported.add(reportKey);
     }
   }
 
@@ -1827,7 +2160,9 @@ export function analyzeProject(files) {
     }
   }
 
-  return diagnostics.sort(compareProjectDiagnostics);
+  return diagnostics
+    .map(diagnostic => diagnostic.code ? diagnostic : { ...diagnostic, code: diagnostic.ruleId })
+    .sort(compareProjectDiagnostics);
 }
 
 /**
@@ -2077,10 +2412,91 @@ function findSniceElementClasses(source) {
   return declarations;
 }
 
+/**
+ * Find standalone, static CustomEvent dispatches that @dispatch can express
+ * without changing control flow. Calls whose return value is consumed, whose
+ * event name is dynamic, or whose target is not the Snice host are deliberately
+ * left alone as valid low-level event code.
+ */
+function findManualCustomEventDispatches(body, role) {
+  const dispatches = [];
+  const pattern = role === 'controller'
+    ? /\bthis\s*\.\s*element\s*(?:\?\.\s*|\.\s*)dispatchEvent\s*\(/g
+    : /\bthis\s*\.\s*dispatchEvent\s*\(/g;
+
+  for (const match of body.matchAll(pattern)) {
+    const lineStart = body.lastIndexOf('\n', match.index) + 1;
+    if (body.slice(lineStart, match.index).trim()) continue;
+
+    const dispatchOpen = body.indexOf('(', match.index);
+    const dispatchClose = findMatchingDelimiter(body, dispatchOpen, '(', ')');
+    if (dispatchOpen < 0 || dispatchClose < 0) continue;
+
+    let afterDispatch = dispatchClose + 1;
+    while (body[afterDispatch] === ' ' || body[afterDispatch] === '\t') afterDispatch++;
+    if (body[afterDispatch] !== ';') continue;
+    const lineEnd = body.indexOf('\n', afterDispatch);
+    const remainder = body.slice(afterDispatch + 1, lineEnd < 0 ? body.length : lineEnd);
+    if (remainder.trim()) continue;
+
+    let cursor = dispatchOpen + 1;
+    while (/\s/.test(body[cursor] ?? '')) cursor++;
+    if (!body.startsWith('new', cursor) || /[\w$]/.test(body[cursor + 3] ?? '')) continue;
+    cursor += 3;
+    while (/\s/.test(body[cursor] ?? '')) cursor++;
+    if (!body.startsWith('CustomEvent', cursor) || /[\w$]/.test(body[cursor + 11] ?? '')) continue;
+    cursor += 11;
+    while (/\s/.test(body[cursor] ?? '')) cursor++;
+
+    if (body[cursor] === '<') {
+      const genericClose = findMatchingDelimiter(body, cursor, '<', '>');
+      if (genericClose < 0) continue;
+      cursor = genericClose + 1;
+      while (/\s/.test(body[cursor] ?? '')) cursor++;
+    }
+
+    if (body[cursor] !== '(') continue;
+    cursor++;
+    while (/\s/.test(body[cursor] ?? '')) cursor++;
+    const eventName = /^(['"])([^'"]+)\1/.exec(body.slice(cursor));
+    if (!eventName) continue;
+
+    dispatches.push({ index: match.index, eventName: eventName[2] });
+  }
+
+  return dispatches;
+}
+
 function findElementDecoratorTag(source, index) {
   return /^@element\s*\(\s*['"]([^'"]+)['"]/.exec(source.slice(index, index + 500))?.[1] ?? null;
 }
 
+function findPageStringRoutes(source, decoratorIndex) {
+  const open = source.indexOf('(', decoratorIndex);
+  if (open < 0) return [];
+  const close = findMatchingDelimiter(source, open, '(', ')');
+  if (close < 0) return [];
+  const argumentsSource = source.slice(open + 1, close);
+  const routesProperty = /\broutes\s*:\s*\[/.exec(argumentsSource);
+  if (!routesProperty) return [];
+  const arrayOpen = open + 1 + routesProperty.index + routesProperty[0].lastIndexOf('[');
+  const arrayClose = findMatchingDelimiter(source, arrayOpen, '[', ']');
+  if (arrayClose < 0 || arrayClose > close) return [];
+
+  const body = source.slice(arrayOpen + 1, arrayClose);
+  const routes = [];
+  let searchFrom = 0;
+  for (const item of splitTopLevelArguments(body)) {
+    const relative = body.indexOf(item, searchFrom);
+    if (relative < 0) continue;
+    searchFrom = relative + item.length;
+    const literal = /^(['"])([^'"]+)\1$/.exec(item);
+    if (!literal) continue;
+    routes.push({ spec: literal[2], index: arrayOpen + 1 + relative });
+  }
+  return routes;
+}
+
 function inspectElementMembers(body) {
   const code = blankStringContents(maskComments(body));
   const depths = new Uint16Array(code.length + 1);
@@ -2096,11 +2512,13 @@ function inspectElementMembers(body) {
   const readonly = new Set();
   const functionFields = new Set();
   const reactive = new Set();
-  const fieldPattern = /(?:^|\n)\s*((?:(?:public|private|protected|static|readonly|override|declare|abstract)\s+)*)([A-Za-z_$][\w$]*)\s*[!?]?\s*(?::[^=\n;{]+)?\s*(?==|;)/g;
+  const memberIndices = new Map();
+  const fieldPattern = /(?:^|\n)\s*((?:(?:public|private|protected|static|readonly|override|declare|abstract)\s+)*)([A-Za-z_$][\w$]*)\s*[!?]?\s*(?::[^=\n;]+)?\s*(?==|;)/g;
   for (const match of code.matchAll(fieldPattern)) {
     const nameIndex = match.index + match[0].lastIndexOf(match[2]);
     if (depths[nameIndex] !== 0) continue;
     fields.add(match[2]);
+    if (!memberIndices.has(match[2])) memberIndices.set(match[2], nameIndex);
     if (/\breadonly\b/.test(match[1])) readonly.add(match[2]);
   }
   const functionFieldPattern = /(?:^|\n)\s*(?:(?:public|private|protected|static|readonly|override|declare|abstract)\s+)*([A-Za-z_$][\w$]*)\s*[!?]?\s*(?::[^=\n;{]+)?\s*=\s*(?:async\s*)?(?:\([^\n)]*\)|[A-Za-z_$][\w$]*)\s*=>/g;
@@ -2111,7 +2529,10 @@ function inspectElementMembers(body) {
   const accessorPattern = /(?:^|\n)\s*(?:(?:public|private|protected|static|readonly|override|declare|abstract)\s+)*(?:get|set|accessor)\s+([A-Za-z_$][\w$]*)\b/g;
   for (const match of code.matchAll(accessorPattern)) {
     const nameIndex = match.index + match[0].lastIndexOf(match[1]);
-    if (depths[nameIndex] === 0) accessors.add(match[1]);
+    if (depths[nameIndex] === 0) {
+      accessors.add(match[1]);
+      if (!memberIndices.has(match[1])) memberIndices.set(match[1], nameIndex);
+    }
   }
   const decoratedPattern = /@(property|state)\b/g;
   for (const match of code.matchAll(decoratedPattern)) {
@@ -2124,7 +2545,12 @@ function inspectElementMembers(body) {
       cursor = close + 1;
     }
     const declaration = /^\s*(?:(?:public|private|protected|static|readonly|override|declare|abstract)\s+)*(?:accessor\s+)?([A-Za-z_$][\w$]*)/.exec(code.slice(cursor));
-    if (declaration) reactive.add(declaration[1]);
+    if (declaration) {
+      reactive.add(declaration[1]);
+      if (!memberIndices.has(declaration[1])) {
+        memberIndices.set(declaration[1], cursor + declaration.index + declaration[0].lastIndexOf(declaration[1]));
+      }
+    }
   }
 
   // An undecorated native-style accessor can still be reactive when its
@@ -2153,7 +2579,7 @@ function inspectElementMembers(body) {
     if (close >= 0 && invalidates(body.slice(open + 1, close))) invalidatingAccessors.add(match[1]);
   }
 
-  return { fields, accessors, readonly, functionFields, reactive, invalidatingAccessors };
+  return { fields, accessors, readonly, functionFields, reactive, invalidatingAccessors, memberIndices };
 }
 
 function findDecoratedClassMethods(body, decoratorName, bodyStart = 0) {
@@ -2162,10 +2588,12 @@ function findDecoratedClassMethods(body, decoratorName, bodyStart = 0) {
   const pattern = new RegExp(`@${escapeRegExp(decoratorName)}\\b`, 'g');
   for (const match of code.matchAll(pattern)) {
     let cursor = match.index + match[0].length;
+    let decoratorArguments = '';
     while (/\s/.test(code[cursor] ?? '')) cursor++;
     if (code[cursor] === '(') {
       const close = findMatchingDelimiter(code, cursor, '(', ')');
       if (close < 0) continue;
+      decoratorArguments = body.slice(cursor + 1, close);
       cursor = close + 1;
     }
     const signature = /^\s*(?:(?:public|private|protected|static|override)\s+)*(?:async\s+)?([A-Za-z_$][\w$]*)\s*\(/.exec(code.slice(cursor));
@@ -2179,6 +2607,9 @@ function findDecoratedClassMethods(body, decoratorName, bodyStart = 0) {
     if (methodClose < 0) continue;
     methods.push({
       name: signature[1],
+      decoratorIndex: match.index,
+      decoratorArguments,
+      parameters: body.slice(parametersOpen + 1, parametersClose),
       bodyStart: bodyStart + methodOpen + 1,
       body: body.slice(methodOpen + 1, methodClose)
     });
@@ -2186,6 +2617,55 @@ function findDecoratedClassMethods(body, decoratorName, bodyStart = 0) {
   return methods;
 }
 
+function firstDecoratorStringArguments(argumentsSource) {
+  const first = /^\s*(['"])([^'"]+)\1/.exec(argumentsSource);
+  if (first) return [first[2]];
+  const array = /^\s*\[([^\]]*)\]/.exec(argumentsSource);
+  if (!array) return [];
+  return [...array[1].matchAll(/(['"])([^'"]+)\1/g)].map(match => match[2]);
+}
+
+function splitTopLevelArguments(source) {
+  const argumentsList = [];
+  let start = 0;
+  let quote = '';
+  let escaped = false;
+  let round = 0;
+  let square = 0;
+  let curly = 0;
+  for (let index = 0; index < source.length; index++) {
+    const character = source[index];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (character === '\\') escaped = true;
+      else if (character === quote) quote = '';
+      continue;
+    }
+    if (character === '"' || character === "'" || character === '`') {
+      quote = character;
+      continue;
+    }
+    if (character === '(') round++;
+    else if (character === ')') round = Math.max(0, round - 1);
+    else if (character === '[') square++;
+    else if (character === ']') square = Math.max(0, square - 1);
+    else if (character === '{') curly++;
+    else if (character === '}') curly = Math.max(0, curly - 1);
+    else if (character === ',' && round === 0 && square === 0 && curly === 0) {
+      argumentsList.push(source.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  argumentsList.push(source.slice(start).trim());
+  return argumentsList;
+}
+
+function hasHostOriginCheck(body, parameter) {
+  const target = `${escapeRegExp(parameter)}\\s*\\.\\s*target`;
+  const host = 'this\\s*\\.\\s*element';
+  return new RegExp(`(?:${target})\\s*[!=]==?\\s*(?:${host})|(?:${host})\\s*[!=]==?\\s*(?:${target})`).test(body);
+}
+
 function isDirectMemberWrite(body, index, length) {
   const before = body.slice(Math.max(0, index - 3), index);
   const after = body.slice(index + length).trimStart();
@@ -2218,6 +2698,23 @@ function findClassMethods(body, bodyStart = 0) {
   return methods;
 }
 
+function findNamedFunctionBodies(source) {
+  const code = blankStringContents(maskComments(source));
+  const functions = [];
+  const pattern = /\bfunction\s+([A-Za-z_$][\w$]*)\s*\([^)]*\)[^{]*\{|\b(?:const|let)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?\([^)]*\)\s*(?::[^=\n]+)?=>\s*\{/g;
+  for (const match of code.matchAll(pattern)) {
+    const open = match.index + match[0].lastIndexOf('{');
+    const close = findMatchingDelimiter(code, open, '{', '}');
+    if (close < 0) continue;
+    functions.push({
+      name: match[1] ?? match[2],
+      bodyStart: open + 1,
+      body: source.slice(open + 1, close)
+    });
+  }
+  return functions;
+}
+
 function pageLogicProfile(body) {
   const code = blankStringContents(body);
   const methods = findClassMethods(body);
@@ -3101,6 +3598,10 @@ function isFrameworkImplementation(filename) {
   return /(?:^|[/\\])packages[/\\]components[/\\]src(?:[/\\]|$)/.test(filename);
 }
 
+function isTestFilename(filename) {
+  return /(?:^|[/\\])[^/\\]+\.(?:test|spec)\.[cm]?[jt]sx?$/.test(filename);
+}
+
 function sourceLocation(source, index) {
   const prefix = source.slice(0, index);
   const line = prefix.split('\n').length;