snice 7.5.0 → 7.7.0

package/bin/project-analyzer.js

@@ -530,6 +530,38 @@ const RULE_DEFINITIONS = [
       }
     }
   },
+  {
+    id: 'snice/unguarded-context-load',
+    severity: 'warning',
+    category: 'lifecycle',
+    description: 'Warn when a controller starts repeatable load work from an unguarded @context handler.',
+    check(context) {
+      if (isFrameworkImplementation(context.filename) || isTestFilename(context.filename)) return;
+      for (const declaration of findDecoratedClasses(context.source, 'controller')) {
+        for (const method of findDecoratedClassMethods(declaration.body, 'context', declaration.bodyStart)) {
+          if (/\bonce\s*:\s*true\b/.test(method.decoratorArguments)) continue;
+
+          const body = blankStringContents(maskComments(method.body));
+          const load = /\b(?:void\s+|await\s+)?this\.((?:re)?load|refresh|fetch)(?:[A-Z_$][\w$]*)?\s*\(/.exec(body);
+          if (!load) continue;
+
+          const beforeLoad = body.slice(0, load.index);
+          const statementPrefix = beforeLoad.slice(Math.max(
+            beforeLoad.lastIndexOf(';'),
+            beforeLoad.lastIndexOf('\n')
+          ) + 1);
+          const hasGuard = /\b(?:if|switch|for|while)\s*\(|\breturn\b/.test(beforeLoad)
+            || /(?:&&|\|\||\?)/.test(statementPrefix);
+          if (hasGuard) continue;
+
+          context.report(method.bodyStart + load.index, {
+            message: `${declaration.name}.${method.name} starts ${load[1]} work from @context(), which fires on every context update while attached.`,
+            fix: 'Add an explicit first-delivery guard reset in detach(), pass @context({ once: true }) for a true one-shot, or diff the context update before loading. Review docs/ai/controllers.md.'
+          });
+        }
+      }
+    }
+  },
   {
     id: 'snice/imperative-controller-attach',
     severity: 'suggestion',
@@ -555,16 +587,8 @@ const RULE_DEFINITIONS = [
     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.`
-          });
-        }
+      for (const finding of findNativeIdlShadowFindings(context.source, context.provenance)) {
+        context.report(finding.index, finding);
       }
     }
   },
@@ -1512,6 +1536,14 @@ const RULE_DEFINITIONS = [
     projectOnly: true,
     check() {}
   },
+  {
+    id: 'snice/route-param-has-no-binding-target',
+    severity: 'warning',
+    category: 'router',
+    description: 'Warn when a page route parameter has no statically reachable binding target through the Router attribute channel.',
+    projectOnly: true,
+    check() {}
+  },
   {
     id: 'snice/shadowed-query-route',
     severity: 'warning',
@@ -1662,6 +1694,7 @@ export function analyzeProject(files) {
   const routerConstructions = [];
   const architectureDeclarations = [];
   const pageClasses = [];
+  const localClassDeclarations = [];
   const reactiveRenderContracts = new Map();
   const localElementContracts = new Map();
   const staleGuards = [];
@@ -1686,8 +1719,37 @@ export function analyzeProject(files) {
       staleGuards.push({ file, index: guard.index, field: guard[2], owner: owner?.kind });
     }
     const provenance = buildSourceProvenance(analyzable);
+    enrichSniceProvenance(provenance, file, normalized);
+    if (!isFrameworkImplementation(file.filename)) {
+      for (const finding of findNativeIdlShadowFindings(analyzable, provenance)) {
+        const location = sourceLocation(file.source, finding.index);
+        const duplicate = diagnostics.some(diagnostic =>
+          diagnostic.ruleId === 'snice/element-member-shadows-native-idl' &&
+          diagnostic.file === file.filename &&
+          diagnostic.line === location.line &&
+          diagnostic.column === location.column
+        );
+        if (!duplicate) {
+          diagnostics.push({
+            severity: 'warning',
+            ruleId: 'snice/element-member-shadows-native-idl',
+            message: finding.message,
+            fix: finding.fix,
+            file: file.filename,
+            line: location.line,
+            column: location.column
+          });
+        }
+      }
+    }
+    localClassDeclarations.push(...findClassBodies(analyzable).map(declaration => ({
+      ...declaration,
+      file,
+      provenance,
+      routeProperties: inspectRouteProperties(declaration.body, declaration.bodyStart, provenance)
+    })));
     routerConstructions.push(
-      ...findRouterConstructions(analyzable, localsFor(provenance.rootBindings, 'Router'))
+      ...findRouterConstructions(analyzable, provenRootBindingNames(provenance, 'Router'))
         .map(construction => ({ ...construction, file }))
     );
     for (const convention of [
@@ -1696,10 +1758,23 @@ export function analyzeProject(files) {
       { decorator: 'controller', folder: 'controllers', kind: 'controller' },
       { decorator: 'daemon', folder: 'daemons', kind: 'daemon' }
     ]) {
-      for (const declaration of findDecoratedClasses(analyzable, convention.decorator)) {
+      const bindingPageNames = convention.decorator === 'page'
+        ? routeDecoratorNames(provenance, file, normalized)
+        : [];
+      const decoratorNames = convention.decorator === 'page'
+        ? [...new Set(['page', ...bindingPageNames])]
+        : [convention.decorator];
+      const declarations = decoratorNames.flatMap(name =>
+        findDecoratedClasses(analyzable, name).map(declaration => ({ ...declaration, routeDecorator: name }))
+      );
+      for (const declaration of declarations.filter((item, index, all) =>
+        all.findIndex(candidate => candidate.bodyStart === item.bodyStart) === index
+      )) {
         const architectural = { ...declaration, ...convention, file };
         architectureDeclarations.push(architectural);
-        if (convention.decorator === 'page') pageClasses.push(architectural);
+        if (convention.decorator === 'page' && bindingPageNames.includes(declaration.routeDecorator)) {
+          pageClasses.push(architectural);
+        }
         if (convention.decorator === 'page' || convention.decorator === 'element') {
           reactiveRenderContracts.set(`${file.filename}:${declaration.bodyStart}`, {
             ...architectural,
@@ -1968,6 +2043,86 @@ export function analyzeProject(files) {
       });
     }
 
+    const bindingEnvironment = resolveRouteBindingEnvironment(page, localClassDeclarations, normalized);
+    const reportedRouteAttributes = new Set();
+    for (const route of findPageRoutes(page.file.source, page.index)) {
+      for (const parameter of findRouteParameters(route)) {
+        const routeAttribute = parameter.name.toLowerCase();
+        if (reportedRouteAttributes.has(routeAttribute)) continue;
+
+        const reachable = bindingEnvironment.properties.find(property =>
+          property.attributeKind !== 'false' &&
+          property.attributeKind !== 'unknown' &&
+          routePropertyAttribute(property, bindingEnvironment.naming) === routeAttribute
+        );
+        if (reachable) continue;
+
+        const sameName = bindingEnvironment.properties.find(property => property.name === parameter.name);
+        if (sameName?.attributeKind === 'unknown') continue;
+        if (sameName?.attributeKind === 'default' && bindingEnvironment.naming === 'unknown') continue;
+        if (bindingEnvironment.customAttributes.has(routeAttribute)) continue;
+
+        reportedRouteAttributes.add(routeAttribute);
+        const location = sourceLocation(page.file.source, parameter.index);
+        const routeLabel = `${parameter.marker}${parameter.name}`;
+        if (sameName?.attributeKind === 'false') {
+          const disabledBy = sameName.kind === 'state'
+            ? '@state() is internal state and disables the attribute channel used by Router'
+            : '@property({ attribute: false }) disables the attribute channel used by Router';
+          const enableFix = sameName.kind === 'state'
+            ? `Replace @state() with a plain @property() on ${sameName.name}`
+            : `Remove attribute: false so ${sameName.name} is a plain bindable @property()`;
+          diagnostics.push({
+            severity: 'warning',
+            ruleId: 'snice/route-param-has-no-binding-target',
+            message: `Route parameter "${routeLabel}" cannot bind ${page.name}.${sameName.name} because ${disabledBy}.`,
+            fix: `${enableFix}, or remove/rename "${routeLabel}" if the URL value is not a page input. Review docs/ai/routing.md.`,
+            file: page.file.filename,
+            line: location.line,
+            column: location.column
+          });
+          continue;
+        }
+
+        if (sameName) {
+          const observedAttribute = routePropertyAttribute(sameName, bindingEnvironment.naming);
+          const defaultAttribute = defaultRoutePropertyAttribute(sameName.name, bindingEnvironment.naming);
+          const removeAliasFix = sameName.attributeKind === 'alias' && defaultAttribute === routeAttribute
+            ? `remove the explicit attribute alias so @property() ${sameName.name} observes "${routeAttribute}"`
+            : `declare @property({ attribute: '${parameter.name}' }) ${sameName.name} so it observes "${routeAttribute}"`;
+          diagnostics.push({
+            severity: 'warning',
+            ruleId: 'snice/route-param-has-no-binding-target',
+            message: `Route parameter "${routeLabel}" sets the "${routeAttribute}" attribute, but ${page.name}.${sameName.name} observes "${observedAttribute}", so Router cannot reach it.`,
+            fix: `Change the route parameter spelling to "${parameter.marker}${observedAttribute}", or ${removeAliasFix}. Review docs/ai/routing.md.`,
+            file: page.file.filename,
+            line: location.line,
+            column: location.column
+          });
+          continue;
+        }
+
+        if (bindingEnvironment.nativeAttributes.has(routeAttribute)) continue;
+        if (!bindingEnvironment.complete) continue;
+
+        const suggestedName = kebabToCamel(parameter.name);
+        const propertySuggestion = /^[A-Za-z_$][\w$]*$/.test(suggestedName)
+          ? suggestedName === parameter.name
+            ? `Add @property() ${suggestedName} = ''; to ${page.name}`
+            : `Add @property({ attribute: '${parameter.name}' }) ${suggestedName} = ''; to ${page.name}`
+          : `Rename "${routeLabel}" to a valid property name and add a matching plain @property()`;
+        diagnostics.push({
+          severity: 'warning',
+          ruleId: 'snice/route-param-has-no-binding-target',
+          message: `Route parameter "${routeLabel}" has no bindable @property on ${page.name}; Router sets the "${routeAttribute}" attribute, which otherwise does not populate page state.`,
+          fix: `${propertySuggestion}, or remove the parameter if the page does not consume it. 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('?');
@@ -2238,7 +2393,8 @@ function usesComponent(source, recommendation) {
 
 export function findImports(source) {
   const imports = [];
-  for (const start of source.matchAll(/^\s*import\b/gm)) {
+  const code = maskNonExecutableCode(source);
+  for (const start of code.matchAll(/^\s*import\b/gm)) {
     const statement = source.slice(start.index, start.index + 4000);
     const sideEffect = statement.match(/^\s*import\s*(['"])([^'"]+)\1\s*;?/);
     if (sideEffect) {
@@ -2282,13 +2438,15 @@ function findObjectCalls(source, functionName) {
 
 function findClassBodies(source) {
   const classes = [];
-  const pattern = /\bclass\s+[A-Za-z_$][\w$]*\s+extends\s+([A-Za-z_$][\w$]*)[^{]*\{/g;
+  const pattern = /\bclass\s+([A-Za-z_$][\w$]*)\s+extends\s+([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?)[^{]*\{/g;
   for (const match of source.matchAll(pattern)) {
     const open = source.indexOf('{', match.index);
     const close = findMatchingDelimiter(source, open, '{', '}');
     if (close < 0) continue;
     classes.push({
-      base: match[1],
+      index: match.index,
+      name: match[1],
+      base: match[2],
       bodyStart: open + 1,
       body: source.slice(open + 1, close)
     });
@@ -2373,7 +2531,7 @@ function findDecoratedClasses(source, decoratorName) {
     // intervening decorators so each Snice role resolves to that class.
     while (true) {
       while (/\s/.test(source[declarationStart] ?? '')) declarationStart++;
-      const nextDecorator = /^@[A-Za-z_$][\w$]*/.exec(source.slice(declarationStart));
+      const nextDecorator = /^@[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)*/.exec(source.slice(declarationStart));
       if (!nextDecorator) break;
       declarationStart += nextDecorator[0].length;
       while (/\s/.test(source[declarationStart] ?? '')) declarationStart++;
@@ -2392,6 +2550,7 @@ function findDecoratedClasses(source, decoratorName) {
     declarations.push({
       index: match.index,
       name: declaration[1],
+      base: /\bextends\s+([A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*)?)/.exec(declaration[0])?.[1] ?? null,
       bodyStart: open + 1,
       body: source.slice(open + 1, close)
     });
@@ -2412,6 +2571,91 @@ function findSniceElementClasses(source) {
   return declarations;
 }
 
+function parameterDeclaresBinding(parameters, name) {
+  const escaped = escapeRegExp(name);
+  return splitTopLevelArguments(parameters).some(parameter => {
+    const value = parameter.trim().replace(/^\.\.\.\s*/, '');
+    if (new RegExp(`^${escaped}(?=\\s*[?:=,]|\\s*$)`).test(value)) return true;
+    if (!value.startsWith('{') && !value.startsWith('[')) return false;
+    return new RegExp(
+      `(?:^|[,\\[{:])\\s*${escaped}(?=\\s*[,}\\]=?:]|\\s*$)`
+    ).test(value);
+  });
+}
+
+function isImportedDecoratorBindingShadowed(source, bindingName, useIndex) {
+  const controls = new Set(['if', 'for', 'while', 'switch', 'with']);
+  for (let open = source.indexOf('('); open >= 0 && open < useIndex; open = source.indexOf('(', open + 1)) {
+    const close = findMatchingDelimiter(source, open, '(', ')');
+    if (close < 0 || close >= useIndex) continue;
+    let cursor = close + 1;
+    while (/\s/.test(source[cursor] ?? '')) cursor++;
+    if (source[cursor] === ':') {
+      cursor++;
+      while (cursor < source.length && source[cursor] !== '{' && !source.startsWith('=>', cursor)) cursor++;
+    }
+    while (/\s/.test(source[cursor] ?? '')) cursor++;
+    let bodyOpen = -1;
+    if (source.startsWith('=>', cursor)) {
+      cursor += 2;
+      while (/\s/.test(source[cursor] ?? '')) cursor++;
+      if (source[cursor] === '{') bodyOpen = cursor;
+    } else if (source[cursor] === '{') {
+      const prefix = source.slice(Math.max(0, open - 160), open);
+      const preceding = /([A-Za-z_$][\w$]*)\s*$/.exec(prefix)?.[1];
+      if (preceding && !controls.has(preceding)) bodyOpen = cursor;
+    }
+    if (bodyOpen < 0) continue;
+    const bodyClose = findMatchingDelimiter(source, bodyOpen, '{', '}');
+    if (bodyClose < useIndex) continue;
+    if (parameterDeclaresBinding(source.slice(open + 1, close), bindingName)) return true;
+  }
+
+  const escaped = escapeRegExp(bindingName);
+  for (const arrow of source.matchAll(new RegExp(`\\b${escaped}\\s*=>\\s*\\{`, 'g'))) {
+    const bodyOpen = source.indexOf('{', arrow.index);
+    const bodyClose = findMatchingDelimiter(source, bodyOpen, '{', '}');
+    if (bodyOpen < useIndex && useIndex < bodyClose) return true;
+  }
+  return false;
+}
+
+function findProvenSniceElementClasses(source, provenance) {
+  const code = maskNonExecutableCode(source, { preserveTemplateExpressions: true });
+  const decoratorNames = new Set(provenRootBindingNames(provenance, 'element'));
+  const declarations = [];
+  const seen = new Set();
+  for (const decoratorName of decoratorNames) {
+    const bindingName = decoratorName.split('.')[0];
+    for (const declaration of findDecoratedClasses(code, decoratorName)) {
+      if (
+        seen.has(declaration.bodyStart) ||
+        isImportedDecoratorBindingShadowed(code, bindingName, declaration.index)
+      ) continue;
+      seen.add(declaration.bodyStart);
+      declarations.push(declaration);
+    }
+  }
+  return declarations;
+}
+
+function findNativeIdlShadowFindings(source, provenance) {
+  const findings = [];
+  for (const declaration of findProvenSniceElementClasses(source, provenance)) {
+    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;
+      findings.push({
+        index: 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.`
+      });
+    }
+  }
+  return findings;
+}
+
 /**
  * Find standalone, static CustomEvent dispatches that @dispatch can express
  * without changing control flow. Calls whose return value is consumed, whose
@@ -2472,29 +2716,777 @@ function findElementDecoratorTag(source, index) {
 }
 
 function findPageStringRoutes(source, decoratorIndex) {
+  return findPageRoutes(source, decoratorIndex).filter(route => route.kind === 'string');
+}
+
+function findPageRoutes(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 options = unwrapStaticExpression(source, open + 1, close);
+  if (!options || source[options.start] !== '{') return [];
+  const routes = findStaticObjectProperty(source, options.start, options.end, 'routes');
+  if (!routes) return [];
+  const array = unwrapStaticExpression(source, routes.start, routes.end);
+  if (!array || source[array.start] !== '[') return [];
+  const arrayOpen = array.start;
   const arrayClose = findMatchingDelimiter(source, arrayOpen, '[', ']');
-  if (arrayClose < 0 || arrayClose > close) return [];
+  if (arrayClose < 0 || arrayClose > array.end) return [];
 
   const body = source.slice(arrayOpen + 1, arrayClose);
-  const routes = [];
+  const found = [];
   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 });
+    const itemBounds = unwrapStaticExpression(source, arrayOpen + 1 + relative, arrayOpen + 1 + relative + item.length);
+    if (!itemBounds) continue;
+    const literal = parseStaticString(source, itemBounds.start, itemBounds.end);
+    if (literal) {
+      found.push({
+        kind: 'string',
+        spec: literal.value,
+        index: arrayOpen + 1 + relative,
+        specStart: literal.start,
+        sourceIndices: literal.sourceIndices
+      });
+      continue;
+    }
+    if (source[itemBounds.start] !== '{') continue;
+    const path = findStaticObjectProperty(source, itemBounds.start, itemBounds.end, 'path');
+    if (!path) continue;
+    const pathBounds = unwrapStaticExpression(source, path.start, path.end);
+    if (!pathBounds) continue;
+    const objectPath = parseStaticString(source, pathBounds.start, pathBounds.end);
+    if (!objectPath) continue;
+    found.push({
+      kind: 'object',
+      spec: objectPath.value,
+      index: pathBounds.start,
+      specStart: objectPath.start,
+      sourceIndices: objectPath.sourceIndices
+    });
+  }
+  return found;
+}
+
+function findRouteParameters(route) {
+  const parameters = [];
+  for (const match of route.spec.matchAll(/(?:[:*])([\w-]+)/g)) {
+    parameters.push({ name: match[1], marker: match[0][0], index: route.sourceIndices?.[match.index] ?? route.specStart + match.index });
+  }
+  return parameters;
+}
+
+function unwrapStaticExpression(source, start, end) {
+  while (start < end && /\s/.test(source[start])) start++;
+  while (end > start && /\s/.test(source[end - 1])) end--;
+  while (source[start] === '(') {
+    const close = findMatchingDelimiter(source, start, '(', ')');
+    if (close < 0 || !/^\s*(?:as\s+const\s*)?$/.test(source.slice(close + 1, end))) break;
+    start++;
+    end = close;
+    while (start < end && /\s/.test(source[start])) start++;
+    while (end > start && /\s/.test(source[end - 1])) end--;
+  }
+  const suffix = /\s+as\s+const\s*$/.exec(source.slice(start, end));
+  if (suffix) end = start + suffix.index;
+  while (end > start && /\s/.test(source[end - 1])) end--;
+  return start < end ? { start, end } : null;
+}
+
+function findStaticObjectProperty(source, open, end, wanted) {
+  const close = findMatchingDelimiter(source, open, '{', '}');
+  if (close < 0 || close >= end) return null;
+  const body = source.slice(open + 1, close);
+  let offset = 0;
+  let result = null;
+  for (const item of splitTopLevelArguments(body)) {
+    const relative = body.indexOf(item, offset);
+    offset = relative + item.length;
+    const absolute = open + 1 + relative;
+    const trimmed = item.trimStart();
+    // A spread or computed/shorthand key can replace any earlier property.
+    // A later explicit key is certain again because JavaScript uses last-key
+    // semantics for object literals.
+    if (trimmed.startsWith('...') || trimmed.startsWith('[')) {
+      result = null;
+      continue;
+    }
+    // splitTopLevelArguments already isolates the property; find the first
+    // colon outside a quoted key.
+    const keyMatch = /^\s*(?:([A-Za-z_$][\w$]*)|(['"])(.*?)\2)\s*:/.exec(item);
+    if (!keyMatch) {
+      const staticMethodOrShorthand = new RegExp(
+        `^\\s*(?:(?:get|set|async)\\s+)?\\*?\\s*(?:${escapeRegExp(wanted)}|(['"])${escapeRegExp(wanted)}\\1)\\s*(?:\\(|,|$)`
+      );
+      if (staticMethodOrShorthand.test(item)) result = null;
+      continue;
+    }
+    const key = keyMatch[1] ?? keyMatch[3];
+    if (key !== wanted) continue;
+    result = { start: absolute + keyMatch[0].length, end: absolute + item.length };
+  }
+  return result;
+}
+
+function parseStaticString(source, start, end) {
+  const quote = source[start];
+  if (!['\'', '"', '`'].includes(quote)) return null;
+  let value = '';
+  const sourceIndices = [];
+  for (let index = start + 1; index < end; index++) {
+    const char = source[index];
+    if (char === quote) return /^\s*$/.test(source.slice(index + 1, end))
+      ? { value, start: start + 1, sourceIndices }
+      : null;
+    if (quote === '`' && char === '$' && source[index + 1] === '{') return null;
+    if (char !== '\\') { value += char; sourceIndices.push(index); continue; }
+    const escapeStart = index;
+    const next = source[++index];
+    if (next === '\n') continue;
+    if (next === '\r') {
+      if (source[index + 1] === '\n') index++;
+      continue;
+    }
+    let emitted;
+    if (next === 'x' && /^[0-9a-fA-F]{2}/.test(source.slice(index + 1, index + 3))) {
+      emitted = String.fromCharCode(parseInt(source.slice(index + 1, index + 3), 16)); index += 2;
+    } else if (next === 'u' && source[index + 1] === '{') {
+      const braceClose = source.indexOf('}', index + 2);
+      const digits = braceClose >= 0 ? source.slice(index + 2, braceClose) : '';
+      const codePoint = /^[0-9a-fA-F]{1,6}$/.test(digits) ? parseInt(digits, 16) : -1;
+      if (codePoint < 0 || codePoint > 0x10ffff) return null;
+      emitted = String.fromCodePoint(codePoint); index = braceClose;
+    } else if (next === 'u' && /^[0-9a-fA-F]{4}/.test(source.slice(index + 1, index + 5))) {
+      emitted = String.fromCharCode(parseInt(source.slice(index + 1, index + 5), 16)); index += 4;
+    } else emitted = ({ n: '\n', r: '\r', t: '\t', b: '\b', f: '\f', v: '\v', 0: '\0' }[next] ?? next);
+    value += emitted;
+    for (let unit = 0; unit < emitted.length; unit++) sourceIndices.push(escapeStart);
+  }
+  return null;
+}
+
+function inspectRouteProperties(body, bodyStart = 0, provenance = null) {
+  const masked = maskComments(body);
+  const code = blankStringContents(masked);
+  const depths = new Uint16Array(code.length + 1);
+  let depth = 0;
+  for (let index = 0; index < code.length; index++) {
+    depths[index] = depth;
+    if (code[index] === '{') depth++;
+    else if (code[index] === '}') depth = Math.max(0, depth - 1);
+  }
+
+  const properties = [];
+  const propertyNames = decoratorBindingNames(provenance, 'property');
+  if (!propertyNames.length) return properties;
+  const pattern = new RegExp(`@(?:${propertyNames.map(escapeRegExp).join('|')})\\b`, 'g');
+  for (const match of code.matchAll(pattern)) {
+    if (depths[match.index] !== 0) continue;
+    let cursor = match.index + match[0].length;
+    while (/\s/.test(code[cursor] ?? '')) cursor++;
+    let optionsSource = '';
+    let optionsOpen = -1;
+    let optionsClose = -1;
+    let hasArguments = false;
+    if (code[cursor] === '(') {
+      const close = findMatchingDelimiter(masked, cursor, '(', ')');
+      if (close < 0) continue;
+      hasArguments = true;
+      optionsSource = masked.slice(cursor + 1, close).trim();
+      optionsOpen = cursor + 1;
+      optionsClose = close;
+      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 || /\bstatic\b/.test(declaration[1])) continue;
+
+    let attributeKind = 'default';
+    let attribute = null;
+    if (hasArguments && optionsSource) {
+      if (!optionsSource.startsWith('{')) {
+        attributeKind = 'unknown';
+      } else {
+        const objectOpen = masked.indexOf('{', optionsOpen);
+        const attributeProperty = findStaticObjectProperty(masked, objectOpen, optionsClose, 'attribute');
+        const attributeBounds = attributeProperty
+          ? unwrapStaticExpression(masked, attributeProperty.start, attributeProperty.end)
+          : null;
+        const attributeOption = attributeBounds
+          ? masked.slice(attributeBounds.start, attributeBounds.end).trim()
+          : null;
+        if (!attributeProperty && /\.\.\./.test(optionsSource)) attributeKind = 'unknown';
+        else if (attributeOption === 'false') attributeKind = 'false';
+        else if (attributeOption === 'true') attributeKind = 'kebab';
+        else if (attributeOption) {
+          const alias = parseStaticString(masked, attributeBounds.start, attributeBounds.end);
+          if (alias) {
+            attributeKind = 'alias';
+            attribute = alias.value.toLowerCase();
+          } else {
+            attributeKind = 'unknown';
+          }
+        }
+      }
+    }
+    const nameOffset = cursor + declaration.index + declaration[0].lastIndexOf(declaration[2]);
+    properties.push({
+      name: declaration[2],
+      index: bodyStart + nameOffset,
+      attributeKind,
+      attribute
+    });
+  }
+  return properties;
+}
+
+function decoratorBindingNames(provenance, imported) {
+  const known = provenRootBindingNames(provenance, imported);
+  if (known.length) return known;
+  const importedLocals = new Set((provenance?.imports ?? []).flatMap(entry =>
+    parseNamedImportEntries(entry.clause).map(binding => binding.local)
+  ));
+  const locallyDeclared = new RegExp(`\\b(?:const|let|var|function|class)\\s+${escapeRegExp(imported)}\\b`)
+    .test(provenance?.source ?? '');
+  return importedLocals.has(imported) || locallyDeclared ? [] : [imported];
+}
+
+function provenRootBindingNames(provenance, imported) {
+  return [
+    ...localsFor(provenance?.rootBindings ?? new Map(), imported),
+    ...[...(provenance?.namespaceBindings ?? new Map())]
+      .filter(([, path]) => path === 'snice')
+      .map(([local]) => `${local}.${imported}`),
+    ...[...(provenance?.projectRootNamespaces ?? new Map())]
+      .filter(([, exports]) => exports.has(imported))
+      .map(([local]) => `${local}.${imported}`)
+  ];
+}
+
+function enrichSniceProvenance(provenance, file, projectFiles) {
+  const projectRootNamespaces = new Map();
+  for (const entry of provenance.imports) {
+    if (entry.typeOnly) continue;
+    if (!entry.path.startsWith('.')) continue;
+    const target = resolveProjectSource(file.filename, entry.path, projectFiles);
+    if (!target) continue;
+    const namespace = /^\*\s+as\s+([A-Za-z_$][\w$]*)$/.exec(entry.clause ?? '');
+    if (namespace) {
+      const exports = new Set(['element', 'property', 'state', 'SniceElement', 'Router'].filter(name =>
+        resolvesSniceRootExport(target, name, projectFiles)
+      ));
+      if (exports.size) projectRootNamespaces.set(namespace[1], exports);
+      for (const exported of sniceRootExportNames(target, 'element', projectFiles)) {
+        const list = provenance.rootBindings.get('element') ?? [];
+        list.push({
+          imported: 'element',
+          local: `${namespace[1]}.${exported}`,
+          index: entry.index,
+          path: entry.path
+        });
+        provenance.rootBindings.set('element', list);
+      }
+      continue;
+    }
+    for (const binding of parseNamedImportEntries(entry.clause)) {
+      if (binding.typeOnly) continue;
+      for (const imported of ['element', 'property', 'state', 'SniceElement', 'Router']) {
+        if (!resolvesSniceRootExport(target, binding.imported, projectFiles, imported)) continue;
+        const list = provenance.rootBindings.get(imported) ?? [];
+        list.push({ imported, local: binding.local, index: entry.index, path: entry.path });
+        provenance.rootBindings.set(imported, list);
+      }
+    }
+  }
+  provenance.projectRootNamespaces = projectRootNamespaces;
+}
+
+function readStaticQuotedString(source, quoteIndex) {
+  const quote = source[quoteIndex];
+  if (quote !== "'" && quote !== '"') return null;
+  let escaped = false;
+  for (let index = quoteIndex + 1; index < source.length; index++) {
+    const character = source[index];
+    if (character === '\n' || character === '\r') return null;
+    if (escaped) escaped = false;
+    else if (character === '\\') escaped = true;
+    else if (character === quote) return parseStaticString(source, quoteIndex, index + 1);
+  }
+  return null;
+}
+
+function findNamedExportStatements(source) {
+  const code = maskNonExecutableCode(source);
+  const statements = [];
+  for (const match of code.matchAll(/\bexport\s*\{([^}]*)\}/g)) {
+    const after = match.index + match[0].length;
+    const from = /^\s*from\s*(['"])/.exec(code.slice(after));
+    let path = null;
+    if (from) {
+      const quoteIndex = after + from[0].lastIndexOf(from[1]);
+      const literal = readStaticQuotedString(source, quoteIndex);
+      if (!literal) continue;
+      path = literal.value;
+    }
+    statements.push({ bindings: match[1], path, index: match.index });
+  }
+  return statements;
+}
+
+function findExportStarStatements(source) {
+  const code = maskNonExecutableCode(source);
+  const statements = [];
+  for (const match of code.matchAll(/\bexport\s*\*\s*from\s*(['"])/g)) {
+    const quoteIndex = match.index + match[0].lastIndexOf(match[1]);
+    const literal = readStaticQuotedString(source, quoteIndex);
+    if (literal) statements.push({ path: literal.value, index: match.index });
+  }
+  return statements;
+}
+
+function resolvesSniceRootExport(file, exportedName, projectFiles, wanted = exportedName, visited = new Set()) {
+  const key = `${normalizeModuleFilename(file.filename)}:${exportedName}:${wanted}`;
+  if (visited.has(key)) return false;
+  visited.add(key);
+  if (findExportStarStatements(file.source).some(statement => statement.path === 'snice') && exportedName === wanted) return true;
+  const provenance = buildSourceProvenance(file.source);
+  const localNames = new Set(localsFor(provenance.rootBindings, wanted));
+  for (const statement of findNamedExportStatements(file.source)) {
+    for (const binding of parseNamedImportEntries(`{${statement.bindings}}`)) {
+      if (binding.typeOnly) continue;
+      if (binding.local !== exportedName) continue;
+      if (statement.path === 'snice') return binding.imported === wanted;
+      if (!statement.path && localNames.has(binding.imported)) return true;
+      if (statement.path?.startsWith('.')) {
+        const target = resolveProjectSource(file.filename, statement.path, projectFiles);
+        if (target && resolvesSniceRootExport(target, binding.imported, projectFiles, wanted, visited)) return true;
+      }
+    }
+  }
+  return false;
+}
+
+function sniceRootExportNames(file, wanted, projectFiles, visited = new Set()) {
+  const filename = normalizeModuleFilename(file.filename);
+  if (visited.has(filename)) return new Set();
+  visited.add(filename);
+  const exported = new Set();
+  const provenance = buildSourceProvenance(file.source);
+  const directLocals = new Set(localsFor(provenance.rootBindings, wanted));
+  if (findExportStarStatements(file.source).some(statement => statement.path === 'snice')) {
+    exported.add(wanted);
+  }
+  for (const statement of findNamedExportStatements(file.source)) {
+    for (const binding of parseNamedImportEntries(`{${statement.bindings}}`)) {
+      if (binding.typeOnly) continue;
+      if (statement.path === 'snice' && binding.imported === wanted) {
+        exported.add(binding.local);
+        continue;
+      }
+      if (!statement.path) {
+        if (directLocals.has(binding.imported)) {
+          exported.add(binding.local);
+          continue;
+        }
+        for (const entry of provenance.imports) {
+          if (entry.typeOnly || !entry.path.startsWith('.')) continue;
+          const imported = parseNamedImportEntries(entry.clause)
+            .find(candidate => !candidate.typeOnly && candidate.local === binding.imported);
+          if (!imported) continue;
+          const target = resolveProjectSource(file.filename, entry.path, projectFiles);
+          if (!target) continue;
+          const targetExports = sniceRootExportNames(target, wanted, projectFiles, new Set(visited));
+          if (targetExports.has(imported.imported)) exported.add(binding.local);
+        }
+        continue;
+      }
+      if (statement.path?.startsWith('.')) {
+        const target = resolveProjectSource(file.filename, statement.path, projectFiles);
+        if (!target) continue;
+        const targetExports = sniceRootExportNames(target, wanted, projectFiles, new Set(visited));
+        if (targetExports.has(binding.imported)) exported.add(binding.local);
+      }
+    }
+  }
+  for (const statement of findExportStarStatements(file.source)) {
+    if (!statement.path.startsWith('.')) continue;
+    const target = resolveProjectSource(file.filename, statement.path, projectFiles);
+    if (!target) continue;
+    for (const name of sniceRootExportNames(target, wanted, projectFiles, new Set(visited))) {
+      exported.add(name);
+    }
+  }
+  return exported;
+}
+
+function routeDecoratorNames(provenance, file, projectFiles) {
+  const names = [];
+  let barePageImported = false;
+  for (const entry of provenance.imports) {
+    for (const binding of parseNamedImportEntries(entry.clause)) {
+      if (binding.local === 'page') barePageImported = true;
+      if (!entry.path.startsWith('.')) continue;
+      const target = resolveProjectSource(file.filename, entry.path, projectFiles);
+      if (target && routerPageExportNames(target, projectFiles).has(binding.imported)) names.push(binding.local);
+    }
+    const namespace = /^\*\s+as\s+([A-Za-z_$][\w$]*)$/.exec(entry.clause ?? '');
+    if (namespace && entry.path.startsWith('.')) {
+      const target = resolveProjectSource(file.filename, entry.path, projectFiles);
+      if (target) {
+        for (const exported of routerPageExportNames(target, projectFiles)) names.push(`${namespace[1]}.${exported}`);
+      }
+    }
+  }
+  for (const routerName of provenRootBindingNames(provenance, 'Router')) {
+    const escaped = escapeRegExp(routerName);
+    for (const match of provenance.source.matchAll(new RegExp(`(?:const|let|var)\\s+([A-Za-z_$][\\w$]*)\\s*=\\s*${escaped}\\s*\\(`, 'g'))) {
+      names.push(`${match[1]}.page`);
+    }
+    for (const match of provenance.source.matchAll(new RegExp(`(?:const|let|var)\\s*\\{([^}]*)\\}\\s*=\\s*${escaped}\\s*\\(`, 'g'))) {
+      const page = /(?:^|,)\s*page(?:\s*:\s*([A-Za-z_$][\w$]*))?(?=\s*,|\s*$)/.exec(match[1]);
+      if (page) names.push(page[1] ?? 'page');
+    }
+  }
+  const localPageDeclaration = /\b(?:const|let|var|function|class)\s+page\b/.test(provenance.source ?? '');
+  if (!barePageImported && !localPageDeclaration) names.push('page');
+  return [...new Set(names)];
+}
+
+function resolveProjectSource(from, specifier, files) {
+  const base = normalizeModuleFilename(`${from.replaceAll('\\', '/').replace(/\/[^/]*$/, '')}/${specifier}`);
+  const candidates = new Set([base, ...['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts'].map(ext => base + ext),
+    ...['.ts', '.tsx', '.js', '.jsx'].map(ext => `${base}/index${ext}`)]);
+  return files.find(candidate => candidates.has(normalizeModuleFilename(candidate.filename))) ?? null;
+}
+
+function routerPageExportNames(file, projectFiles, visited = new Set()) {
+  const filename = normalizeModuleFilename(file.filename);
+  if (visited.has(filename)) return new Set();
+  visited.add(filename);
+  const source = maskNonExecutableCode(file.source);
+  const provenance = buildSourceProvenance(file.source);
+  enrichSniceProvenance(provenance, file, projectFiles);
+  const locals = new Set();
+  for (const routerName of provenRootBindingNames(provenance, 'Router')) {
+    const direct = new RegExp(`(?:export\\s+)?(?:const|let|var)\\s*\\{([^}]*)\\}\\s*=\\s*${escapeRegExp(routerName)}\\s*\\(`, 'g');
+    for (const match of source.matchAll(direct)) {
+      const page = /(?:^|,)\s*page(?:\s*:\s*([A-Za-z_$][\w$]*))?(?=\s*,|\s*$)/.exec(match[1]);
+      if (page) locals.add(page[1] ?? 'page');
+    }
+    const instance = new RegExp(`(?:const|let|var)\\s+([A-Za-z_$][\\w$]*)\\s*=\\s*${escapeRegExp(routerName)}\\s*\\(`, 'g');
+    for (const match of source.matchAll(instance)) {
+      const destructure = new RegExp(`(?:export\\s+)?(?:const|let|var)\\s*\\{([^}]*)\\}\\s*=\\s*${escapeRegExp(match[1])}\\b`, 'g');
+      for (const binding of source.matchAll(destructure)) {
+        const page = /(?:^|,)\s*page(?:\s*:\s*([A-Za-z_$][\w$]*))?(?=\s*,|\s*$)/.exec(binding[1]);
+        if (page) locals.add(page[1] ?? 'page');
+      }
+    }
+  }
+  const exported = new Set();
+  for (const local of locals) {
+    if (new RegExp(`export\\s+(?:const|let|var)\\s*\\{[^}]*\\b${escapeRegExp(local)}\\b`).test(source)) exported.add(local);
+    for (const statement of source.matchAll(/export\s*\{([^}]*)\}/g)) {
+      const after = source.slice(statement.index + statement[0].length);
+      if (/^\s*from\b/.test(after)) continue;
+      for (const binding of parseNamedImportEntries(`{${statement[1]}}`)) {
+        if (binding.imported === local) exported.add(binding.local);
+      }
+    }
+  }
+  for (const statement of findNamedExportStatements(file.source)) {
+    if (!statement.path?.startsWith('.')) continue;
+    const target = resolveProjectSource(file.filename, statement.path, projectFiles);
+    if (!target) continue;
+    const targetExports = routerPageExportNames(target, projectFiles, visited);
+    for (const binding of parseNamedImportEntries(`{${statement.bindings}}`)) {
+      if (targetExports.has(binding.imported)) exported.add(binding.local);
+    }
+  }
+  return exported;
+}
+
+function inspectRouteStateNames(body, provenance) {
+  const code = blankStringContents(maskComments(body));
+  const names = new Set();
+  let depth = 0;
+  const depths = new Uint16Array(code.length + 1);
+  for (let index = 0; index < code.length; index++) {
+    depths[index] = depth;
+    if (code[index] === '{') depth++;
+    else if (code[index] === '}') depth = Math.max(0, depth - 1);
+  }
+  const stateNames = decoratorBindingNames(provenance, 'state');
+  if (!stateNames.length) return names;
+  const pattern = new RegExp(`@(?:${stateNames.map(escapeRegExp).join('|')})\\b`, 'g');
+  for (const match of code.matchAll(pattern)) {
+    if (depths[match.index] !== 0) continue;
+    let cursor = match.index + match[0].length;
+    while (/\s/.test(code[cursor] ?? '')) cursor++;
+    if (code[cursor] === '(') {
+      const close = findMatchingDelimiter(code, cursor, '(', ')');
+      if (close < 0) continue;
+      cursor = close + 1;
+    }
+    const declaration = /^\s*(?:(?:public|private|protected|readonly|override|declare|abstract)\s+)*(?:accessor\s+)?([A-Za-z_$][\w$]*)/.exec(code.slice(cursor));
+    if (declaration) names.add(declaration[1]);
+  }
+  return names;
+}
+
+function resolveRouteBindingEnvironment(page, localClasses, projectFiles) {
+  const propertiesByName = new Map();
+  const shadowedNames = new Set();
+  const visited = new Set();
+  let current = localClasses.find(candidate =>
+    candidate.file.filename === page.file.filename && candidate.bodyStart === page.bodyStart
+  ) ?? {
+    name: page.name,
+    base: page.base,
+    body: page.body,
+    bodyStart: page.bodyStart,
+    file: page.file,
+    provenance: buildSourceProvenance(maskComments(page.file.source)),
+    routeProperties: inspectRouteProperties(page.body, page.bodyStart, buildSourceProvenance(maskComments(page.file.source)))
+  };
+  let naming = 'unknown';
+  let complete = true;
+  let customObserved = null;
+  let observedAttributesDeclared = false;
+  let hasAttributeCallback = false;
+  let observedAttributesUnknown = false;
+
+  while (current && !visited.has(`${current.file.filename}:${current.bodyStart}`)) {
+    visited.add(`${current.file.filename}:${current.bodyStart}`);
+    if (hasUnresolvedRelativeRouteDecorator(current.body, current.provenance)) complete = false;
+    const stateNames = inspectRouteStateNames(current.body, current.provenance);
+    for (const name of stateNames) {
+      if (!shadowedNames.has(name)) {
+        propertiesByName.set(name, { name, attributeKind: 'false', attribute: null, kind: 'state' });
+      }
+      shadowedNames.add(name);
+    }
+    for (const property of current.routeProperties) {
+      if (!shadowedNames.has(property.name)) propertiesByName.set(property.name, property);
+      shadowedNames.add(property.name);
+    }
+    if (!observedAttributesDeclared) {
+      const observed = inspectObservedAttributes(current.body);
+      if (observed !== undefined) {
+        observedAttributesDeclared = true;
+        if (observed === null) observedAttributesUnknown = true;
+        else customObserved = observed;
+      }
+    }
+    if (hasOwnAttributeChangedCallback(current.body)) hasAttributeCallback = true;
+
+    const sniceElementNames = new Set(provenRootBindingNames(current.provenance, 'SniceElement'));
+    if (current.base === 'HTMLElement') {
+      naming = 'lowercase';
+      break;
+    }
+    if (sniceElementNames.has(current.base)) {
+      naming = 'kebab';
+      break;
+    }
+    if (!current.base) {
+      complete = false;
+      break;
+    }
+
+    const sameFile = localClasses.filter(candidate =>
+      candidate.file.filename === current.file.filename && candidate.name === current.base
+    );
+    let candidates = sameFile;
+    if (!candidates.length) {
+      const imported = current.provenance.imports.flatMap(entry =>
+        parseNamedImportEntries(entry.clause)
+          .filter(binding => binding.local === current.base && entry.path.startsWith('.'))
+          .map(binding => ({ entry, binding }))
+      );
+      candidates = imported.flatMap(({ entry, binding }) =>
+        resolveImportedRouteClass(current.file.filename, entry.path, binding.imported, localClasses, projectFiles)
+      );
+      const namespaceBase = /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/.exec(current.base);
+      if (namespaceBase) {
+        const path = current.provenance.namespaceBindings.get(namespaceBase[1]);
+        if (path?.startsWith('.')) {
+          candidates.push(...resolveImportedRouteClass(current.file.filename, path, namespaceBase[2], localClasses, projectFiles));
+        }
+      }
+    }
+    if (candidates.length !== 1) {
+      complete = false;
+      break;
+    }
+    current = candidates[0];
+  }
+
+  const nativeAttributes = new Set([...NATIVE_ELEMENT_IDL_MEMBERS].map(name => name.toLowerCase()));
+  const customAttributes = hasAttributeCallback && Array.isArray(customObserved)
+    ? new Set(customObserved.map(name => name.toLowerCase()))
+    : new Set();
+  return {
+    properties: [...propertiesByName.values()], naming,
+    complete: complete && !(hasAttributeCallback && observedAttributesUnknown),
+    nativeAttributes,
+    customAttributes
+  };
+}
+
+function hasUnresolvedRelativeRouteDecorator(body, provenance) {
+  const proven = new Set([
+    ...provenRootBindingNames(provenance, 'property'),
+    ...provenRootBindingNames(provenance, 'state')
+  ]);
+  const code = blankStringContents(maskComments(body));
+  for (const entry of provenance.imports) {
+    if (!entry.path.startsWith('.')) continue;
+    const namespace = /^\*\s+as\s+([A-Za-z_$][\w$]*)$/.exec(entry.clause ?? '');
+    if (namespace) {
+      for (const member of ['property', 'state']) {
+        const name = `${namespace[1]}.${member}`;
+        if (!proven.has(name) && new RegExp(`@${escapeRegExp(name)}\\b`).test(code)) return true;
+      }
+      continue;
+    }
+    for (const binding of parseNamedImportEntries(entry.clause)) {
+      if (!proven.has(binding.local) && new RegExp(`@${escapeRegExp(binding.local)}\\b`).test(code)) return true;
+    }
+  }
+  return false;
+}
+
+function normalizeModuleFilename(filename) {
+  const parts = filename.replaceAll('\\', '/').split('/');
+  const normalized = [];
+  for (const part of parts) {
+    if (part === '..') normalized.pop();
+    else if (part !== '.') normalized.push(part);
   }
-  return routes;
+  return normalized.join('/');
+}
+
+function resolveLocalModule(from, specifier, localClasses) {
+  const base = normalizeModuleFilename(`${from.replaceAll('\\', '/').replace(/\/[^/]*$/, '')}/${specifier}`);
+  const candidates = new Set([base, ...['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts'].map(ext => base + ext),
+    ...['.ts', '.tsx', '.js', '.jsx'].map(ext => `${base}/index${ext}`)]);
+  return new Set([...candidates].filter(candidate => localClasses.some(item => normalizeModuleFilename(item.file.filename) === candidate)));
+}
+
+function resolveImportedRouteClass(from, specifier, exportedName, localClasses, projectFiles, visited = new Set()) {
+  const target = resolveProjectSource(from, specifier, projectFiles);
+  const key = `${from}:${specifier}:${exportedName}`;
+  if (visited.has(key) || !target) return [];
+  visited.add(key);
+  const results = [];
+  for (const filename of [normalizeModuleFilename(target.filename)]) {
+    const direct = localClasses.filter(candidate =>
+      normalizeModuleFilename(candidate.file.filename) === filename && candidate.name === exportedName
+    );
+    results.push(...direct);
+    const file = target;
+    for (const statement of findNamedExportStatements(file.source)) {
+      for (const binding of parseNamedImportEntries(`{${statement.bindings}}`)) {
+        if (binding.local !== exportedName) continue;
+        if (statement.path?.startsWith('.')) {
+          results.push(...resolveImportedRouteClass(file.filename, statement.path, binding.imported, localClasses, projectFiles, visited));
+        } else {
+          results.push(...localClasses.filter(candidate =>
+            normalizeModuleFilename(candidate.file.filename) === filename && candidate.name === binding.imported
+          ));
+        }
+      }
+    }
+  }
+  return results.filter((candidate, index, all) =>
+    all.findIndex(item => item.file.filename === candidate.file.filename && item.bodyStart === candidate.bodyStart) === index
+  );
+}
+
+function inspectObservedAttributes(body) {
+  const source = maskComments(body);
+  const code = blankStringContents(source);
+  const depths = lexicalBraceDepths(code);
+  const getterPattern = /(?:^|[;\n])\s*(?:(?:public|protected|private)\s+)?static\s+get\s+observedAttributes\s*\(\s*\)\s*\{/g;
+  const fieldPattern = /(?:^|[;\n])\s*(?:(?:public|protected|private)\s+)?static\s+(?:readonly\s+)?observedAttributes\s*=/g;
+  const getters = [...code.matchAll(getterPattern)].filter(match => depths[match.index] === 0);
+  const fields = [...code.matchAll(fieldPattern)].filter(match => depths[match.index] === 0);
+  if (getters.length + fields.length > 1) return null;
+  for (const declaration of getters) {
+    const open = code.indexOf('{', declaration.index);
+    const close = findMatchingDelimiter(source, open, '{', '}');
+    if (close < 0) return null;
+    const getterBody = source.slice(open + 1, close);
+    const returnStatement = /^\s*return\s+([\s\S]*?);?\s*$/.exec(blankStringContents(getterBody));
+    if (!returnStatement) return null;
+    const returnIndex = getterBody.search(/\breturn\b/) + 'return'.length;
+    let expressionEnd = close;
+    while (/\s/.test(source[expressionEnd - 1] ?? '')) expressionEnd--;
+    if (source[expressionEnd - 1] === ';') expressionEnd--;
+    const expression = unwrapStaticExpression(source, open + 1 + returnIndex, expressionEnd);
+    return expression ? parseStaticStringArray(source, expression.start, expression.end) : null;
+  }
+  for (const declaration of fields) {
+    const equals = code.indexOf('=', declaration.index);
+    let end = code.indexOf(';', equals + 1);
+    if (end < 0) end = code.indexOf('\n', equals + 1);
+    if (end < 0) end = code.length;
+    const expression = unwrapStaticExpression(source, equals + 1, end);
+    return expression ? parseStaticStringArray(source, expression.start, expression.end) : null;
+  }
+  return undefined;
+}
+
+function parseStaticStringArray(source, start, end) {
+  if (source[start] !== '[') return null;
+  const arrayClose = findMatchingDelimiter(source, start, '[', ']');
+  if (arrayClose < 0 || !/^\s*$/.test(source.slice(arrayClose + 1, end))) return null;
+  const values = [];
+  const body = source.slice(start + 1, arrayClose);
+  let offset = 0;
+  for (const item of splitTopLevelArguments(body)) {
+    const relative = body.indexOf(item, offset);
+    offset = relative + item.length;
+    const itemStart = start + 1 + relative;
+    const literal = parseStaticString(source, itemStart, itemStart + item.length);
+    if (!literal) return null;
+    values.push(literal.value);
+  }
+  return values;
+}
+
+function lexicalBraceDepths(code) {
+  const depths = new Uint16Array(code.length + 1);
+  let depth = 0;
+  for (let index = 0; index < code.length; index++) {
+    depths[index] = depth;
+    if (code[index] === '{') depth++;
+    else if (code[index] === '}') depth = Math.max(0, depth - 1);
+  }
+  return depths;
+}
+
+function hasOwnAttributeChangedCallback(body) {
+  const code = blankStringContents(maskComments(body));
+  const depths = lexicalBraceDepths(code);
+  for (const match of code.matchAll(/(?:^|[;\n])\s*(?:(?:public|protected|private|override)\s+)*(?:async\s+)?attributeChangedCallback\s*\(/g)) {
+    if (depths[match.index] === 0) return true;
+  }
+  return false;
+}
+
+function routePropertyAttribute(property, naming) {
+  if (property.attributeKind === 'alias') return property.attribute;
+  if (property.attributeKind === 'kebab') return camelToKebab(property.name).toLowerCase();
+  return defaultRoutePropertyAttribute(property.name, naming);
+}
+
+function defaultRoutePropertyAttribute(name, naming) {
+  return naming === 'kebab' ? camelToKebab(name).toLowerCase() : name.toLowerCase();
 }
 
 function inspectElementMembers(body) {
@@ -2911,6 +3903,223 @@ function blankStringContents(source) {
   return output;
 }
 
+/**
+ * Preserve executable tokens and source positions while blanking comments and
+ * literal contents. Provenance scans use this shared view so code examples in
+ * documentation strings cannot manufacture imports, exports, or Router calls.
+ */
+function maskNonExecutableCode(source, { preserveTemplateExpressions = false } = {}) {
+  const output = source.split('');
+  const blank = (start, end) => {
+    for (let index = start; index < end; index++) {
+      if (source[index] !== '\n' && source[index] !== '\r') output[index] = ' ';
+    }
+  };
+  const quotedEnd = (start, quote) => {
+    for (let index = start + 1; index < source.length; index++) {
+      if (source[index] === '\\') { index++; continue; }
+      if (source[index] === quote) return index;
+      if (quote !== '`' && (source[index] === '\n' || source[index] === '\r')) return source.length;
+    }
+    return source.length;
+  };
+  const controlBodies = new Set(['if', 'while', 'for', 'with']);
+  const expressionKeywords = new Set([
+    'await', 'case', 'delete', 'do', 'else', 'in', 'instanceof', 'new',
+    'of', 'return', 'throw', 'typeof', 'void', 'yield'
+  ]);
+  const controlParens = new Set(['if', 'while', 'for', 'with', 'switch', 'catch']);
+
+  const scanTemplate = start => {
+    let rawStart = start + 1;
+    for (let index = start + 1; index < source.length; index++) {
+      if (source[index] === '\\') { index++; continue; }
+      if (source[index] === '`') {
+        if (preserveTemplateExpressions) blank(rawStart, index);
+        return index;
+      }
+      if (source[index] !== '$' || source[index + 1] !== '{') continue;
+      if (preserveTemplateExpressions) blank(rawStart, index);
+      index = scanCode(index + 2, true) - 1;
+      rawStart = index + 1;
+    }
+    if (preserveTemplateExpressions) blank(rawStart, source.length);
+    return source.length;
+  };
+
+  const scanCode = (start, templateExpression = false) => {
+    let expectExpression = true;
+    let expectStatement = !templateExpression;
+    let pendingControl = null;
+    let templateBraceDepth = templateExpression ? 1 : 0;
+    const parens = [];
+    const braces = [];
+
+    for (let index = start; index < source.length;) {
+      const character = source[index];
+      if (/\s/.test(character)) { index++; continue; }
+
+      if (character === '/' && source[index + 1] === '/') {
+        const newline = source.indexOf('\n', index + 2);
+        const end = newline < 0 ? source.length : newline;
+        blank(index, end);
+        index = end;
+        continue;
+      }
+      if (character === '/' && source[index + 1] === '*') {
+        const close = source.indexOf('*/', index + 2);
+        const end = close < 0 ? source.length : close + 2;
+        blank(index, end);
+        index = end;
+        continue;
+      }
+      if (character === "'" || character === '"') {
+        const end = quotedEnd(index, character);
+        blank(index + 1, end);
+        index = end < source.length ? end + 1 : end;
+        expectExpression = false;
+        expectStatement = false;
+        pendingControl = null;
+        continue;
+      }
+      if (character === '`') {
+        const end = scanTemplate(index);
+        if (!preserveTemplateExpressions) blank(index + 1, end);
+        index = end < source.length ? end + 1 : end;
+        expectExpression = false;
+        expectStatement = false;
+        pendingControl = null;
+        continue;
+      }
+      if (character === '/') {
+        if (source[index + 1] === '=') {
+          index += 2;
+          expectExpression = true;
+          expectStatement = false;
+          pendingControl = null;
+          continue;
+        }
+        if (expectExpression) {
+          const end = regexLiteralEnd(source, index);
+          if (end > index) {
+            blank(index, end);
+            index = end;
+            expectExpression = false;
+            expectStatement = false;
+            pendingControl = null;
+            continue;
+          }
+        }
+        index++;
+        expectExpression = true;
+        expectStatement = false;
+        pendingControl = null;
+        continue;
+      }
+      if (/[A-Za-z_$]/.test(character)) {
+        let end = index + 1;
+        while (/[\w$]/.test(source[end] ?? '')) end++;
+        const word = source.slice(index, end);
+        if (word === 'await' && pendingControl === 'for') {
+          expectExpression = true;
+          expectStatement = false;
+        } else if (controlParens.has(word)) {
+          pendingControl = word;
+          expectExpression = true;
+          expectStatement = false;
+        } else {
+          pendingControl = null;
+          expectExpression = expressionKeywords.has(word);
+          expectStatement = word === 'do' || word === 'else';
+        }
+        index = end;
+        continue;
+      }
+      if (/\d/.test(character)) {
+        index++;
+        while (/[\w.]/.test(source[index] ?? '')) index++;
+        expectExpression = false;
+        expectStatement = false;
+        pendingControl = null;
+        continue;
+      }
+      if (character === '(') {
+        parens.push(pendingControl);
+        pendingControl = null;
+        expectExpression = true;
+        expectStatement = false;
+        index++;
+        continue;
+      }
+      if (character === ')') {
+        const control = parens.pop();
+        expectExpression = controlBodies.has(control);
+        expectStatement = controlBodies.has(control);
+        pendingControl = null;
+        index++;
+        continue;
+      }
+      if (character === '{') {
+        braces.push(expectStatement);
+        if (templateExpression) templateBraceDepth++;
+        expectExpression = true;
+        expectStatement = true;
+        pendingControl = null;
+        index++;
+        continue;
+      }
+      if (character === '}') {
+        if (templateExpression && --templateBraceDepth === 0) return index + 1;
+        const block = braces.pop() ?? false;
+        expectExpression = block;
+        expectStatement = block;
+        pendingControl = null;
+        index++;
+        continue;
+      }
+      if (character === '[') {
+        expectExpression = true;
+        expectStatement = false;
+        pendingControl = null;
+        index++;
+        continue;
+      }
+      if (character === ']') {
+        expectExpression = false;
+        expectStatement = false;
+        pendingControl = null;
+        index++;
+        continue;
+      }
+      if ((character === '+' || character === '-') && source[index + 1] === character) {
+        index += 2;
+        pendingControl = null;
+        continue;
+      }
+      if ('=,:;!?&|+-*%^~<>'.includes(character)) {
+        expectExpression = true;
+        expectStatement = character === ';' && parens.length === 0;
+        pendingControl = null;
+        index++;
+        continue;
+      }
+      if (character === '.') {
+        expectExpression = false;
+        expectStatement = false;
+        pendingControl = null;
+        index++;
+        continue;
+      }
+      pendingControl = null;
+      index++;
+    }
+    return source.length;
+  };
+
+  scanCode(0);
+  return output.join('');
+}
+
 function isClearlyMismatchedComponent(directory, moduleName) {
   const target = moduleName.slice('snice-'.length);
   const topLevel = new Set([
@@ -2950,10 +4159,11 @@ function parseNamedImportEntries(clause) {
   return braces[1]
     .split(',')
     .map(value => {
+      const typeOnly = /^type\s+/.test(value.trim());
       const cleaned = value.trim().replace(/^type\s+/, '');
       if (!cleaned) return null;
       const [imported, local = imported] = cleaned.split(/\s+as\s+/);
-      return { imported: imported.trim(), local: local.trim() };
+      return { imported: imported.trim(), local: local.trim(), typeOnly };
     })
     .filter(Boolean);
 }
@@ -2984,101 +4194,30 @@ function importHasProjectUse(source, entry) {
 }
 
 function hasCodeIdentifier(source, target) {
-  const stack = [{ kind: 'code', templateExpression: false, braces: 0 }];
-  let index = 0;
-  while (index < source.length) {
-    const frame = stack.at(-1);
-    const character = source[index];
-
-    if (frame.kind === 'quoted') {
-      if (character === '\\') index += 2;
-      else {
-        index++;
-        if (character === frame.quote) stack.pop();
-      }
-      continue;
-    }
-    if (frame.kind === 'regex') {
-      if (character === '\\') {
-        index += 2;
-      } else if (character === '[') {
-        frame.characterClass = true;
-        index++;
-      } else if (character === ']' && frame.characterClass) {
-        frame.characterClass = false;
-        index++;
-      } else if (character === '/' && !frame.characterClass) {
-        index++;
-        while (/[A-Za-z]/.test(source[index] ?? '')) index++;
-        stack.pop();
-      } else {
-        index++;
-      }
-      continue;
-    }
-    if (frame.kind === 'template') {
-      if (character === '\\') {
-        index += 2;
-      } else if (character === '`') {
-        stack.pop();
-        index++;
-      } else if (character === '$' && source[index + 1] === '{') {
-        stack.push({ kind: 'code', templateExpression: true, braces: 1 });
-        index += 2;
-      } else {
-        index++;
-      }
-      continue;
-    }
+  const code = maskNonExecutableCode(source, { preserveTemplateExpressions: true });
+  return new RegExp(`(?:^|[^\\w$])${escapeRegExp(target)}(?![\\w$])`).test(code);
+}
 
-    if (character === "'" || character === '"') {
-      stack.push({ kind: 'quoted', quote: character });
-      index++;
-      continue;
-    }
-    if (character === '`') {
-      stack.push({ kind: 'template' });
-      index++;
-      continue;
-    }
-    if (character === '/' && startsRegexLiteral(source, index)) {
-      stack.push({ kind: 'regex', characterClass: false });
-      index++;
-      continue;
-    }
-    if (frame.templateExpression && character === '{') {
-      frame.braces++;
-      index++;
-      continue;
-    }
-    if (frame.templateExpression && character === '}') {
-      frame.braces--;
-      index++;
-      if (frame.braces === 0) stack.pop();
+function regexLiteralEnd(source, slashIndex) {
+  let characterClass = false;
+  for (let index = slashIndex + 1; index < source.length; index++) {
+    const character = source[index];
+    if (character === '\n' || character === '\r') return -1;
+    if (character === '\\') { index++; continue; }
+    if (character === '[' && !characterClass) {
+      characterClass = true;
       continue;
     }
-    if (/[A-Za-z_$]/.test(character)) {
-      let end = index + 1;
-      while (/[\w$]/.test(source[end] ?? '')) end++;
-      if (source.slice(index, end) === target) return true;
-      index = end;
+    if (character === ']' && characterClass) {
+      characterClass = false;
       continue;
     }
+    if (character !== '/' || characterClass) continue;
     index++;
+    while (/[A-Za-z]/.test(source[index] ?? '')) index++;
+    return index;
   }
-  return false;
-}
-
-function startsRegexLiteral(source, slashIndex) {
-  let previous = slashIndex - 1;
-  while (previous >= 0 && /\s/.test(source[previous])) previous--;
-  if (previous < 0 || /[([{=:;,!?&|+*%^~<>-]/.test(source[previous])) return true;
-  if (!/[\w$]/.test(source[previous])) return false;
-  let start = previous;
-  while (start > 0 && /[\w$]/.test(source[start - 1])) start--;
-  return /^(?:return|case|throw|else|do|typeof|instanceof|in|of|yield|await|void|delete)$/.test(
-    source.slice(start, previous + 1)
-  );
+  return -1;
 }
 
 function reactExportReplacement(name) {
@@ -3093,13 +4232,18 @@ function reactExportReplacement(name) {
 }
 
 function buildSourceProvenance(source) {
+  const code = maskNonExecutableCode(source);
   const imports = findImports(source);
   const rootBindings = new Map();
+  const namespaceBindings = new Map();
   const reactBindings = [];
   const componentVariables = new Map();
   for (const entry of imports) {
-    if (entry.path === 'snice') {
+    const namespace = /^\*\s+as\s+([A-Za-z_$][\w$]*)$/.exec(entry.clause ?? '');
+    if (namespace && !entry.typeOnly) namespaceBindings.set(namespace[1], entry.path);
+    if (entry.path === 'snice' && !entry.typeOnly) {
       for (const binding of parseNamedImportEntries(entry.clause)) {
+        if (binding.typeOnly) continue;
         const list = rootBindings.get(binding.imported) ?? [];
         list.push({ ...binding, index: entry.index, path: entry.path });
         rootBindings.set(binding.imported, list);
@@ -3121,7 +4265,7 @@ function buildSourceProvenance(source) {
   for (const match of source.matchAll(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:document\.)?querySelector(?:<[^>]+>)?\(\s*['"](snice-[a-z0-9-]+)['"]\s*\)/g)) {
     if (COMPONENT_CONTRACTS[match[2]]) componentVariables.set(match[1], match[2]);
   }
-  return { imports, rootBindings, reactBindings, componentVariables };
+  return { source: code, imports, rootBindings, namespaceBindings, reactBindings, componentVariables };
 }
 
 function normalizeReactExport(name) {