@decantr/verifier 2.5.1 → 3.0.0-next.0

package/dist/index.js

@@ -1,15 +1,353 @@
 // src/index.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync3, realpathSync, statSync as statSync3 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync4, readFileSync as readFileSync5, realpathSync, statSync as statSync3 } from "fs";
 import { readFile } from "fs/promises";
-import { basename, dirname, extname as extname3, isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve } from "path";
+import { basename as basename2, dirname, extname as extname4, isAbsolute as isAbsolute2, join as join4, relative as relative4, resolve } from "path";
 import { evaluateGuard, isV4, validateEssence } from "@decantr/essence-spec";
+import * as ts3 from "typescript";
+
+// src/component-reuse.ts
+import { readFileSync } from "fs";
+import { basename, extname, relative } from "path";
 import * as ts from "typescript";
+var COMPONENT_REUSE_RULE_ID = "component-reuse-primitive-reimplemented";
+var RAW_CONTROL_REUSE_RULE_ID = "component-reuse-raw-control";
+var PRIMITIVE_COMPONENT_NAMES = /* @__PURE__ */ new Set([
+  "Accordion",
+  "Alert",
+  "Avatar",
+  "Badge",
+  "Breadcrumb",
+  "Button",
+  "Calendar",
+  "Card",
+  "Chart",
+  "Checkbox",
+  "Combobox",
+  "Command",
+  "DataTable",
+  "DatePicker",
+  "Dialog",
+  "Drawer",
+  "DropdownMenu",
+  "EmptyState",
+  "ErrorState",
+  "Field",
+  "Footer",
+  "Form",
+  "Header",
+  "Heading",
+  "Icon",
+  "Input",
+  "Kpi",
+  "Label",
+  "Link",
+  "Metric",
+  "Modal",
+  "Nav",
+  "Popover",
+  "Radio",
+  "Search",
+  "Select",
+  "Sheet",
+  "Sidebar",
+  "Skeleton",
+  "Spinner",
+  "Switch",
+  "Table",
+  "Tabs",
+  "Textarea",
+  "Toast",
+  "Toggle",
+  "Tooltip"
+]);
+var RAW_CONTROL_COMPONENT_BY_ELEMENT = {
+  button: "Button",
+  dialog: "Dialog",
+  input: "Input",
+  select: "Select",
+  table: "Table",
+  textarea: "Textarea"
+};
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function isPrimitiveComponentName(name) {
+  return PRIMITIVE_COMPONENT_NAMES.has(name);
+}
+function isComponentName(name) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(name);
+}
+function hasExportModifier(node) {
+  return Boolean(
+    ts.canHaveModifiers(node) && ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
+  );
+}
+function containsJsx(node) {
+  let found = false;
+  const visit = (child) => {
+    if (found) return;
+    if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child) || ts.isJsxFragment(child) || ts.isJsxOpeningElement(child)) {
+      found = true;
+      return;
+    }
+    ts.forEachChild(child, visit);
+  };
+  ts.forEachChild(node, visit);
+  return found;
+}
+function classExtendsReactComponent(node) {
+  return node.heritageClauses?.some(
+    (clause) => clause.types.some((type) => {
+      const text = type.expression.getText();
+      return /(?:^|\.)(?:Component|PureComponent)$/.test(text);
+    })
+  ) ?? false;
+}
+function lineForNode(sourceFile, node) {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function jsxIdentifierName(name) {
+  return ts.isIdentifier(name) ? name.text : null;
+}
+function jsxAttributeStringValue(node, attributeName) {
+  for (const property of node.attributes.properties) {
+    if (!ts.isJsxAttribute(property) || !ts.isIdentifier(property.name) || property.name.text !== attributeName) {
+      continue;
+    }
+    if (!property.initializer) return "";
+    if (ts.isStringLiteral(property.initializer)) return property.initializer.text;
+  }
+  return null;
+}
+function isHiddenInput(node) {
+  const tagName = jsxIdentifierName(node.tagName);
+  if (tagName !== "input") return false;
+  return jsxAttributeStringValue(node, "type")?.toLowerCase() === "hidden";
+}
+function isReusableComponentPath(file, name) {
+  const normalized = normalizePath(file);
+  const extension = extname(normalized);
+  const base = basename(normalized, extension).toLowerCase();
+  const componentName = name.toLowerCase();
+  return /(?:^|\/)(?:components|ui|shared|primitives|design-system|common)(?:\/|$)/i.test(normalized) || base === componentName && !/(?:^|\/)(?:app|pages|routes)(?:\/|$)/i.test(normalized) && !/(?:^|\/)(?:page|layout|route|loading|error|not-found)\.[cm]?[jt]sx?$/i.test(normalized);
+}
+function collectImports(sourceFile, file) {
+  const imports = /* @__PURE__ */ new Set();
+  const references = [];
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement)) continue;
+    const clause = statement.importClause;
+    const moduleSpecifier = statement.moduleSpecifier;
+    if (!ts.isStringLiteral(moduleSpecifier)) continue;
+    const defaultImport = clause?.name?.text;
+    const imported = [];
+    const localNames = [];
+    let namespaceImport;
+    if (!clause) continue;
+    if (clause.name) {
+      imports.add(clause.name.text);
+      localNames.push(clause.name.text);
+    }
+    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+      for (const element of clause.namedBindings.elements) {
+        imports.add(element.name.text);
+        localNames.push(element.name.text);
+        imported.push((element.propertyName ?? element.name).text);
+      }
+    } else if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+      namespaceImport = clause.namedBindings.name.text;
+      imports.add(namespaceImport);
+      localNames.push(namespaceImport);
+    }
+    references.push({
+      file,
+      source: moduleSpecifier.text,
+      line: lineForNode(sourceFile, statement),
+      ...defaultImport ? { defaultImport } : {},
+      ...namespaceImport ? { namespaceImport } : {},
+      imported,
+      localNames
+    });
+  }
+  return { names: imports, references };
+}
+function collectDeclarations(sourceFile, file) {
+  const declarations = [];
+  const addDeclaration = (node, name, exported, kind) => {
+    if (!isComponentName(name) || !containsJsx(node)) return;
+    declarations.push({
+      id: `cmp:${file}:${name}`,
+      name,
+      file,
+      line: lineForNode(sourceFile, node),
+      exported,
+      reusable: exported && isReusableComponentPath(file, name),
+      kind
+    });
+  };
+  const visit = (node) => {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      addDeclaration(node, node.name.text, hasExportModifier(node), "function");
+    } else if (ts.isClassDeclaration(node) && node.name && classExtendsReactComponent(node)) {
+      addDeclaration(node, node.name.text, hasExportModifier(node), "class");
+    } else if (ts.isVariableStatement(node)) {
+      const exported = hasExportModifier(node);
+      for (const declaration of node.declarationList.declarations) {
+        if (!ts.isIdentifier(declaration.name) || !declaration.initializer) continue;
+        addDeclaration(declaration, declaration.name.text, exported, "variable");
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(sourceFile, visit);
+  return declarations;
+}
+function componentDeclarationName(node) {
+  if (ts.isFunctionDeclaration(node) && node.name && isComponentName(node.name.text)) {
+    return containsJsx(node) ? node.name.text : null;
+  }
+  if (ts.isClassDeclaration(node) && node.name && isComponentName(node.name.text) && classExtendsReactComponent(node)) {
+    return node.name.text;
+  }
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && isComponentName(node.name.text)) {
+    return node.initializer && containsJsx(node) ? node.name.text : null;
+  }
+  return null;
+}
+function collectRawControls(sourceFile, file) {
+  const rawControls = [];
+  const visit = (node, containingComponent) => {
+    const nextComponent = componentDeclarationName(node) ?? containingComponent;
+    if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const tagName = jsxIdentifierName(node.tagName);
+      const component = tagName && Object.hasOwn(RAW_CONTROL_COMPONENT_BY_ELEMENT, tagName) ? RAW_CONTROL_COMPONENT_BY_ELEMENT[tagName] : null;
+      if (component && !isHiddenInput(node)) {
+        rawControls.push({
+          element: tagName,
+          component,
+          file,
+          line: lineForNode(sourceFile, node),
+          ...nextComponent ? { containingComponent: nextComponent } : {}
+        });
+      }
+    }
+    ts.forEachChild(node, (child) => visit(child, nextComponent));
+  };
+  ts.forEachChild(sourceFile, (node) => visit(node));
+  return rawControls;
+}
+function parseComponentFile(projectRoot, absolutePath) {
+  const file = normalizePath(relative(projectRoot, absolutePath) || absolutePath);
+  if (isNonProductionComponentAuditFile(file)) {
+    return null;
+  }
+  let code = "";
+  try {
+    code = readFileSync(absolutePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const sourceFile = ts.createSourceFile(
+    file,
+    code,
+    ts.ScriptTarget.Latest,
+    true,
+    /\.[cm]?[jt]sx$/i.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const imports = collectImports(sourceFile, file);
+  return {
+    file,
+    imports: imports.names,
+    importReferences: imports.references,
+    declarations: collectDeclarations(sourceFile, file),
+    rawControls: collectRawControls(sourceFile, file)
+  };
+}
+function canonicalSort(a, b) {
+  return a.file.localeCompare(b.file) || a.line - b.line || a.name.localeCompare(b.name);
+}
+function isNonProductionComponentAuditFile(file) {
+  const normalized = normalizePath(file);
+  return /(?:^|\/)(?:__tests__|__mocks__|tests?|specs?|fixtures?|mocks?|stories?)(?:\/|$)/i.test(
+    normalized
+  ) || /\.(?:test|spec|stories|story|fixture|mock)\.[cm]?[jt]sx?$/i.test(normalized);
+}
+function auditComponentReuse(projectRoot, sourceFiles) {
+  const parsedFiles = sourceFiles.map((file) => parseComponentFile(projectRoot, file)).filter((file) => Boolean(file));
+  const declarations = parsedFiles.flatMap((file) => file.declarations);
+  const reusableByName = /* @__PURE__ */ new Map();
+  for (const declaration of declarations) {
+    if (!declaration.reusable || !isPrimitiveComponentName(declaration.name)) continue;
+    const existing = reusableByName.get(declaration.name) ?? [];
+    existing.push(declaration);
+    reusableByName.set(declaration.name, existing.sort(canonicalSort));
+  }
+  const findings = [];
+  const rawControlFindings = [];
+  for (const parsedFile of parsedFiles) {
+    for (const declaration of parsedFile.declarations) {
+      if (!isPrimitiveComponentName(declaration.name) || declaration.reusable) continue;
+      if (parsedFile.imports.has(declaration.name)) continue;
+      const canonical = reusableByName.get(declaration.name)?.filter((entry) => entry.file !== declaration.file).sort(canonicalSort)[0];
+      if (!canonical) continue;
+      findings.push({
+        id: `${COMPONENT_REUSE_RULE_ID}:${declaration.file}:${declaration.name}`,
+        name: declaration.name,
+        file: declaration.file,
+        line: declaration.line,
+        canonicalFile: canonical.file,
+        canonicalLine: canonical.line,
+        evidence: [
+          `${declaration.file}:${declaration.line} declares local ${declaration.name}`,
+          `${canonical.file}:${canonical.line} already exports reusable ${canonical.name}`
+        ]
+      });
+    }
+    const seenRawControls = /* @__PURE__ */ new Set();
+    for (const rawControl of parsedFile.rawControls) {
+      if (parsedFile.imports.has(rawControl.component)) continue;
+      if (rawControl.containingComponent === rawControl.component) continue;
+      const canonical = reusableByName.get(rawControl.component)?.filter((entry) => entry.file !== rawControl.file).sort(canonicalSort)[0];
+      if (!canonical) continue;
+      const key = `${rawControl.file}:${rawControl.component}`;
+      if (seenRawControls.has(key)) continue;
+      seenRawControls.add(key);
+      rawControlFindings.push({
+        id: `${RAW_CONTROL_REUSE_RULE_ID}:${rawControl.file}:${rawControl.element}`,
+        element: rawControl.element,
+        component: rawControl.component,
+        file: rawControl.file,
+        line: rawControl.line,
+        canonicalFile: canonical.file,
+        canonicalLine: canonical.line,
+        ...rawControl.containingComponent ? { containingComponent: rawControl.containingComponent } : {},
+        evidence: [
+          `${rawControl.file}:${rawControl.line} renders raw <${rawControl.element}>`,
+          `${canonical.file}:${canonical.line} already exports reusable ${canonical.name}`
+        ]
+      });
+    }
+  }
+  return {
+    filesChecked: parsedFiles.length,
+    declarations,
+    imports: parsedFiles.flatMap((file) => file.importReferences),
+    reusableComponentCount: [...reusableByName.values()].reduce(
+      (count, entries) => count + entries.length,
+      0
+    ),
+    localRedeclarationCount: findings.length,
+    rawControlCount: rawControlFindings.length,
+    findings,
+    rawControlFindings
+  };
+}
 
 // src/runtime.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
 import { createServer } from "http";
-import { extname, join, normalize } from "path";
+import { extname as extname2, join, normalize } from "path";
 var CONTENT_TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -69,7 +407,7 @@ function emptyRuntimeAudit(failures = []) {
   };
 }
 function getContentType(pathname) {
-  return CONTENT_TYPES[extname(pathname)] ?? "application/octet-stream";
+  return CONTENT_TYPES[extname2(pathname)] ?? "application/octet-stream";
 }
 function extractAssetPaths(indexHtml) {
   const assetPaths = /* @__PURE__ */ new Set();
@@ -252,7 +590,7 @@ function auditNextBuildOutput(projectRoot) {
     const relativePath = filePath.slice(appServerDir.length + 1).replace(/\\/g, "/");
     return filePath.endsWith(".html") && !relativePath.startsWith("_");
   });
-  const htmlDocuments = htmlFiles.map((filePath) => readFileSync(filePath, "utf-8"));
+  const htmlDocuments = htmlFiles.map((filePath) => readFileSync2(filePath, "utf-8"));
   const staticAssetFiles = collectFiles(
     join(nextDir, "static"),
     (filePath) => /\.(?:js|css|json|svg|png|jpe?g|webp)$/i.test(filePath)
@@ -269,7 +607,7 @@ function auditNextBuildOutput(projectRoot) {
     totalAssetBytes += byteLength;
     if (assetFile.endsWith(".js")) {
       jsAssetBytes += byteLength;
-      combinedJs += readFileSync(assetFile, "utf-8");
+      combinedJs += readFileSync2(assetFile, "utf-8");
     }
     if (assetFile.endsWith(".css")) {
       cssAssetBytes += byteLength;
@@ -354,7 +692,7 @@ function isNextProject(projectRoot) {
     return true;
   }
   try {
-    const pkg = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync2(join(projectRoot, "package.json"), "utf-8"));
     return Boolean(pkg.dependencies?.next || pkg.devDependencies?.next);
   } catch {
     return false;
@@ -371,13 +709,13 @@ async function startStaticServer(rootDir) {
       if (existsSync(filePath)) {
         res.statusCode = 200;
         res.setHeader("Content-Type", getContentType(filePath));
-        res.end(readFileSync(filePath));
+        res.end(readFileSync2(filePath));
         return;
       }
       if (existsSync(fallbackPath)) {
         res.statusCode = 200;
         res.setHeader("Content-Type", "text/html; charset=utf-8");
-        res.end(readFileSync(fallbackPath));
+        res.end(readFileSync2(fallbackPath));
         return;
       }
       res.statusCode = 404;
@@ -422,7 +760,7 @@ async function auditBuiltDist(projectRoot, options = {}) {
   }
   const routeHints = Array.isArray(options.routeHints) && options.routeHints.length > 0 ? options.routeHints.map((route) => normalizeRouteHint(route)).filter(Boolean).slice(0, 8) : ["/"];
   const frameworkDocumentOutput = isNextProject(projectRoot);
-  const indexHtml = readFileSync(indexPath, "utf-8");
+  const indexHtml = readFileSync2(indexPath, "utf-8");
   const assetPaths = extractAssetPaths(indexHtml);
   const server = await startStaticServer(distDir);
   try {
@@ -586,6 +924,862 @@ async function auditBuiltDist(projectRoot, options = {}) {
   }
 }
 
+// src/style-bridge-drift.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join2, relative as relative2 } from "path";
+import * as ts2 from "typescript";
+var STYLE_BRIDGE_ARBITRARY_VALUE_RULE_ID = "style-bridge-arbitrary-value";
+var CLASS_HELPER_NAMES = /* @__PURE__ */ new Set(["cn", "clsx", "classnames", "cva", "tv"]);
+var INLINE_STYLE_PROPERTIES = /* @__PURE__ */ new Set([
+  "accentColor",
+  "background",
+  "backgroundColor",
+  "border",
+  "borderColor",
+  "boxShadow",
+  "caretColor",
+  "color",
+  "fill",
+  "outline",
+  "outlineColor",
+  "stroke",
+  "textDecorationColor"
+]);
+var STYLESHEET_EXTENSIONS = /\.(?:css|scss|sass|less)$/i;
+var SCRIPT_EXTENSIONS = /\.[cm]?[jt]sx?$/i;
+var STYLESHEET_VISUAL_PROPERTIES = /* @__PURE__ */ new Set([
+  "accent-color",
+  "background",
+  "background-color",
+  "border",
+  "border-color",
+  "box-shadow",
+  "caret-color",
+  "color",
+  "fill",
+  "outline",
+  "outline-color",
+  "stroke",
+  "text-decoration-color"
+]);
+function normalizePath2(path) {
+  return path.replace(/\\/g, "/");
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+function isNonProductionStyleBridgeDriftFile(file) {
+  const normalized = normalizePath2(file);
+  return /(?:^|\/)(?:__tests__|__mocks__|tests?|specs?|fixtures?|mocks?|stories?)(?:\/|$)/i.test(
+    normalized
+  ) || /\.(?:test|spec|stories|story|fixture|mock)\.(?:[cm]?[jt]sx?|css|scss|sass|less)$/i.test(
+    normalized
+  );
+}
+function collectProjectStyleFiles(projectRoot) {
+  const candidates = ["src", "app", "pages", "components", "styles"].map((dir) => join2(projectRoot, dir)).filter((dir) => existsSync2(dir));
+  const ignoredDirNames = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".git",
+    ".decantr",
+    "dist",
+    "build",
+    "coverage"
+  ]);
+  const files = /* @__PURE__ */ new Set();
+  const walk = (dir) => {
+    for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+      if (ignoredDirNames.has(entry.name)) continue;
+      const absolutePath = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(absolutePath);
+        continue;
+      }
+      if (!entry.isFile() || !STYLESHEET_EXTENSIONS.test(absolutePath)) continue;
+      files.add(absolutePath);
+    }
+  };
+  for (const candidate of candidates) {
+    walk(candidate);
+  }
+  return [...files].sort();
+}
+function readAcceptedStyleBridge(projectRoot) {
+  const path = join2(projectRoot, ".decantr", "style-bridge.json");
+  if (!existsSync2(path)) return null;
+  let bridge;
+  try {
+    bridge = JSON.parse(readFileSync3(path, "utf-8"));
+  } catch {
+    return null;
+  }
+  if (bridge.status !== "accepted" || !Array.isArray(bridge.mappings)) return null;
+  const mappings = bridge.mappings.filter(
+    (mapping) => Boolean(mapping) && typeof mapping === "object"
+  );
+  if (mappings.length === 0) return null;
+  const mappingIds = mappings.map(
+    (mapping, index) => typeof mapping.id === "string" && mapping.id.length > 0 ? mapping.id : typeof mapping.label === "string" && mapping.label.length > 0 ? mapping.label : `mapping-${index + 1}`
+  ).slice(0, 12);
+  const tokenHints = [
+    ...new Set(mappings.flatMap((mapping) => stringArray(mapping.tokenHints)))
+  ].slice(0, 16);
+  const classHints = [
+    ...new Set(mappings.flatMap((mapping) => stringArray(mapping.classHints)))
+  ].slice(0, 16);
+  return { mappingIds, tokenHints, classHints };
+}
+function lineForNode2(sourceFile, node) {
+  return sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+}
+function jsxAttributeName(name) {
+  if (ts2.isIdentifier(name)) return name.text;
+  if (ts2.isJsxNamespacedName(name)) return `${name.namespace.text}:${name.name.text}`;
+  return null;
+}
+function jsxAttributeText(attribute) {
+  const initializer = attribute.initializer;
+  if (!initializer) return "";
+  if (ts2.isStringLiteral(initializer)) return initializer.text;
+  if (!ts2.isJsxExpression(initializer) || !initializer.expression) return null;
+  const expression = initializer.expression;
+  if (ts2.isStringLiteral(expression) || ts2.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts2.isTemplateExpression(expression)) {
+    return [
+      expression.head.text,
+      ...expression.templateSpans.map((span) => span.literal.text)
+    ].join(" ");
+  }
+  return null;
+}
+function classHelperName(expression) {
+  if (ts2.isIdentifier(expression)) return expression.text;
+  if (ts2.isPropertyAccessExpression(expression)) return expression.name.text;
+  return null;
+}
+function isClassHelperCall(node) {
+  const helperName = classHelperName(node.expression);
+  return Boolean(helperName && CLASS_HELPER_NAMES.has(helperName));
+}
+function templateExpressionText(expression) {
+  return [
+    expression.head.text,
+    ...expression.templateSpans.map((span) => span.literal.text)
+  ].join(" ");
+}
+function collectClassTextsFromNode(node) {
+  const entries = [];
+  const visit = (child) => {
+    if (ts2.isStringLiteral(child) || ts2.isNoSubstitutionTemplateLiteral(child)) {
+      entries.push({ className: child.text, node: child });
+      return;
+    }
+    if (ts2.isTemplateExpression(child)) {
+      entries.push({ className: templateExpressionText(child), node: child });
+      return;
+    }
+    ts2.forEachChild(child, visit);
+  };
+  ts2.forEachChild(node, visit);
+  return entries;
+}
+function stripTailwindVariants(className) {
+  let bracketDepth = 0;
+  let segmentStart = 0;
+  for (let index = 0; index < className.length; index += 1) {
+    const char = className[index];
+    if (char === "[") bracketDepth += 1;
+    if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+    if (char === ":" && bracketDepth === 0) segmentStart = index + 1;
+  }
+  return className.slice(segmentStart);
+}
+function arbitraryStyleClasses(className) {
+  const classes = className.split(/\s+/).map((entry) => entry.trim()).filter(Boolean);
+  return classes.filter((entry) => {
+    const classWithoutVariant = stripTailwindVariants(entry);
+    return /^(?:-)?(?:bg|text|border|ring|shadow|from|via|to|fill|stroke|outline|decoration|accent|caret|placeholder|divide)-\[[^\]]+\]$/i.test(
+      classWithoutVariant
+    ) || /^\[(?:color|background|background-color|border|border-color|box-shadow|outline|fill|stroke|--[A-Za-z0-9_-]+):[^\]]+\]$/i.test(
+      classWithoutVariant
+    );
+  });
+}
+function propertyName(name) {
+  if (ts2.isIdentifier(name) || ts2.isStringLiteral(name) || ts2.isNumericLiteral(name)) {
+    return name.text;
+  }
+  return null;
+}
+function styleLiteralValue(expression) {
+  if (ts2.isStringLiteral(expression) || ts2.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts2.isTemplateExpression(expression)) {
+    return expression.templateSpans.length === 0 ? expression.head.text : null;
+  }
+  return null;
+}
+function isAcceptedTokenValue(value, tokenHints) {
+  return tokenHints.some((hint) => {
+    const normalizedHint = hint.trim();
+    if (!normalizedHint) return false;
+    return value.includes(normalizedHint) || value.includes(`var(${normalizedHint})`);
+  });
+}
+function arbitraryInlineStyleValue(property, value, tokenHints) {
+  const normalizedProperty = property.trim();
+  const normalizedValue = value.trim();
+  if (!normalizedProperty || !normalizedValue) return null;
+  const isVisualProperty = INLINE_STYLE_PROPERTIES.has(normalizedProperty) || STYLESHEET_VISUAL_PROPERTIES.has(normalizedProperty) || normalizedProperty.startsWith("--");
+  if (!isVisualProperty) return null;
+  if (isAcceptedTokenValue(normalizedValue, tokenHints)) return null;
+  if (/(?:^|[\s,(])#[0-9a-f]{3,8}\b|(?:rgba?|hsla?|oklch|oklab|lch|lab|color-mix)\(/i.test(
+    normalizedValue
+  ) || /var\(--[A-Za-z0-9_-]+\)/i.test(normalizedValue)) {
+    return `${normalizedProperty}: ${normalizedValue}`;
+  }
+  return null;
+}
+function styleBridgeEvidenceText(file, line, source, value) {
+  if (source === "inline-style") {
+    return `${file}:${line} uses inline style value "${value}"`;
+  }
+  if (source === "stylesheet") {
+    return `${file}:${line} uses stylesheet value "${value}"`;
+  }
+  return `${file}:${line} uses arbitrary Tailwind value "${value}"`;
+}
+function collectStyleBridgeDriftFindings(input) {
+  const file = normalizePath2(relative2(input.projectRoot, input.absolutePath) || input.absolutePath);
+  if (isNonProductionStyleBridgeDriftFile(file)) return [];
+  if (!SCRIPT_EXTENSIONS.test(file)) return [];
+  let code = "";
+  try {
+    code = readFileSync3(input.absolutePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const sourceFile = ts2.createSourceFile(
+    file,
+    code,
+    ts2.ScriptTarget.Latest,
+    true,
+    /\.[cm]?[jt]sx$/i.test(file) ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS
+  );
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addFinding = (node, className, value, source, property) => {
+    const line = lineForNode2(sourceFile, node);
+    const key = `${file}:${line}:${value}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    findings.push({
+      id: `${STYLE_BRIDGE_ARBITRARY_VALUE_RULE_ID}:${file}:${line}:${value}`,
+      file,
+      line,
+      className,
+      value,
+      source,
+      ...property ? { property } : {},
+      bridgeMappingIds: input.bridge.mappingIds,
+      tokenHints: input.bridge.tokenHints,
+      classHints: input.bridge.classHints,
+      evidence: [
+        styleBridgeEvidenceText(file, line, source, value),
+        `.decantr/style-bridge.json is accepted with mappings: ${input.bridge.mappingIds.join(", ")}`,
+        input.bridge.tokenHints.length > 0 ? `Accepted token hints: ${input.bridge.tokenHints.join(", ")}` : "Accepted style bridge has no token hints for this mapping set",
+        input.bridge.classHints.length > 0 ? `Accepted class hints: ${input.bridge.classHints.join(", ")}` : "Accepted style bridge has no class hints for this mapping set"
+      ]
+    });
+  };
+  const visit = (node) => {
+    if (ts2.isJsxAttribute(node) && jsxAttributeName(node.name) === "className") {
+      const className = jsxAttributeText(node);
+      if (className) {
+        for (const value of arbitraryStyleClasses(className)) {
+          addFinding(node, className, value, "className");
+        }
+      }
+    }
+    if (ts2.isJsxAttribute(node) && jsxAttributeName(node.name) === "style") {
+      const initializer = node.initializer;
+      const expression = initializer && ts2.isJsxExpression(initializer) ? initializer.expression : void 0;
+      if (expression && ts2.isObjectLiteralExpression(expression)) {
+        for (const property of expression.properties) {
+          if (!ts2.isPropertyAssignment(property)) continue;
+          const name = propertyName(property.name);
+          const literal = styleLiteralValue(property.initializer);
+          if (!name || literal === null) continue;
+          const value = arbitraryInlineStyleValue(name, literal, input.bridge.tokenHints);
+          if (value) {
+            addFinding(property, `style.${name}`, value, "inline-style", name);
+          }
+        }
+      }
+    }
+    if (ts2.isCallExpression(node) && isClassHelperCall(node)) {
+      for (const entry of collectClassTextsFromNode(node)) {
+        for (const value of arbitraryStyleClasses(entry.className)) {
+          addFinding(entry.node, entry.className, value, "className");
+        }
+      }
+    }
+    ts2.forEachChild(node, visit);
+  };
+  ts2.forEachChild(sourceFile, visit);
+  return findings;
+}
+function collectStylesheetBridgeDriftFindings(input) {
+  const file = normalizePath2(relative2(input.projectRoot, input.absolutePath) || input.absolutePath);
+  if (isNonProductionStyleBridgeDriftFile(file) || !STYLESHEET_EXTENSIONS.test(file)) return [];
+  let code = "";
+  try {
+    code = readFileSync3(input.absolutePath, "utf-8");
+  } catch {
+    return [];
+  }
+  const findings = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = code.split(/\r?\n/);
+  const declarationPattern = /(^|[;{\s])(?<property>accent-color|background|background-color|border|border-color|box-shadow|caret-color|color|fill|outline|outline-color|stroke|text-decoration-color)\s*:\s*(?<value>[^;{}]+)\s*;?/gi;
+  for (const [lineIndex, line] of lines.entries()) {
+    if (/^\s*(?:\/\*|\*|\/\/)/.test(line)) continue;
+    for (const match of line.matchAll(declarationPattern)) {
+      const property = match.groups?.property;
+      const rawValue = match.groups?.value;
+      if (!property || !rawValue) continue;
+      const value = arbitraryInlineStyleValue(property, rawValue, input.bridge.tokenHints);
+      if (!value) continue;
+      const lineNumber = lineIndex + 1;
+      const key = `${file}:${lineNumber}:${value}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      findings.push({
+        id: `${STYLE_BRIDGE_ARBITRARY_VALUE_RULE_ID}:${file}:${lineNumber}:${value}`,
+        file,
+        line: lineNumber,
+        className: property,
+        value,
+        source: "stylesheet",
+        property,
+        bridgeMappingIds: input.bridge.mappingIds,
+        tokenHints: input.bridge.tokenHints,
+        classHints: input.bridge.classHints,
+        evidence: [
+          `${file}:${lineNumber} uses stylesheet value "${value}"`,
+          `.decantr/style-bridge.json is accepted with mappings: ${input.bridge.mappingIds.join(", ")}`,
+          input.bridge.tokenHints.length > 0 ? `Accepted token hints: ${input.bridge.tokenHints.join(", ")}` : "Accepted style bridge has no token hints for this mapping set",
+          input.bridge.classHints.length > 0 ? `Accepted class hints: ${input.bridge.classHints.join(", ")}` : "Accepted style bridge has no class hints for this mapping set"
+        ]
+      });
+    }
+  }
+  return findings;
+}
+function auditStyleBridgeDrift(projectRoot, sourceFiles) {
+  const bridge = readAcceptedStyleBridge(projectRoot);
+  if (!bridge) {
+    return {
+      filesChecked: 0,
+      bridgeMappingCount: 0,
+      arbitraryValueCount: 0,
+      findings: []
+    };
+  }
+  const filesToCheck = [
+    .../* @__PURE__ */ new Set([...sourceFiles, ...collectProjectStyleFiles(projectRoot)])
+  ].sort();
+  const findings = filesToCheck.flatMap(
+    (absolutePath) => SCRIPT_EXTENSIONS.test(absolutePath) ? collectStyleBridgeDriftFindings({ projectRoot, absolutePath, bridge }) : collectStylesheetBridgeDriftFindings({ projectRoot, absolutePath, bridge })
+  );
+  return {
+    filesChecked: filesToCheck.filter(
+      (file) => !isNonProductionStyleBridgeDriftFile(
+        normalizePath2(relative2(projectRoot, file) || file)
+      )
+    ).length,
+    bridgeMappingCount: bridge.mappingIds.length,
+    arbitraryValueCount: findings.length,
+    findings
+  };
+}
+
+// src/diagnostics.ts
+var KNOWN_VERIFICATION_DIAGNOSTICS = [
+  {
+    rule: "browser-base-url-missing",
+    code: "VISUAL002",
+    repairId: "provide-browser-base-url",
+    family: "VISUAL"
+  },
+  {
+    rule: "browser-playwright-missing",
+    code: "VISUAL001",
+    repairId: "install-browser-verifier",
+    family: "VISUAL"
+  },
+  {
+    rule: "browser-route-verification-failed",
+    code: "VISUAL003",
+    repairId: "fix-route-render",
+    family: "VISUAL"
+  },
+  {
+    rule: "visual-baseline-screenshot-drift",
+    code: "VISUAL010",
+    repairId: "review-visual-baseline-drift",
+    family: "VISUAL"
+  },
+  {
+    rule: "brownfield-route-drift",
+    code: "ROUTE001",
+    repairId: "reconcile-brownfield-routes",
+    family: "ROUTE"
+  },
+  { rule: "check-failed", code: "CHECK001", repairId: "repair-contract-check", family: "CHECK" },
+  {
+    rule: "component-reuse-raw-control",
+    code: "COMP010",
+    repairId: "replace-raw-control-with-local-component",
+    family: "COMP"
+  },
+  {
+    rule: "component-reuse-primitive-reimplemented",
+    code: "COMP001",
+    repairId: "import-existing-component",
+    family: "COMP"
+  },
+  {
+    rule: "declared-route-resolves",
+    code: "STRUCT002",
+    repairId: "repair-route-binding",
+    family: "STRUCT"
+  },
+  {
+    rule: "design-token-coverage",
+    code: "TOKEN002",
+    repairId: "repair-design-token-coverage",
+    family: "TOKEN"
+  },
+  {
+    rule: "style-bridge-arbitrary-value",
+    code: "TOKEN010",
+    repairId: "replace-arbitrary-style-with-bridge-token",
+    family: "TOKEN"
+  },
+  {
+    rule: "essence-present",
+    code: "CONTRACT001",
+    repairId: "restore-essence-contract",
+    family: "CONTRACT"
+  },
+  {
+    rule: "essence-v4",
+    code: "CONTRACT002",
+    repairId: "migrate-essence-v4",
+    family: "CONTRACT"
+  },
+  {
+    rule: "focus-visible-enabled",
+    code: "A11Y001",
+    repairId: "enable-focus-visible",
+    family: "A11Y"
+  },
+  {
+    rule: "pack-manifest-present",
+    code: "CTX002",
+    repairId: "hydrate-execution-packs",
+    family: "CTX"
+  },
+  {
+    rule: "pack-manifest-missing",
+    code: "CTX002",
+    repairId: "hydrate-execution-packs",
+    family: "CTX"
+  },
+  {
+    rule: "page-pack-count-mismatch",
+    code: "CTX001",
+    repairId: "regenerate-context-packs",
+    family: "CTX"
+  },
+  { rule: "page-route-required", code: "STRUCT001", repairId: "add-page-route", family: "STRUCT" },
+  {
+    rule: "project-audit-invalid",
+    code: "AUDIT001",
+    repairId: "repair-project-audit",
+    family: "AUDIT"
+  },
+  {
+    rule: "review-pack-present",
+    code: "CTX003",
+    repairId: "hydrate-review-pack",
+    family: "CTX"
+  },
+  {
+    rule: "review-pack-file-missing",
+    code: "CTX003",
+    repairId: "hydrate-review-pack",
+    family: "CTX"
+  },
+  {
+    rule: "section-shell-concrete",
+    code: "STRUCT003",
+    repairId: "assign-section-shell",
+    family: "STRUCT"
+  },
+  {
+    rule: "tokens-file-present",
+    code: "TOKEN001",
+    repairId: "restore-design-token-file",
+    family: "TOKEN"
+  },
+  {
+    rule: "typed-graph-current",
+    code: "GRAPH001",
+    repairId: "regenerate-typed-graph",
+    family: "GRAPH"
+  }
+];
+var CODE_BY_RULE = Object.fromEntries(
+  KNOWN_VERIFICATION_DIAGNOSTICS.map((entry) => [entry.rule, entry.code])
+);
+var REPAIR_BY_RULE = Object.fromEntries(
+  KNOWN_VERIFICATION_DIAGNOSTICS.map((entry) => [entry.rule, entry.repairId])
+);
+var DEFAULT_REPAIR_BY_SOURCE = {
+  assertion: "repair-contract-assertion",
+  audit: "repair-audit-finding",
+  browser: "repair-browser-evidence",
+  brownfield: "repair-brownfield-drift",
+  check: "repair-contract-check",
+  "design-token": "repair-design-token-drift",
+  "style-bridge": "repair-style-bridge-drift",
+  graph: "regenerate-typed-graph",
+  interaction: "repair-interaction-contract",
+  pack: "regenerate-context-packs",
+  runtime: "repair-runtime-output"
+};
+var DEFAULT_CODE_PREFIX_BY_SOURCE = {
+  assertion: "CONTRACT",
+  audit: "AUDIT",
+  browser: "VISUAL",
+  brownfield: "ROUTE",
+  check: "CHECK",
+  "design-token": "TOKEN",
+  "style-bridge": "TOKEN",
+  graph: "GRAPH",
+  interaction: "INT",
+  pack: "CTX",
+  runtime: "RUNTIME"
+};
+function stableNumber(value) {
+  let hash = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    hash = hash * 31 + value.charCodeAt(i) >>> 0;
+  }
+  return String(hash % 900 + 100).padStart(3, "0");
+}
+function normalizedKey(value) {
+  return (value ?? "").trim().toLowerCase();
+}
+function codePrefix(input) {
+  const source = normalizedKey(input.source);
+  if (source && DEFAULT_CODE_PREFIX_BY_SOURCE[source]) return DEFAULT_CODE_PREFIX_BY_SOURCE[source];
+  const category = normalizedKey(input.category);
+  if (category.includes("accessibility")) return "A11Y";
+  if (category.includes("route")) return "ROUTE";
+  if (category.includes("token")) return "TOKEN";
+  if (category.includes("runtime")) return "RUNTIME";
+  if (category.includes("pack") || category.includes("context")) return "CTX";
+  if (category.includes("visual") || category.includes("browser")) return "VISUAL";
+  if (category.includes("interaction")) return "INT";
+  if (category.includes("contract")) return "CONTRACT";
+  return "DCTR";
+}
+function lookupById(map, input) {
+  const id = normalizedKey(input.id);
+  if (!id) return void 0;
+  if (map[id]) return map[id];
+  const source = normalizedKey(input.source);
+  const idWithoutSource = source && id.startsWith(`${source}-`) ? id.slice(source.length + 1) : id;
+  if (map[idWithoutSource]) return map[idWithoutSource];
+  const suffix = Object.keys(map).find((key) => id.endsWith(`-${key}`));
+  return suffix ? map[suffix] : void 0;
+}
+function diagnosticCode(input) {
+  const rule = normalizedKey(input.rule);
+  if (rule && CODE_BY_RULE[rule]) return CODE_BY_RULE[rule];
+  const idCode = lookupById(CODE_BY_RULE, input);
+  if (idCode) return idCode;
+  const seed = [input.source, input.rule, input.id, input.category, input.message].filter((entry) => typeof entry === "string" && entry.length > 0).join("|");
+  return `${codePrefix(input)}${stableNumber(seed)}`;
+}
+function repairId(input) {
+  const rule = normalizedKey(input.rule);
+  if (rule && REPAIR_BY_RULE[rule]) return REPAIR_BY_RULE[rule];
+  const idRepair = lookupById(REPAIR_BY_RULE, input);
+  if (idRepair) return idRepair;
+  const source = normalizedKey(input.source);
+  return DEFAULT_REPAIR_BY_SOURCE[source] ?? "repair-project-health-finding";
+}
+function compactPayload(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => {
+      if (value === void 0 || value === null) return false;
+      if (Array.isArray(value)) return value.length > 0;
+      if (typeof value === "string") return value.length > 0;
+      return true;
+    })
+  );
+}
+function deriveVerificationDiagnostic(input) {
+  const payload = compactPayload({
+    source: input.source,
+    rule: input.rule,
+    target: input.target,
+    file: input.file,
+    suggested_fix: input.suggestedFix,
+    evidence: input.evidence?.slice(0, 5)
+  });
+  const repair = { id: repairId(input) };
+  if (Object.keys(payload).length > 0) repair.payload = payload;
+  return {
+    code: diagnosticCode(input),
+    repair
+  };
+}
+
+// src/graph-anchors.ts
+function payloadRecord(payload) {
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+function payloadString(payload, key) {
+  const value = payloadRecord(payload)[key];
+  return typeof value === "string" ? value : void 0;
+}
+function slug(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_.:/-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function normalizedHaystack(finding) {
+  return [
+    finding.id,
+    finding.category,
+    finding.message,
+    finding.target,
+    finding.file,
+    finding.rule,
+    ...finding.evidence ?? []
+  ].filter((entry) => typeof entry === "string" && entry.length > 0).join("\n").toLowerCase();
+}
+function graphAnchor(snapshot, node, confidence, reason, route) {
+  const anchor = {
+    snapshot_id: snapshot.id,
+    source_hash: snapshot.source_hash,
+    node_id: node.id,
+    node_type: node.type,
+    confidence,
+    reason
+  };
+  if (route) anchor.route = route;
+  return anchor;
+}
+function routeForNode(snapshot, nodeId, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(nodeId)) return void 0;
+  visited.add(nodeId);
+  if (nodeId.startsWith("rt:")) {
+    const route2 = snapshot.nodes.find((node) => node.id === nodeId);
+    return payloadString(route2?.payload, "path") ?? nodeId.replace(/^rt:/, "");
+  }
+  const sourceNode = snapshot.nodes.find(
+    (node) => node.id === nodeId && node.type === "SourceArtifact"
+  );
+  if (sourceNode) {
+    const sourceEdges = snapshot.edges.filter(
+      (edge) => edge.relation === "NODE_DERIVED_FROM_SOURCE" && edge.dst === nodeId
+    );
+    const sortedSourceEdges = [
+      ...sourceEdges.filter((edge) => edge.src.startsWith("rt:")),
+      ...sourceEdges.filter((edge) => !edge.src.startsWith("rt:"))
+    ];
+    for (const edge of sortedSourceEdges) {
+      const route2 = routeForNode(snapshot, edge.src, visited);
+      if (route2) return route2;
+    }
+    return void 0;
+  }
+  const pageId = snapshot.nodes.find((node) => node.id === nodeId && node.type === "Page")?.id ?? snapshot.edges.find((edge) => edge.relation === "PAGE_COMPOSES_PATTERN" && edge.dst === nodeId)?.src ?? snapshot.edges.find((edge) => edge.relation === "PAGE_USES_SHELL" && edge.dst === nodeId)?.src;
+  if (!pageId) return void 0;
+  const routeEdge = snapshot.edges.find(
+    (edge) => edge.relation === "PAGE_ROUTED_AT_ROUTE" && edge.src === pageId
+  );
+  if (!routeEdge) return void 0;
+  const route = snapshot.nodes.find((node) => node.id === routeEdge.dst);
+  return payloadString(route?.payload, "path") ?? routeEdge.dst.replace(/^rt:/, "");
+}
+function findProjectNode(snapshot) {
+  return snapshot.nodes.find((node) => node.id === snapshot.project_id) ?? snapshot.nodes.find((node) => node.type === "Project");
+}
+function findLocalRuleNode(snapshot, finding) {
+  const candidates = [finding.rule, finding.target, finding.id].filter((entry) => typeof entry === "string" && entry.length > 0).map(slug);
+  if (candidates.length === 0) return null;
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "LocalRule") return false;
+    const payloadId = payloadString(node.payload, "id");
+    const ids = [node.id.replace(/^rule:/, ""), payloadId ? slug(payloadId) : null].filter(
+      (entry) => Boolean(entry)
+    );
+    return ids.some((id) => candidates.some((candidate) => id === candidate));
+  }) ?? null;
+}
+function findStyleBridgeNode(snapshot, finding) {
+  const haystack = normalizedHaystack(finding);
+  const candidates = [finding.rule, finding.target, finding.id, ...finding.evidence ?? []].filter((entry) => typeof entry === "string" && entry.length > 0).map(slug);
+  const styleBridgeNodes = snapshot.nodes.filter((node) => node.type === "StyleBridge");
+  if (styleBridgeNodes.length === 0) return null;
+  return styleBridgeNodes.find((node) => {
+    const payloadId = payloadString(node.payload, "id");
+    const payloadLabel = payloadString(node.payload, "label");
+    const ids = [
+      node.id.replace(/^bridge:/, ""),
+      payloadId ? slug(payloadId) : null,
+      payloadLabel ? slug(payloadLabel) : null
+    ].filter((entry) => Boolean(entry));
+    return ids.some(
+      (id) => candidates.some((candidate) => id === candidate || candidate.includes(id)) || haystack.includes(id.toLowerCase())
+    );
+  }) ?? (haystack.includes("style-bridge") || haystack.includes("style bridge") ? styleBridgeNodes[0] ?? null : null);
+}
+function findRouteNode(snapshot, finding) {
+  const haystack = normalizedHaystack(finding);
+  const exactTarget = finding.target?.startsWith("/") ? finding.target : null;
+  const routes = snapshot.nodes.filter((node) => node.type === "Route").map((node) => ({
+    node,
+    path: payloadString(node.payload, "path") ?? node.id.replace(/^rt:/, "")
+  })).sort((a, b) => b.path.length - a.path.length);
+  return routes.find((route) => route.path === exactTarget)?.node ?? routes.find((route) => route.path !== "/" && haystack.includes(route.path.toLowerCase()))?.node ?? null;
+}
+function findPageNode(snapshot, finding) {
+  const candidates = [finding.target, finding.id].filter((entry) => typeof entry === "string" && entry.length > 0).map(slug);
+  if (candidates.length === 0) return null;
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "Page") return false;
+    const payloadId = payloadString(node.payload, "id");
+    const payloadSection = payloadString(node.payload, "section");
+    const ids = [
+      node.id.replace(/^pg:/, ""),
+      payloadId ? slug(payloadId) : null,
+      payloadId && payloadSection ? slug(`${payloadSection}:${payloadId}`) : null
+    ].filter((entry) => Boolean(entry));
+    return ids.some((id) => candidates.some((candidate) => id === candidate));
+  }) ?? null;
+}
+function findPatternNode(snapshot, finding) {
+  const haystack = normalizedHaystack(finding);
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "Pattern") return false;
+    const payloadId = payloadString(node.payload, "id");
+    return [node.id.replace(/^pat:/, ""), payloadId].filter((entry) => Boolean(entry)).some((id) => haystack.includes(id.toLowerCase()));
+  }) ?? null;
+}
+function findSourceArtifactNode(snapshot, finding) {
+  const haystack = normalizedHaystack(finding);
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "SourceArtifact") return false;
+    const path = payloadString(node.payload, "path");
+    return path ? haystack.includes(path.toLowerCase()) : false;
+  }) ?? null;
+}
+function normalizePath3(value) {
+  return value ? value.replace(/\\/g, "/").toLowerCase() : null;
+}
+function findExactSourceArtifactNode(snapshot, finding) {
+  const findingFile = normalizePath3(finding.file);
+  if (!findingFile) return null;
+  return snapshot.nodes.find((node) => {
+    if (node.type !== "SourceArtifact") return false;
+    return normalizePath3(payloadString(node.payload, "path")) === findingFile;
+  }) ?? null;
+}
+function resolveGraphAnchorForFinding(snapshot, finding) {
+  if (!snapshot) return void 0;
+  const localRule = findLocalRuleNode(snapshot, finding);
+  if (localRule) {
+    return graphAnchor(snapshot, localRule, "exact", "finding rule matched a LocalRule node");
+  }
+  const exactSourceArtifact = findExactSourceArtifactNode(snapshot, finding);
+  if (exactSourceArtifact) {
+    return graphAnchor(
+      snapshot,
+      exactSourceArtifact,
+      "exact",
+      "finding file matched a SourceArtifact node",
+      routeForNode(snapshot, exactSourceArtifact.id)
+    );
+  }
+  const styleBridge = findStyleBridgeNode(snapshot, finding);
+  if (styleBridge) {
+    return graphAnchor(snapshot, styleBridge, "exact", "finding matched a StyleBridge node");
+  }
+  const route = findRouteNode(snapshot, finding);
+  if (route) {
+    return graphAnchor(
+      snapshot,
+      route,
+      finding.target === payloadString(route.payload, "path") ? "exact" : "inferred",
+      "finding text matched a Route node",
+      payloadString(route.payload, "path") ?? route.id.replace(/^rt:/, "")
+    );
+  }
+  const page = findPageNode(snapshot, finding);
+  if (page) {
+    return graphAnchor(
+      snapshot,
+      page,
+      "exact",
+      "finding target matched a Page node",
+      routeForNode(snapshot, page.id)
+    );
+  }
+  const pattern = findPatternNode(snapshot, finding);
+  if (pattern) {
+    return graphAnchor(
+      snapshot,
+      pattern,
+      "inferred",
+      "finding text matched a Pattern node",
+      routeForNode(snapshot, pattern.id)
+    );
+  }
+  const sourceArtifact = findSourceArtifactNode(snapshot, finding);
+  if (sourceArtifact) {
+    return graphAnchor(
+      snapshot,
+      sourceArtifact,
+      "inferred",
+      "finding evidence matched a SourceArtifact node",
+      routeForNode(snapshot, sourceArtifact.id)
+    );
+  }
+  const project = findProjectNode(snapshot);
+  return project ? graphAnchor(
+    snapshot,
+    project,
+    "fallback",
+    "finding is project-level or no specific graph node matched"
+  ) : void 0;
+}
+function anchorFindingsToGraph(snapshot, findings) {
+  if (!snapshot) return findings;
+  return findings.map((finding) => {
+    const graph = resolveGraphAnchorForFinding(snapshot, finding);
+    return graph ? { ...finding, graph } : finding;
+  });
+}
+
 // src/interactions.ts
 var INTERACTION_SIGNALS = {
   "animate-on-mount": {
@@ -755,8 +1949,9 @@ function listKnownInteractions() {
 }
 
 // src/scan.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import { extname as extname2, isAbsolute, join as join2, relative } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import { extname as extname3, isAbsolute, join as join3, relative as relative3 } from "path";
+import { decodeHTML, decodeHTMLAttribute } from "entities";
 var SCAN_REPORT_SCHEMA_URL = "https://decantr.ai/schemas/scan-report.v1.json";
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".vue", ".svelte"]);
 var STYLE_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
@@ -788,6 +1983,27 @@ var RULE_FILES = [
   "copilot-instructions.md",
   ".windsurfrules"
 ];
+var GITHUB_OWNER_RE = /^[a-z0-9](?:[a-z0-9-]{0,37}[a-z0-9])?$/i;
+var GITHUB_REPO_RE = /^[a-z0-9._-]{1,100}$/i;
+function parseHttpUrl(value) {
+  try {
+    const url = new URL(value.trim());
+    return url.protocol === "https:" || url.protocol === "http:" ? url : null;
+  } catch {
+    return null;
+  }
+}
+function githubPagesOwnerFromHostname(hostname) {
+  const [owner, domain, tld, ...extra] = hostname.toLowerCase().split(".");
+  if (extra.length > 0 || domain !== "github" || tld !== "io" || !owner) return null;
+  return GITHUB_OWNER_RE.test(owner) ? owner : null;
+}
+function normalizeGitHubPathSegment(segment, kind) {
+  if (!segment) return null;
+  const normalized = kind === "repo" ? segment.replace(/\.git$/i, "") : segment;
+  const pattern = kind === "owner" ? GITHUB_OWNER_RE : GITHUB_REPO_RE;
+  return pattern.test(normalized) ? normalized : null;
+}
 var WEB_FRAMEWORKS = /* @__PURE__ */ new Set([
   "angular",
   "astro",
@@ -806,14 +2022,14 @@ function readTextFile(path, maxBytes = MAX_FILE_READ_BYTES) {
   try {
     const stat = statSync2(path);
     if (!stat.isFile() || stat.size > maxBytes) return null;
-    return readFileSync2(path, "utf-8");
+    return readFileSync4(path, "utf-8");
   } catch {
     return null;
   }
 }
 function readPackageJson(projectRoot) {
-  const path = join2(projectRoot, "package.json");
-  if (!existsSync2(path)) return { value: null, present: false, valid: false };
+  const path = join3(projectRoot, "package.json");
+  if (!existsSync3(path)) return { value: null, present: false, valid: false };
   const content = readTextFile(path);
   if (!content) return { value: null, present: true, valid: false };
   try {
@@ -831,17 +2047,17 @@ function dependencyVersion(dependencies, names) {
   return null;
 }
 function hasAnyFile(projectRoot, paths) {
-  return paths.some((path) => existsSync2(join2(projectRoot, path)));
+  return paths.some((path) => existsSync3(join3(projectRoot, path)));
 }
 function detectPackageManager(projectRoot, pkg) {
   const declared = pkg?.packageManager?.split("@")[0];
   if (declared === "npm" || declared === "pnpm" || declared === "yarn" || declared === "bun") {
     return declared;
   }
-  if (existsSync2(join2(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync2(join2(projectRoot, "yarn.lock"))) return "yarn";
-  if (existsSync2(join2(projectRoot, "bun.lockb"))) return "bun";
-  if (existsSync2(join2(projectRoot, "package-lock.json"))) return "npm";
+  if (existsSync3(join3(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join3(projectRoot, "yarn.lock"))) return "yarn";
+  if (existsSync3(join3(projectRoot, "bun.lockb"))) return "bun";
+  if (existsSync3(join3(projectRoot, "package-lock.json"))) return "npm";
   return "unknown";
 }
 function detectPrimaryLanguage(projectRoot, packageJsonPresent) {
@@ -897,7 +2113,7 @@ function detectProject(projectRoot) {
       "tailwind.config.mjs",
       "tailwind.config.cjs"
     ]),
-    hasDecantr: existsSync2(join2(projectRoot, "decantr.essence.json")) || existsSync2(join2(projectRoot, ".decantr")) || Boolean(dependencies["@decantr/cli"] || dependencies["@decantr/css"]),
+    hasDecantr: existsSync3(join3(projectRoot, "decantr.essence.json")) || existsSync3(join3(projectRoot, ".decantr")) || Boolean(dependencies["@decantr/cli"] || dependencies["@decantr/css"]),
     packageName: typeof pkg?.name === "string" ? pkg.name : null,
     packageJsonValid: packageRead.valid,
     packageJsonPresent: packageRead.present,
@@ -913,13 +2129,13 @@ function walkFiles(projectRoot, options = {}) {
     if (files.length >= MAX_WALK_FILES) return;
     let entries;
     try {
-      entries = readdirSync2(dir);
+      entries = readdirSync3(dir);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (files.length >= MAX_WALK_FILES) return;
-      const fullPath = join2(dir, entry);
+      const fullPath = join3(dir, entry);
       let stat;
       try {
         stat = statSync2(fullPath);
@@ -932,8 +2148,8 @@ function walkFiles(projectRoot, options = {}) {
         continue;
       }
       if (!stat.isFile()) continue;
-      const rel = relative(projectRoot, fullPath).replace(/\\/g, "/");
-      const ext = extname2(entry).toLowerCase();
+      const rel = relative3(projectRoot, fullPath).replace(/\\/g, "/");
+      const ext = extname3(entry).toLowerCase();
       if (!options.extensions || options.extensions.has(ext)) {
         files.push(rel);
       }
@@ -955,7 +2171,7 @@ function segmentToRoute(segment) {
 function walkNextAppRoutes(dir, projectRoot, segments) {
   let entries;
   try {
-    entries = readdirSync2(dir);
+    entries = readdirSync3(dir);
   } catch {
     return [];
   }
@@ -965,13 +2181,13 @@ function walkNextAppRoutes(dir, projectRoot, segments) {
   if (pageFile) {
     routes.push({
       path: `/${segments.filter(Boolean).join("/")}` || "/",
-      file: relative(projectRoot, join2(dir, pageFile)).replace(/\\/g, "/"),
+      file: relative3(projectRoot, join3(dir, pageFile)).replace(/\\/g, "/"),
       hasLayout
     });
   }
   for (const entry of entries) {
     if (shouldSkipDir(entry)) continue;
-    const fullPath = join2(dir, entry);
+    const fullPath = join3(dir, entry);
     try {
       if (!statSync2(fullPath).isDirectory()) continue;
     } catch {
@@ -983,17 +2199,17 @@ function walkNextAppRoutes(dir, projectRoot, segments) {
   return routes;
 }
 function fileRouteFromPath(file, baseDir) {
-  let withoutExt = file.slice(0, -extname2(file).length);
+  let withoutExt = file.slice(0, -extname3(file).length);
   if (withoutExt.endsWith("/index")) withoutExt = withoutExt.slice(0, -"/index".length);
   withoutExt = withoutExt.replace(new RegExp(`^${baseDir.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`), "");
   const parts = withoutExt.split("/").filter(Boolean).map((part) => segmentToRoute(part)).filter(Boolean);
   return `/${parts.join("/")}` || "/";
 }
 function scanFileRoutes(projectRoot, baseDir, extensions = PAGE_EXTENSIONS) {
-  const fullBase = join2(projectRoot, baseDir);
-  if (!existsSync2(fullBase)) return [];
+  const fullBase = join3(projectRoot, baseDir);
+  if (!existsSync3(fullBase)) return [];
   return walkFiles(fullBase, { extensions }).map((file) => {
-    const rel = relative(projectRoot, join2(fullBase, file)).replace(/\\/g, "/");
+    const rel = relative3(projectRoot, join3(fullBase, file)).replace(/\\/g, "/");
     return { path: fileRouteFromPath(rel, baseDir), file: rel, hasLayout: false };
   });
 }
@@ -1002,7 +2218,7 @@ function scanReactRouter(projectRoot) {
   const routes = /* @__PURE__ */ new Map();
   let hashRouting = false;
   for (const file of files) {
-    const content = readTextFile(join2(projectRoot, file));
+    const content = readTextFile(join3(projectRoot, file));
     if (!content) continue;
     if (content.includes("HashRouter") || content.includes("createHashRouter")) hashRouting = true;
     const jsxRouteRegex = /<Route\b[^>]*\bpath\s*=\s*["']([^"']+)["']/g;
@@ -1021,7 +2237,7 @@ function scanReactRouter(projectRoot) {
 }
 function scanRoutes(projectRoot, detection) {
   const appRoutes = ["src/app", "app"].flatMap(
-    (dir) => existsSync2(join2(projectRoot, dir)) ? walkNextAppRoutes(join2(projectRoot, dir), projectRoot, []) : []
+    (dir) => existsSync3(join3(projectRoot, dir)) ? walkNextAppRoutes(join3(projectRoot, dir), projectRoot, []) : []
   );
   const pagesRoutes = ["src/pages", "pages"].flatMap((dir) => scanFileRoutes(projectRoot, dir));
   if (detection.framework === "nextjs") {
@@ -1044,10 +2260,10 @@ function scanRoutes(projectRoot, detection) {
   const reactRouter = scanReactRouter(projectRoot);
   if (reactRouter.routes.length > 0) return { strategy: "react-router", routes: reactRouter.routes };
   if (pagesRoutes.length > 0) return { strategy: "pages-router", routes: pagesRoutes };
-  if (existsSync2(join2(projectRoot, "index.html"))) {
+  if (existsSync3(join3(projectRoot, "index.html"))) {
     return { strategy: "static-html", routes: [{ path: "/", file: "index.html", hasLayout: false }] };
   }
-  if (existsSync2(join2(projectRoot, "docs", "index.html"))) {
+  if (existsSync3(join3(projectRoot, "docs", "index.html"))) {
     return { strategy: "static-html", routes: [{ path: "/", file: "docs/index.html", hasLayout: false }] };
   }
   return { strategy: "none", routes: [] };
@@ -1089,12 +2305,12 @@ function scanStyling(projectRoot, detection) {
   let configFile = null;
   let approach = "unknown";
   const tailwindConfig = ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.mjs", "tailwind.config.cjs"].find(
-    (file) => existsSync2(join2(projectRoot, file))
+    (file) => existsSync3(join3(projectRoot, file))
   );
   if (tailwindConfig || deps.tailwindcss) {
     approach = "tailwind";
     configFile = tailwindConfig ?? "package.json";
-  } else if (deps["@decantr/css"] || existsSync2(join2(projectRoot, "src/styles/tokens.css")) && existsSync2(join2(projectRoot, "src/styles/treatments.css"))) {
+  } else if (deps["@decantr/css"] || existsSync3(join3(projectRoot, "src/styles/tokens.css")) && existsSync3(join3(projectRoot, "src/styles/treatments.css"))) {
     approach = "decantr-css";
     configFile = deps["@decantr/css"] ? "package.json" : "src/styles/tokens.css";
   } else if (deps.bootstrap) {
@@ -1112,7 +2328,7 @@ function scanStyling(projectRoot, detection) {
     approach = "css";
   }
   for (const file of cssFiles.slice(0, 80)) {
-    const content = readTextFile(join2(projectRoot, file), 256 * 1024);
+    const content = readTextFile(join3(projectRoot, file), 256 * 1024);
     if (!content) continue;
     const evidence = extractCssEvidence(content);
     cssVariableCount += evidence.variables;
@@ -1130,7 +2346,7 @@ function scanStyling(projectRoot, detection) {
   };
 }
 function findAssistantRules(projectRoot) {
-  return RULE_FILES.filter((file) => existsSync2(join2(projectRoot, file)));
+  return RULE_FILES.filter((file) => existsSync3(join3(projectRoot, file)));
 }
 function scanStaticHosting(projectRoot, detection) {
   const packageRead = readPackageJson(projectRoot);
@@ -1139,25 +2355,22 @@ function scanStaticHosting(projectRoot, detection) {
   const homepageUrl = typeof pkg?.homepage === "string" ? pkg.homepage : null;
   let basePath = null;
   let hashRouting = false;
-  if (homepageUrl?.includes("github.io")) {
+  const homepage = homepageUrl ? parseHttpUrl(homepageUrl) : null;
+  if (homepage && githubPagesOwnerFromHostname(homepage.hostname)) {
     evidence.push("package.json homepage points at GitHub Pages");
-    try {
-      const url = new URL(homepageUrl);
-      basePath = url.pathname && url.pathname !== "/" ? url.pathname : null;
-    } catch {
-    }
+    basePath = homepage.pathname && homepage.pathname !== "/" ? homepage.pathname : null;
   }
   if (detection.dependencies["gh-pages"] || pkg?.scripts?.deploy?.includes("gh-pages")) {
     evidence.push("package scripts or dependencies reference gh-pages");
   }
-  if (existsSync2(join2(projectRoot, "docs", "index.html"))) evidence.push("docs/index.html can serve GitHub Pages");
-  if (existsSync2(join2(projectRoot, "404.html")) || existsSync2(join2(projectRoot, "docs", "404.html"))) {
+  if (existsSync3(join3(projectRoot, "docs", "index.html"))) evidence.push("docs/index.html can serve GitHub Pages");
+  if (existsSync3(join3(projectRoot, "404.html")) || existsSync3(join3(projectRoot, "docs", "404.html"))) {
     evidence.push("404.html fallback is present");
   }
-  const workflowDir = join2(projectRoot, ".github", "workflows");
-  if (existsSync2(workflowDir)) {
+  const workflowDir = join3(projectRoot, ".github", "workflows");
+  if (existsSync3(workflowDir)) {
     for (const file of walkFiles(workflowDir, { extensions: /* @__PURE__ */ new Set([".yml", ".yaml"]) }).slice(0, 20)) {
-      const content = readTextFile(join2(workflowDir, file));
+      const content = readTextFile(join3(workflowDir, file));
       if (content && /pages|gh-pages|upload-pages-artifact|deploy-pages/i.test(content)) {
         evidence.push(`GitHub Pages workflow hint: .github/workflows/${file}`);
         break;
@@ -1166,7 +2379,7 @@ function scanStaticHosting(projectRoot, detection) {
   }
   const sourceFiles = walkFiles(projectRoot, { extensions: SOURCE_EXTENSIONS });
   for (const file of sourceFiles.slice(0, 200)) {
-    const content = readTextFile(join2(projectRoot, file), 128 * 1024);
+    const content = readTextFile(join3(projectRoot, file), 128 * 1024);
     if (!content) continue;
     if (content.includes("HashRouter") || content.includes("createHashRouter")) {
       hashRouting = true;
@@ -1175,7 +2388,7 @@ function scanStaticHosting(projectRoot, detection) {
     }
   }
   for (const config of ["vite.config.ts", "vite.config.js", "vite.config.mjs"]) {
-    const content = readTextFile(join2(projectRoot, config), 128 * 1024);
+    const content = readTextFile(join3(projectRoot, config), 128 * 1024);
     const baseMatch = content?.match(/\bbase\s*:\s*['"]([^'"]+)['"]/);
     if (baseMatch?.[1]) {
       basePath = baseMatch[1];
@@ -1482,12 +2695,15 @@ function createUnavailableScanReport(input) {
     }
   };
 }
-function decodeHtml(value) {
-  return value.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").trim();
+function decodeHtmlText(value) {
+  return decodeHTML(value).replace(/\s+/g, " ").trim();
+}
+function decodeHtmlAttributeValue(value) {
+  return decodeHTMLAttribute(value).trim();
 }
 function extractHtmlAttribute(tag, attr) {
   const match = tag.match(new RegExp(`${attr}\\s*=\\s*["']([^"']+)["']`, "i"));
-  return match?.[1] ? decodeHtml(match[1]) : null;
+  return match?.[1] ? decodeHtmlAttributeValue(match[1]) : null;
 }
 async function probePublishedSite(url, options = {}) {
   const fetchImpl = options.fetchImpl ?? fetch;
@@ -1519,7 +2735,7 @@ async function probePublishedSite(url, options = {}) {
       checked: true,
       reachable: response.ok,
       status: response.status,
-      title: titleMatch?.[1] ? decodeHtml(titleMatch[1].replace(/\s+/g, " ")) : null,
+      title: titleMatch?.[1] ? decodeHtmlText(titleMatch[1]) : null,
       description: descriptionTag ? extractHtmlAttribute(descriptionTag, "content") : null,
       canonicalUrl: canonicalTag ? extractHtmlAttribute(canonicalTag, "href") : null,
       assetHints: {
@@ -1550,22 +2766,21 @@ async function probePublishedSite(url, options = {}) {
   }
 }
 function resolveGitHubScanInput(input) {
-  let url;
-  try {
-    url = new URL(input.trim());
-  } catch {
+  const url = parseHttpUrl(input);
+  if (!url) {
     throw new Error("Enter a valid GitHub repository URL or GitHub Pages URL.");
   }
-  if (url.protocol !== "https:" && url.protocol !== "http:") {
-    throw new Error("Scan URLs must use http or https.");
-  }
   const host = url.hostname.toLowerCase();
   if (host === "github.com" || host === "www.github.com") {
-    const [owner, repoSegment] = url.pathname.split("/").filter(Boolean);
+    const [ownerSegment, repoSegment] = url.pathname.split("/").filter(Boolean);
+    const owner = normalizeGitHubPathSegment(ownerSegment, "owner");
+    const repo = normalizeGitHubPathSegment(repoSegment, "repo");
     if (!owner || !repoSegment) {
       throw new Error("GitHub repository URLs must include owner and repository.");
     }
-    const repo = repoSegment.replace(/\.git$/, "");
+    if (!repo) {
+      throw new Error("GitHub repository URLs must include a valid owner and repository.");
+    }
     return {
       inputKind: "github-repo",
       normalizedInput: `https://github.com/${owner}/${repo}`,
@@ -1578,18 +2793,21 @@ function resolveGitHubScanInput(input) {
       warnings: url.pathname.split("/").filter(Boolean).length > 2 ? ["Extra GitHub URL path segments were ignored."] : []
     };
   }
-  if (host.endsWith(".github.io")) {
-    const owner = host.slice(0, -".github.io".length);
+  const pagesOwner = githubPagesOwnerFromHostname(host);
+  if (pagesOwner) {
     const segments = url.pathname.split("/").filter(Boolean);
-    const repo = segments[0] ?? `${owner}.github.io`;
-    const publishedSiteUrl = segments[0] ? `https://${owner}.github.io/${repo}/` : `https://${owner}.github.io/`;
+    const repo = segments[0] ? normalizeGitHubPathSegment(segments[0], "repo") : `${pagesOwner}.github.io`;
+    if (!repo) {
+      throw new Error("GitHub Pages URLs must include a valid owner and repository path.");
+    }
+    const publishedSiteUrl = segments[0] ? `https://${pagesOwner}.github.io/${repo}/` : `https://${pagesOwner}.github.io/`;
     return {
       inputKind: "github-pages",
       normalizedInput: publishedSiteUrl,
       repository: {
-        owner,
+        owner: pagesOwner,
         repo,
-        url: `https://github.com/${owner}/${repo}`
+        url: `https://github.com/${pagesOwner}/${repo}`
       },
       publishedSiteUrl,
       warnings: segments.length > 1 ? ["Only the first GitHub Pages path segment was used to infer the repository."] : []
@@ -1615,16 +2833,16 @@ function hashString(value) {
   return createHash("sha256").update(value).digest("hex").slice(0, 16);
 }
 function hashFile(path) {
-  if (!existsSync3(path)) return null;
+  if (!existsSync4(path)) return null;
   try {
-    return createHash("sha256").update(readFileSync3(path)).digest("hex");
+    return createHash("sha256").update(readFileSync5(path)).digest("hex");
   } catch {
     return null;
   }
 }
 function provenanceEntry(projectRoot, relativePath) {
-  const path = join3(projectRoot, relativePath);
-  if (!existsSync3(path)) {
+  const path = join4(projectRoot, relativePath);
+  if (!existsSync4(path)) {
     return {
       path: relativePath,
       present: false,
@@ -1646,8 +2864,8 @@ function provenanceEntry(projectRoot, relativePath) {
   };
 }
 function provenanceForPath(projectRoot, path) {
-  const rel = isAbsolute2(path) ? relative2(projectRoot, path).replace(/\\/g, "/") : path;
-  return provenanceEntry(projectRoot, rel && !rel.startsWith("..") ? rel : basename(path));
+  const rel = isAbsolute2(path) ? relative4(projectRoot, path).replace(/\\/g, "/") : path;
+  return provenanceEntry(projectRoot, rel && !rel.startsWith("..") ? rel : basename2(path));
 }
 function redactEvidenceText(projectRoot, value) {
   const normalizedRoot = projectRoot.replace(/\\/g, "/");
@@ -1660,6 +2878,116 @@ function redactEvidenceText(projectRoot, value) {
 function redactEvidenceList(projectRoot, evidence) {
   return evidence.map((entry) => redactEvidenceText(projectRoot, entry));
 }
+function redactEvidenceValue(projectRoot, value) {
+  if (typeof value === "string") return redactEvidenceText(projectRoot, value);
+  if (Array.isArray(value)) return value.map((entry) => redactEvidenceValue(projectRoot, entry));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        redactEvidenceValue(projectRoot, entry)
+      ])
+    );
+  }
+  return value;
+}
+function redactRepairAction(projectRoot, repair) {
+  if (!repair) return void 0;
+  return {
+    id: repair.id,
+    ...repair.payload ? { payload: redactEvidenceValue(projectRoot, repair.payload) } : {}
+  };
+}
+function evidenceRepairPlanAction(projectRoot, finding) {
+  const repair = redactRepairAction(projectRoot, finding.repair);
+  const repairId2 = repair?.id ?? "manual-repair";
+  if (repairId2 === "regenerate-typed-graph" || finding.source === "graph") {
+    return {
+      id: repairId2,
+      kind: "regenerate_artifact",
+      target: ".decantr/graph",
+      description: "Regenerate typed Contract graph artifacts from current project sources.",
+      ...repair?.payload ? { payload: repair.payload } : {}
+    };
+  }
+  if (repairId2 === "import-existing-component") {
+    return {
+      id: repairId2,
+      kind: "replace_duplicate_with_import",
+      target: finding.file ? redactEvidenceText(projectRoot, finding.file) : finding.target ? redactEvidenceText(projectRoot, finding.target) : null,
+      description: "Remove the locally redeclared UI primitive and import the existing project-owned component.",
+      ...repair?.payload ? { payload: repair.payload } : {}
+    };
+  }
+  if (repairId2 === "replace-raw-control-with-local-component") {
+    return {
+      id: repairId2,
+      kind: "replace_raw_control_with_component",
+      target: finding.file ? redactEvidenceText(projectRoot, finding.file) : finding.target ? redactEvidenceText(projectRoot, finding.target) : null,
+      description: "Replace the raw JSX control with the existing project-owned primitive component.",
+      ...repair?.payload ? { payload: repair.payload } : {}
+    };
+  }
+  return {
+    id: repairId2,
+    kind: "manual_repair",
+    target: finding.file ? redactEvidenceText(projectRoot, finding.file) : finding.target ? redactEvidenceText(projectRoot, finding.target) : null,
+    description: finding.suggestedFix ?? finding.remediation.summary,
+    ...repair?.payload ? { payload: repair.payload } : {}
+  };
+}
+function evidenceRepairReadTargets(projectRoot, finding) {
+  const targets = /* @__PURE__ */ new Set(["DECANTR.md", "decantr.essence.json"]);
+  if (finding.source === "graph") {
+    targets.add(".decantr/graph/graph.manifest.json");
+    targets.add(".decantr/graph/graph.snapshot.json");
+    targets.add(".decantr/graph/graph.diff.json");
+    targets.add(".decantr/graph/snapshots/");
+  }
+  if (finding.source === "style-bridge") {
+    targets.add(".decantr/style-bridge.json");
+  }
+  if (finding.source === "pack" || finding.source === "assertion") {
+    targets.add(".decantr/context/pack-manifest.json");
+  }
+  if (finding.graph?.node_id) {
+    targets.add(".decantr/graph/contract-capsule.json");
+  }
+  if (finding.file) targets.add(redactEvidenceText(projectRoot, finding.file));
+  if (finding.target && !finding.target.startsWith("http")) {
+    targets.add(redactEvidenceText(projectRoot, finding.target));
+  }
+  return [...targets];
+}
+function buildProjectHealthRepairPlan(projectRoot, finding) {
+  return {
+    id: `repair-plan:${finding.id}`,
+    findingId: finding.id,
+    diagnosticCode: finding.code ?? null,
+    repairId: finding.repair?.id ?? null,
+    severity: finding.severity,
+    source: finding.source,
+    category: finding.category,
+    graphAnchor: finding.graph ?? null,
+    actions: [evidenceRepairPlanAction(projectRoot, finding)],
+    evidence: redactEvidenceList(projectRoot, finding.evidence).map((entry, index) => ({
+      id: `evidence:${finding.id}:${index + 1}`,
+      text: entry
+    })),
+    readTargets: evidenceRepairReadTargets(projectRoot, finding),
+    preserve: [
+      "existing framework, routing, and styling system",
+      "existing production behavior unrelated to this finding",
+      "accepted local law, style bridge mappings, and graph anchors"
+    ],
+    avoid: [
+      "rewriting unrelated routes",
+      "replacing the app styling system",
+      "regenerating Decantr artifacts unless the finding is about generated context or graph freshness"
+    ],
+    commands: finding.remediation.commands
+  };
+}
 function assertion(input) {
   return {
     status: "passed",
@@ -1670,7 +2998,7 @@ function createContractAssertions(projectRoot, audit) {
   const assertions = [];
   const essence = audit?.essence;
   const v4 = essence && isV4(essence) ? essence : null;
-  const contextDir = join3(projectRoot, ".decantr", "context");
+  const contextDir = join4(projectRoot, ".decantr", "context");
   const packManifest = audit?.packManifest ?? null;
   assertions.push(
     assertion({
@@ -1680,7 +3008,7 @@ function createContractAssertions(projectRoot, audit) {
       rule: "essence-present",
       status: essence ? "passed" : "failed",
       message: essence ? "Decantr Essence contract is present." : "No Decantr Essence contract was found.",
-      evidence: [redactEvidenceText(projectRoot, join3(projectRoot, "decantr.essence.json"))],
+      evidence: [redactEvidenceText(projectRoot, join4(projectRoot, "decantr.essence.json"))],
       suggestedFix: essence ? void 0 : "Run `decantr init` or restore decantr.essence.json."
     })
   );
@@ -1752,7 +3080,7 @@ function createContractAssertions(projectRoot, audit) {
       rule: "pack-manifest-present",
       status: packManifest ? "passed" : "failed",
       message: packManifest ? "Compiled execution pack manifest is present." : "Compiled execution pack manifest is missing.",
-      evidence: [redactEvidenceText(projectRoot, join3(contextDir, "pack-manifest.json"))],
+      evidence: [redactEvidenceText(projectRoot, join4(contextDir, "pack-manifest.json"))],
       suggestedFix: packManifest ? void 0 : "Run `decantr registry compile-packs decantr.essence.json --write-context` to hydrate the full context pack bundle."
     })
   );
@@ -1764,21 +3092,21 @@ function createContractAssertions(projectRoot, audit) {
       rule: "review-pack-present",
       status: audit?.reviewPack ? "passed" : "failed",
       message: audit?.reviewPack ? "Compiled review pack is present." : "Compiled review pack is missing.",
-      evidence: [redactEvidenceText(projectRoot, join3(contextDir, "review-pack.json"))],
+      evidence: [redactEvidenceText(projectRoot, join4(contextDir, "review-pack.json"))],
       suggestedFix: audit?.reviewPack ? void 0 : "Run `decantr registry compile-packs decantr.essence.json --write-context` so critique has the compiled review contract."
     })
   );
-  const tokensPath = join3(projectRoot, "src", "styles", "tokens.css");
+  const tokensPath = join4(projectRoot, "src", "styles", "tokens.css");
   assertions.push(
     assertion({
       id: "contract.design-token.tokens-file",
       category: "design-token",
-      severity: existsSync3(tokensPath) ? "info" : "warn",
+      severity: existsSync4(tokensPath) ? "info" : "warn",
       rule: "tokens-file-present",
-      status: existsSync3(tokensPath) ? "passed" : "failed",
-      message: existsSync3(tokensPath) ? "Decantr token CSS file is present." : "Decantr token CSS file was not found.",
+      status: existsSync4(tokensPath) ? "passed" : "failed",
+      message: existsSync4(tokensPath) ? "Decantr token CSS file is present." : "Decantr token CSS file was not found.",
       evidence: [redactEvidenceText(projectRoot, tokensPath)],
-      suggestedFix: existsSync3(tokensPath) ? void 0 : "Run `decantr refresh` or map Decantr tokens into the existing styling system."
+      suggestedFix: existsSync4(tokensPath) ? void 0 : "Run `decantr refresh` or map Decantr tokens into the existing styling system."
     })
   );
   return assertions;
@@ -1797,7 +3125,7 @@ function createEvidenceBundle(input) {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     project: {
       id: projectId,
-      rootLabel: basename(input.projectRoot) || "project"
+      rootLabel: basename2(input.projectRoot) || "project"
     },
     toolchain: {
       verifierVersion: input.verifierVersion ?? null
@@ -1826,12 +3154,17 @@ function createEvidenceBundle(input) {
       essence: provenanceEntry(input.projectRoot, "decantr.essence.json"),
       packManifest: provenanceEntry(input.projectRoot, ".decantr/context/pack-manifest.json"),
       reviewPack: provenanceEntry(input.projectRoot, ".decantr/context/review-pack.json"),
+      graphSnapshot: provenanceEntry(input.projectRoot, ".decantr/graph/graph.snapshot.json"),
+      graphManifest: provenanceEntry(input.projectRoot, ".decantr/graph/graph.manifest.json"),
+      graphDiff: provenanceEntry(input.projectRoot, ".decantr/graph/graph.diff.json"),
+      contractCapsule: provenanceEntry(input.projectRoot, ".decantr/graph/contract-capsule.json"),
       ...input.workspaceConfigPath ? { workspaceConfig: provenanceForPath(input.projectRoot, input.workspaceConfigPath) } : {},
       ...input.designTokensPath ? { designTokens: provenanceForPath(input.projectRoot, input.designTokensPath) } : {}
     },
     assertions,
     findings: input.report.findings.map((finding) => ({
       id: finding.id,
+      code: finding.code,
       source: finding.source,
       category: finding.category,
       severity: finding.severity,
@@ -1840,6 +3173,9 @@ function createEvidenceBundle(input) {
       target: finding.target ? redactEvidenceText(input.projectRoot, finding.target) : void 0,
       rule: finding.rule,
       suggestedFix: finding.suggestedFix,
+      graph: finding.graph,
+      repair: redactRepairAction(input.projectRoot, finding.repair),
+      repairPlan: buildProjectHealthRepairPlan(input.projectRoot, finding),
       remediationSummary: finding.remediation.summary,
       commands: finding.remediation.commands,
       promptCommand: `decantr health --prompt ${finding.id}`
@@ -1883,21 +3219,21 @@ function scoreRatio(numerator, denominator) {
   return Math.min(5, Math.max(1, Math.round(numerator / denominator * 5)));
 }
 function readJsonIfExists(path) {
-  if (!existsSync3(path)) return null;
+  if (!existsSync4(path)) return null;
   try {
-    return JSON.parse(readFileSync3(path, "utf-8"));
+    return JSON.parse(readFileSync5(path, "utf-8"));
   } catch {
     return null;
   }
 }
 function loadReviewPack(projectRoot) {
   return readJsonIfExists(
-    join3(projectRoot, ".decantr", "context", "review-pack.json")
+    join4(projectRoot, ".decantr", "context", "review-pack.json")
   );
 }
 function loadPackManifest(projectRoot) {
   return readJsonIfExists(
-    join3(projectRoot, ".decantr", "context", "pack-manifest.json")
+    join4(projectRoot, ".decantr", "context", "pack-manifest.json")
   );
 }
 function collectPackManifestReferences(packManifest) {
@@ -1946,14 +3282,14 @@ function collectPackManifestReferences(packManifest) {
 }
 function collectMissingPackManifestFiles(projectRoot, packManifest = loadPackManifest(projectRoot)) {
   if (!packManifest) return [];
-  const contextDir = join3(projectRoot, ".decantr", "context");
+  const contextDir = join4(projectRoot, ".decantr", "context");
   const missing = [];
   for (const reference of collectPackManifestReferences(packManifest)) {
     for (const field of ["markdown", "json"]) {
       const fileName = reference[field];
       if (!fileName) continue;
-      const absolutePath = join3(contextDir, fileName);
-      if (existsSync3(absolutePath)) continue;
+      const absolutePath = join4(contextDir, fileName);
+      if (existsSync4(absolutePath)) continue;
       missing.push({
         entryId: reference.entryId,
         kind: reference.kind,
@@ -1967,13 +3303,13 @@ function collectMissingPackManifestFiles(projectRoot, packManifest = loadPackMan
 }
 function readTextIfExists(path) {
   try {
-    return existsSync3(path) ? readFileSync3(path, "utf-8") : "";
+    return existsSync4(path) ? readFileSync5(path, "utf-8") : "";
   } catch {
     return "";
   }
 }
 function readProjectAdoptionMode(projectRoot) {
-  const projectJson = readJsonIfExists(join3(projectRoot, ".decantr", "project.json"));
+  const projectJson = readJsonIfExists(join4(projectRoot, ".decantr", "project.json"));
   const adoptionMode = projectJson?.initialized?.adoptionMode;
   return typeof adoptionMode === "string" ? adoptionMode : null;
 }
@@ -2059,7 +3395,7 @@ function collectProjectSourceFiles(projectRoot) {
     "hooks",
     "providers",
     "server"
-  ].map((dir) => join3(projectRoot, dir)).filter((dir) => existsSync3(dir));
+  ].map((dir) => join4(projectRoot, dir)).filter((dir) => existsSync4(dir));
   const rootFileCandidates = [
     "middleware.ts",
     "middleware.tsx",
@@ -2073,7 +3409,7 @@ function collectProjectSourceFiles(projectRoot) {
     "proxy.jsx",
     "proxy.mts",
     "proxy.cts"
-  ].map((file) => join3(projectRoot, file)).filter((file) => existsSync3(file));
+  ].map((file) => join4(projectRoot, file)).filter((file) => existsSync4(file));
   const files = /* @__PURE__ */ new Set();
   const ignoredDirNames = /* @__PURE__ */ new Set([
     "node_modules",
@@ -2084,9 +3420,9 @@ function collectProjectSourceFiles(projectRoot) {
     "coverage"
   ]);
   const walk = (dir) => {
-    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join3(dir, entry.name);
+      const absolutePath = join4(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
         continue;
@@ -2116,8 +3452,8 @@ function buildSourceAuditEvidence(summary, bucket, label) {
 function isAuditableStyleFile(filePath) {
   return /\.css$/i.test(filePath);
 }
-function collectProjectStyleFiles(projectRoot) {
-  const candidates = ["src", "app", "styles"].map((dir) => join3(projectRoot, dir)).filter((dir) => existsSync3(dir));
+function collectProjectStyleFiles2(projectRoot) {
+  const candidates = ["src", "app", "styles"].map((dir) => join4(projectRoot, dir)).filter((dir) => existsSync4(dir));
   const files = /* @__PURE__ */ new Set();
   const ignoredDirNames = /* @__PURE__ */ new Set([
     "node_modules",
@@ -2128,9 +3464,9 @@ function collectProjectStyleFiles(projectRoot) {
     "coverage"
   ]);
   const walk = (dir) => {
-    for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+    for (const entry of readdirSync4(dir, { withFileTypes: true })) {
       if (ignoredDirNames.has(entry.name)) continue;
-      const absolutePath = join3(dir, entry.name);
+      const absolutePath = join4(dir, entry.name);
       if (entry.isDirectory()) {
         walk(absolutePath);
         continue;
@@ -2158,15 +3494,15 @@ function countReducedMotionSignals(code) {
   return patterns.reduce((count, pattern) => count + (pattern.test(code) ? 1 : 0), 0);
 }
 function hasModuleDirective(filePath, code, directive) {
-  const sourceFile = ts.createSourceFile(
+  const sourceFile = ts3.createSourceFile(
     filePath,
     code,
-    ts.ScriptTarget.Latest,
+    ts3.ScriptTarget.Latest,
     true,
     getScriptKind(filePath)
   );
   for (const statement of sourceFile.statements) {
-    if (ts.isExpressionStatement(statement) && ts.isStringLiteralLike(statement.expression)) {
+    if (ts3.isExpressionStatement(statement) && ts3.isStringLiteralLike(statement.expression)) {
       if (statement.expression.text === directive) {
         return true;
       }
@@ -2182,20 +3518,20 @@ function importDeclarationHasRuntimeBinding(statement) {
   if (clause.isTypeOnly) return false;
   if (clause.name) return true;
   if (!clause.namedBindings) return true;
-  if (ts.isNamespaceImport(clause.namedBindings)) return true;
+  if (ts3.isNamespaceImport(clause.namedBindings)) return true;
   return clause.namedBindings.elements.some((element) => !element.isTypeOnly);
 }
 function collectRuntimeImportSpecifiers(entry) {
-  const sourceFile = ts.createSourceFile(
+  const sourceFile = ts3.createSourceFile(
     entry.relativePath,
     entry.code,
-    ts.ScriptTarget.Latest,
+    ts3.ScriptTarget.Latest,
     true,
     getScriptKind(entry.relativePath)
   );
   const specifiers = [];
   for (const statement of sourceFile.statements) {
-    if (ts.isImportDeclaration(statement) && ts.isStringLiteralLike(statement.moduleSpecifier) && importDeclarationHasRuntimeBinding(statement)) {
+    if (ts3.isImportDeclaration(statement) && ts3.isStringLiteralLike(statement.moduleSpecifier) && importDeclarationHasRuntimeBinding(statement)) {
       specifiers.push(statement.moduleSpecifier.text);
     }
   }
@@ -2204,7 +3540,7 @@ function collectRuntimeImportSpecifiers(entry) {
 function resolveSourceImportTarget(projectRoot, sourceAbsolutePath, specifier) {
   let basePath = null;
   if (specifier.startsWith("@/")) {
-    basePath = join3(projectRoot, "src", specifier.slice(2));
+    basePath = join4(projectRoot, "src", specifier.slice(2));
   } else if (specifier.startsWith("./") || specifier.startsWith("../")) {
     basePath = resolve(dirname(sourceAbsolutePath), specifier);
   }
@@ -2217,14 +3553,14 @@ function resolveSourceImportTarget(projectRoot, sourceAbsolutePath, specifier) {
     `${basePath}.jsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join3(basePath, "index.ts"),
-    join3(basePath, "index.tsx"),
-    join3(basePath, "index.js"),
-    join3(basePath, "index.jsx")
+    join4(basePath, "index.ts"),
+    join4(basePath, "index.tsx"),
+    join4(basePath, "index.js"),
+    join4(basePath, "index.jsx")
   ];
   for (const candidate of candidates) {
-    if (existsSync3(candidate) && isAuditableSourceFile(candidate)) {
-      return relative2(projectRoot, candidate) || candidate;
+    if (existsSync4(candidate) && isAuditableSourceFile(candidate)) {
+      return relative4(projectRoot, candidate) || candidate;
     }
   }
   return null;
@@ -2269,12 +3605,11 @@ function isClientAuthHeaderSource(relativePath, code, clientReachableFiles) {
   }
   return /(?:^|\/)(?:components|routes|pages|hooks|providers)\//i.test(normalized);
 }
-function auditProjectSourceTree(projectRoot) {
-  const sourceFiles = collectProjectSourceFiles(projectRoot);
+function auditProjectSourceTree(projectRoot, sourceFiles = collectProjectSourceFiles(projectRoot)) {
   const sourceEntries = sourceFiles.map((sourceFile) => ({
     absolutePath: sourceFile,
-    relativePath: relative2(projectRoot, sourceFile) || sourceFile,
-    code: readFileSync3(sourceFile, "utf-8")
+    relativePath: relative4(projectRoot, sourceFile) || sourceFile,
+    code: readFileSync5(sourceFile, "utf-8")
   })).filter((entry) => !isNonProductionSourceAuditFile(entry.relativePath));
   const clientReachableFiles = collectClientReachableSourceFiles(projectRoot, sourceEntries);
   const summary = {
@@ -2580,15 +3915,15 @@ function auditProjectSourceTree(projectRoot) {
   return summary;
 }
 function auditProjectStyleContracts(projectRoot) {
-  const styleFiles = collectProjectStyleFiles(projectRoot);
+  const styleFiles = collectProjectStyleFiles2(projectRoot);
   const summary = {
     filesChecked: styleFiles.length,
     focusVisibleSignals: createSourceAuditBucket(),
     reducedMotionSignals: createSourceAuditBucket()
   };
   for (const styleFile of styleFiles) {
-    const relativePath = relative2(projectRoot, styleFile) || styleFile;
-    const css = readFileSync3(styleFile, "utf-8");
+    const relativePath = relative4(projectRoot, styleFile) || styleFile;
+    const css = readFileSync5(styleFile, "utf-8");
     recordSourceAudit(summary.focusVisibleSignals, relativePath, countFocusVisibleSignals(css));
     recordSourceAudit(summary.reducedMotionSignals, relativePath, countReducedMotionSignals(css));
   }
@@ -2597,15 +3932,15 @@ function auditProjectStyleContracts(projectRoot) {
 function buildRegistryContext(projectRoot) {
   const themeRegistry = /* @__PURE__ */ new Map();
   const patternRegistry = /* @__PURE__ */ new Map();
-  const cacheDir = join3(projectRoot, ".decantr", "cache");
-  const customDir = join3(projectRoot, ".decantr", "custom");
-  const cachedThemesDir = join3(cacheDir, "@official", "themes");
+  const cacheDir = join4(projectRoot, ".decantr", "cache");
+  const customDir = join4(projectRoot, ".decantr", "custom");
+  const cachedThemesDir = join4(cacheDir, "@official", "themes");
   try {
-    if (existsSync3(cachedThemesDir)) {
-      for (const file of readdirSync3(cachedThemesDir).filter(
+    if (existsSync4(cachedThemesDir)) {
+      for (const file of readdirSync4(cachedThemesDir).filter(
         (name) => name.endsWith(".json") && name !== "index.json"
       )) {
-        const data = JSON.parse(readFileSync3(join3(cachedThemesDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync5(join4(cachedThemesDir, file), "utf-8"));
         if (data.id && !themeRegistry.has(data.id)) {
           themeRegistry.set(data.id, { modes: data.modes || ["light", "dark"] });
         }
@@ -2613,11 +3948,11 @@ function buildRegistryContext(projectRoot) {
     }
   } catch {
   }
-  const customThemesDir = join3(customDir, "themes");
+  const customThemesDir = join4(customDir, "themes");
   try {
-    if (existsSync3(customThemesDir)) {
-      for (const file of readdirSync3(customThemesDir).filter((name) => name.endsWith(".json"))) {
-        const data = JSON.parse(readFileSync3(join3(customThemesDir, file), "utf-8"));
+    if (existsSync4(customThemesDir)) {
+      for (const file of readdirSync4(customThemesDir).filter((name) => name.endsWith(".json"))) {
+        const data = JSON.parse(readFileSync5(join4(customThemesDir, file), "utf-8"));
         if (data.id) {
           themeRegistry.set(`custom:${data.id}`, { modes: data.modes || ["light", "dark"] });
         }
@@ -2625,13 +3960,13 @@ function buildRegistryContext(projectRoot) {
     }
   } catch {
   }
-  const cachedPatternsDir = join3(cacheDir, "@official", "patterns");
+  const cachedPatternsDir = join4(cacheDir, "@official", "patterns");
   try {
-    if (existsSync3(cachedPatternsDir)) {
-      for (const file of readdirSync3(cachedPatternsDir).filter(
+    if (existsSync4(cachedPatternsDir)) {
+      for (const file of readdirSync4(cachedPatternsDir).filter(
         (name) => name.endsWith(".json") && name !== "index.json"
       )) {
-        const data = JSON.parse(readFileSync3(join3(cachedPatternsDir, file), "utf-8"));
+        const data = JSON.parse(readFileSync5(join4(cachedPatternsDir, file), "utf-8"));
         if (data.id && !patternRegistry.has(data.id)) {
           patternRegistry.set(data.id, data);
         }
@@ -2945,8 +4280,8 @@ function extractFailedRouteDocumentHardening(runtimeAudit) {
   return runtimeAudit.failures.filter((failure) => failure.startsWith("route-document-hardening-failed:")).map((failure) => normalizeRouteHint2(failure.slice("route-document-hardening-failed:".length))).filter(Boolean);
 }
 function appendRuntimeAuditFindings(findings, runtimeAudit, projectRoot, topology, sourceAudit) {
-  const distPath = join3(projectRoot, "dist");
-  const indexPath = join3(distPath, "index.html");
+  const distPath = join4(projectRoot, "dist");
+  const indexPath = join4(distPath, "index.html");
   const isFrameworkBuildOutput = runtimeAudit.failures.includes("next-build-output");
   if (!runtimeAudit.distPresent) {
     findings.push(
@@ -4590,6 +5925,88 @@ function appendSourceAuditFindings(findings, sourceAudit, essence, reviewPack, a
     );
   }
 }
+function appendComponentReuseFindings(findings, audit) {
+  for (const finding of audit.findings.slice(0, 8)) {
+    findings.push(
+      makeFinding({
+        id: COMPONENT_REUSE_RULE_ID,
+        code: "COMP001",
+        category: "Component Reuse",
+        severity: "warn",
+        message: `${finding.name} is reimplemented locally even though a reusable ${finding.name} component already exists.`,
+        evidence: finding.evidence,
+        target: finding.name,
+        file: finding.file,
+        rule: COMPONENT_REUSE_RULE_ID,
+        suggestedFix: `Import ${finding.name} from ${finding.canonicalFile} instead of redefining it in ${finding.file}.`,
+        repair: {
+          id: "import-existing-component",
+          payload: {
+            component: finding.name,
+            file: finding.file,
+            canonical_file: finding.canonicalFile
+          }
+        }
+      })
+    );
+  }
+  for (const finding of audit.rawControlFindings.slice(0, 8)) {
+    findings.push(
+      makeFinding({
+        id: RAW_CONTROL_REUSE_RULE_ID,
+        code: "COMP010",
+        category: "Component Reuse",
+        severity: "warn",
+        message: `${finding.file} renders raw <${finding.element}> even though the project has a reusable ${finding.component} component.`,
+        evidence: finding.evidence,
+        target: finding.component,
+        file: finding.file,
+        rule: RAW_CONTROL_REUSE_RULE_ID,
+        suggestedFix: `Use ${finding.component} from ${finding.canonicalFile} instead of raw <${finding.element}> in ${finding.file}.`,
+        repair: {
+          id: "replace-raw-control-with-local-component",
+          payload: {
+            component: finding.component,
+            element: finding.element,
+            file: finding.file,
+            canonical_file: finding.canonicalFile
+          }
+        }
+      })
+    );
+  }
+}
+function appendStyleBridgeDriftFindings(findings, audit) {
+  for (const finding of audit.findings.slice(0, 8)) {
+    findings.push(
+      makeFinding({
+        id: STYLE_BRIDGE_ARBITRARY_VALUE_RULE_ID,
+        code: "TOKEN010",
+        category: "Style Bridge",
+        severity: "warn",
+        message: `${finding.file} uses arbitrary styling even though an accepted style bridge defines project-owned token/class authority.`,
+        evidence: finding.evidence,
+        target: finding.value,
+        file: finding.file,
+        rule: STYLE_BRIDGE_ARBITRARY_VALUE_RULE_ID,
+        suggestedFix: "Replace the arbitrary Tailwind value with an accepted project token or class from .decantr/style-bridge.json, or update the style bridge if this value is now approved design authority.",
+        repair: {
+          id: "replace-arbitrary-style-with-bridge-token",
+          payload: {
+            file: finding.file,
+            line: finding.line,
+            value: finding.value,
+            source: finding.source,
+            property: finding.property,
+            bridge_mappings: finding.bridgeMappingIds,
+            token_hints: finding.tokenHints,
+            class_hints: finding.classHints
+          }
+        }
+      })
+    );
+  }
+}
 function appendStyleContractFindings(findings, styleAudit, essence) {
   if (essenceRequiresFocusVisible(essence) && styleAudit.focusVisibleSignals.count === 0) {
     findings.push(
@@ -4625,7 +6042,7 @@ function appendStyleContractFindings(findings, styleAudit, essence) {
   }
 }
 async function auditProject(projectRoot) {
-  const essencePath = join3(projectRoot, "decantr.essence.json");
+  const essencePath = join4(projectRoot, "decantr.essence.json");
   const findings = [];
   const reviewPack = loadReviewPack(projectRoot);
   const packManifest = loadPackManifest(projectRoot);
@@ -4633,7 +6050,7 @@ async function auditProject(projectRoot) {
   const packHydrationOptional = adoptionMode === "contract-only" || adoptionMode === "style-bridge";
   const packHydrationSeverity = packHydrationOptional ? "info" : "warn";
   const runtimeAudit = emptyRuntimeAudit();
-  if (!existsSync3(essencePath)) {
+  if (!existsSync4(essencePath)) {
     findings.push(
       makeFinding({
         id: "essence-missing",
@@ -4668,7 +6085,7 @@ async function auditProject(projectRoot) {
   }
   let essence = null;
   try {
-    essence = JSON.parse(readFileSync3(essencePath, "utf-8"));
+    essence = JSON.parse(readFileSync5(essencePath, "utf-8"));
   } catch (error) {
     findings.push(
       makeFinding({
@@ -4711,7 +6128,7 @@ async function auditProject(projectRoot) {
         category: "Execution Packs",
         severity: packHydrationSeverity,
         message: packHydrationOptional ? "Compiled execution pack manifest is not hydrated yet; this is optional for contract-only/style-bridge Brownfield adoption." : "Compiled execution pack manifest is missing.",
-        evidence: [join3(projectRoot, ".decantr", "context", "pack-manifest.json")],
+        evidence: [join4(projectRoot, ".decantr", "context", "pack-manifest.json")],
         suggestedFix: packHydrationOptional ? "Optional: run `decantr registry compile-packs decantr.essence.json --write-context` when you want hosted page packs and review packs for richer assistant context." : "Run `decantr registry compile-packs decantr.essence.json --write-context` to hydrate scaffold, review, mutation, section, and page packs."
       })
     );
@@ -4775,12 +6192,15 @@ async function auditProject(projectRoot) {
         category: "Review Contract",
         severity: packHydrationSeverity,
         message: packHydrationOptional ? "The compiled review pack file is not hydrated yet; contract-only/style-bridge Brownfield projects can continue without it." : "The compiled review pack file is missing.",
-        evidence: [join3(projectRoot, ".decantr", "context", "review-pack.json")],
+        evidence: [join4(projectRoot, ".decantr", "context", "review-pack.json")],
         suggestedFix: packHydrationOptional ? "Optional: hydrate hosted packs later if you want critique consumers to anchor findings to the compiled review contract." : "Hydrate the full hosted context bundle with `decantr registry compile-packs decantr.essence.json --write-context` so critique consumers can anchor findings to the compiled review contract."
       })
     );
   }
-  const sourceAudit = auditProjectSourceTree(projectRoot);
+  const projectSourceFiles = collectProjectSourceFiles(projectRoot);
+  const sourceAudit = auditProjectSourceTree(projectRoot, projectSourceFiles);
+  const componentReuseAudit = auditComponentReuse(projectRoot, projectSourceFiles);
+  const styleBridgeDriftAudit = auditStyleBridgeDrift(projectRoot, projectSourceFiles);
   const styleAudit = auditProjectStyleContracts(projectRoot);
   const checkedRuntimeAudit = await runRuntimeAudit(projectRoot, essence);
   appendRuntimeAuditFindings(
@@ -4791,6 +6211,8 @@ async function auditProject(projectRoot) {
     sourceAudit
   );
   appendSourceAuditFindings(findings, sourceAudit, essence, reviewPack, adoptionMode);
+  appendComponentReuseFindings(findings, componentReuseAudit);
+  appendStyleBridgeDriftFindings(findings, styleBridgeDriftAudit);
   appendStyleContractFindings(findings, styleAudit, essence);
   const summary = {
     errorCount: findings.filter((finding) => finding.severity === "error").length,
@@ -4916,74 +6338,74 @@ function countKeyboardShortcutSignals(code) {
   return matches.length;
 }
 function getScriptKind(filePath) {
-  switch (extname3(filePath).toLowerCase()) {
+  switch (extname4(filePath).toLowerCase()) {
     case ".tsx":
-      return ts.ScriptKind.TSX;
+      return ts3.ScriptKind.TSX;
     case ".jsx":
-      return ts.ScriptKind.JSX;
+      return ts3.ScriptKind.JSX;
     case ".ts":
-      return ts.ScriptKind.TS;
+      return ts3.ScriptKind.TS;
     case ".js":
-      return ts.ScriptKind.JS;
+      return ts3.ScriptKind.JS;
     default:
-      return ts.ScriptKind.TSX;
+      return ts3.ScriptKind.TSX;
   }
 }
 function isPropertyNamed(node, ...names) {
   if (!node) return false;
-  if (ts.isIdentifier(node)) {
+  if (ts3.isIdentifier(node)) {
     return names.includes(node.text);
   }
-  if (ts.isPrivateIdentifier(node)) {
+  if (ts3.isPrivateIdentifier(node)) {
     return names.includes(node.text);
   }
-  if (ts.isStringLiteral(node)) {
+  if (ts3.isStringLiteral(node)) {
     return names.includes(node.text);
   }
   return false;
 }
 function getJsxAttribute(attributes, ...names) {
   return attributes.properties.find(
-    (property) => ts.isJsxAttribute(property) && isPropertyNamed(property.name, ...names)
+    (property) => ts3.isJsxAttribute(property) && isPropertyNamed(property.name, ...names)
   );
 }
 function getJsxTagName(node) {
-  if (ts.isIdentifier(node.tagName)) {
+  if (ts3.isIdentifier(node.tagName)) {
     return node.tagName.text;
   }
-  if (ts.isPropertyAccessExpression(node.tagName)) {
+  if (ts3.isPropertyAccessExpression(node.tagName)) {
     return node.tagName.name.text;
   }
   return null;
 }
 function getJsxAttributeLiteralValue(attribute) {
   if (!attribute?.initializer) return null;
-  if (ts.isStringLiteral(attribute.initializer)) {
+  if (ts3.isStringLiteral(attribute.initializer)) {
     return attribute.initializer.text;
   }
-  if (ts.isJsxExpression(attribute.initializer)) {
+  if (ts3.isJsxExpression(attribute.initializer)) {
     const expression = attribute.initializer.expression;
     if (!expression) return "";
-    if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+    if (ts3.isStringLiteral(expression) || ts3.isNoSubstitutionTemplateLiteral(expression)) {
       return expression.text;
     }
   }
   return null;
 }
 function getJsxTextContent(node) {
-  if (ts.isJsxText(node)) {
+  if (ts3.isJsxText(node)) {
     return node.getText();
   }
-  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts3.isStringLiteral(node) || ts3.isNoSubstitutionTemplateLiteral(node)) {
     return node.text;
   }
-  if (ts.isJsxExpression(node)) {
+  if (ts3.isJsxExpression(node)) {
     return node.expression ? getJsxTextContent(node.expression) : "";
   }
-  if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
+  if (ts3.isJsxSelfClosingElement(node) || ts3.isJsxOpeningElement(node)) {
     return "";
   }
-  if (ts.isJsxElement(node) || ts.isJsxFragment(node)) {
+  if (ts3.isJsxElement(node) || ts3.isJsxFragment(node)) {
     return node.children.map((child) => getJsxTextContent(child)).join("");
   }
   let text = "";
@@ -5003,7 +6425,7 @@ function isNonSemanticInteractiveTag(tagName) {
 function collectLabelForIds(root) {
   const ids = /* @__PURE__ */ new Set();
   const walk = (node) => {
-    if (ts.isJsxSelfClosingElement(node) || ts.isJsxOpeningElement(node)) {
+    if (ts3.isJsxSelfClosingElement(node) || ts3.isJsxOpeningElement(node)) {
       const tagName = getJsxTagName(node);
       if (tagName === "label") {
         const htmlForValue = getJsxAttributeLiteralValue(
@@ -5014,7 +6436,7 @@ function collectLabelForIds(root) {
         }
       }
     }
-    ts.forEachChild(node, walk);
+    ts3.forEachChild(node, walk);
   };
   walk(root);
   return ids;
@@ -5022,7 +6444,7 @@ function collectLabelForIds(root) {
 function isWrappedInJsxLabel(node) {
   let current = node.parent;
   while (current) {
-    if (ts.isJsxElement(current) && getJsxTagName(current.openingElement) === "label") {
+    if (ts3.isJsxElement(current) && getJsxTagName(current.openingElement) === "label") {
       return true;
     }
     current = current.parent;
@@ -5032,7 +6454,7 @@ function isWrappedInJsxLabel(node) {
 function hasAncestorJsxTag(node, tagName) {
   let current = node.parent;
   while (current) {
-    if (ts.isJsxElement(current) && getJsxTagName(current.openingElement) === tagName) {
+    if (ts3.isJsxElement(current) && getJsxTagName(current.openingElement) === tagName) {
       return true;
     }
     current = current.parent;
@@ -5110,9 +6532,9 @@ function hasNavigationLabel(attributes) {
 }
 function getJsxAttributeOwner(attribute) {
   const attributes = attribute.parent;
-  if (!attributes || !ts.isJsxAttributes(attributes)) return null;
+  if (!attributes || !ts3.isJsxAttributes(attributes)) return null;
   const owner = attributes.parent;
-  if (ts.isJsxOpeningElement(owner) || ts.isJsxSelfClosingElement(owner)) {
+  if (ts3.isJsxOpeningElement(owner) || ts3.isJsxSelfClosingElement(owner)) {
     return owner;
   }
   return null;
@@ -5199,14 +6621,14 @@ function jsxTreeContainsAuthInput(node) {
   let found = false;
   const visit = (current) => {
     if (found) return;
-    if (ts.isJsxSelfClosingElement(current)) {
+    if (ts3.isJsxSelfClosingElement(current)) {
       const tagName = getJsxTagName(current);
       if (tagName === "input" && isAuthLikeInputAttributes(current.attributes)) {
         found = true;
       }
       return;
     }
-    if (ts.isJsxElement(current)) {
+    if (ts3.isJsxElement(current)) {
       const tagName = getJsxTagName(current.openingElement);
       if (tagName === "input" && isAuthLikeInputAttributes(current.openingElement.attributes)) {
         found = true;
@@ -5218,7 +6640,7 @@ function jsxTreeContainsAuthInput(node) {
       }
       return;
     }
-    if (ts.isJsxFragment(current)) {
+    if (ts3.isJsxFragment(current)) {
       for (const child of current.children) {
         visit(child);
         if (found) return;
@@ -5242,7 +6664,7 @@ function jsxTreeHasSubmitControl(node) {
   let found = false;
   const visit = (current) => {
     if (found) return;
-    if (ts.isJsxSelfClosingElement(current)) {
+    if (ts3.isJsxSelfClosingElement(current)) {
       const tagName = getJsxTagName(current);
       if (tagName === "button") {
         const typeValue = getJsxAttributeLiteralValue(getJsxAttribute(current.attributes, "type"))?.trim().toLowerCase();
@@ -5258,7 +6680,7 @@ function jsxTreeHasSubmitControl(node) {
       }
       return;
     }
-    if (ts.isJsxElement(current)) {
+    if (ts3.isJsxElement(current)) {
       const tagName = getJsxTagName(current.openingElement);
       if (tagName === "button") {
         const typeValue = getJsxAttributeLiteralValue(
@@ -5282,7 +6704,7 @@ function jsxTreeHasSubmitControl(node) {
       }
       return;
     }
-    if (ts.isJsxFragment(current)) {
+    if (ts3.isJsxFragment(current)) {
       for (const child of current.children) {
         visit(child);
         if (found) return;
@@ -5299,14 +6721,14 @@ function jsxTreeHasTag(node, tagNames) {
   const wanted = new Set(tagNames);
   const visit = (current) => {
     if (found) return;
-    if (ts.isJsxSelfClosingElement(current)) {
+    if (ts3.isJsxSelfClosingElement(current)) {
       const tagName = getJsxTagName(current);
       if (tagName && wanted.has(tagName)) {
         found = true;
       }
       return;
     }
-    if (ts.isJsxElement(current)) {
+    if (ts3.isJsxElement(current)) {
       const tagName = getJsxTagName(current.openingElement);
       if (tagName && wanted.has(tagName)) {
         found = true;
@@ -5318,7 +6740,7 @@ function jsxTreeHasTag(node, tagNames) {
       }
       return;
     }
-    if (ts.isJsxFragment(current)) {
+    if (ts3.isJsxFragment(current)) {
       for (const child of current.children) {
         visit(child);
         if (found) return;
@@ -5335,47 +6757,47 @@ function hasAuthFormWithoutSubmitControl(node) {
 }
 function getExpressionLiteralValue(expression) {
   if (!expression) return null;
-  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+  if (ts3.isStringLiteral(expression) || ts3.isNoSubstitutionTemplateLiteral(expression)) {
     return expression.text;
   }
-  if (ts.isParenthesizedExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression)) {
     return getExpressionLiteralValue(expression.expression);
   }
-  if (ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression)) {
+  if (ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression)) {
     return getExpressionLiteralValue(expression.expression);
   }
   return null;
 }
 function getObjectLiteralStringPropertyValue(expression, ...propertyNames) {
-  if (!expression || !ts.isObjectLiteralExpression(expression)) return null;
+  if (!expression || !ts3.isObjectLiteralExpression(expression)) return null;
   for (const property of expression.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    const propertyName = ts.isIdentifier(property.name) ? property.name.text : ts.isStringLiteral(property.name) ? property.name.text : null;
-    if (!propertyName || !propertyNames.includes(propertyName)) continue;
+    if (!ts3.isPropertyAssignment(property)) continue;
+    const propertyName2 = ts3.isIdentifier(property.name) ? property.name.text : ts3.isStringLiteral(property.name) ? property.name.text : null;
+    if (!propertyName2 || !propertyNames.includes(propertyName2)) continue;
     const value = getExpressionLiteralValue(property.initializer);
     if (value) return value;
   }
   return null;
 }
 function getObjectLiteralBooleanPropertyValue(expression, ...propertyNames) {
-  if (!expression || !ts.isObjectLiteralExpression(expression)) return null;
+  if (!expression || !ts3.isObjectLiteralExpression(expression)) return null;
   for (const property of expression.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    const propertyName = ts.isIdentifier(property.name) ? property.name.text : ts.isStringLiteral(property.name) ? property.name.text : null;
-    if (!propertyName || !propertyNames.includes(propertyName)) continue;
-    if (property.initializer.kind === ts.SyntaxKind.TrueKeyword) return true;
-    if (property.initializer.kind === ts.SyntaxKind.FalseKeyword) return false;
+    if (!ts3.isPropertyAssignment(property)) continue;
+    const propertyName2 = ts3.isIdentifier(property.name) ? property.name.text : ts3.isStringLiteral(property.name) ? property.name.text : null;
+    if (!propertyName2 || !propertyNames.includes(propertyName2)) continue;
+    if (property.initializer.kind === ts3.SyntaxKind.TrueKeyword) return true;
+    if (property.initializer.kind === ts3.SyntaxKind.FalseKeyword) return false;
   }
   return null;
 }
 function collectNamedFunctionLikeDeclarations(root) {
   const declarations = /* @__PURE__ */ new Map();
   const visit = (node) => {
-    if (ts.isFunctionDeclaration(node) && node.name && ts.isIdentifier(node.name)) {
+    if (ts3.isFunctionDeclaration(node) && node.name && ts3.isIdentifier(node.name)) {
       declarations.set(node.name.text, node);
     }
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
-      if (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer)) {
+    if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.initializer) {
+      if (ts3.isArrowFunction(node.initializer) || ts3.isFunctionExpression(node.initializer)) {
         declarations.set(node.name.text, node.initializer);
       }
     }
@@ -5395,12 +6817,12 @@ function getCachedNamedFunctionLikeDeclarations(sourceFile) {
 function collectNamedExpressionInitializers(root) {
   const initializers = /* @__PURE__ */ new Map();
   const visit = (node) => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+    if (ts3.isVariableDeclaration(node) && ts3.isIdentifier(node.name) && node.initializer) {
       initializers.set(node.name.text, node.initializer);
     }
-    if (ts.isVariableDeclaration(node) && ts.isArrayBindingPattern(node.name) && node.initializer) {
+    if (ts3.isVariableDeclaration(node) && ts3.isArrayBindingPattern(node.name) && node.initializer) {
       const firstElement = node.name.elements[0];
-      if (firstElement && !ts.isOmittedExpression(firstElement) && ts.isBindingElement(firstElement) && ts.isIdentifier(firstElement.name)) {
+      if (firstElement && !ts3.isOmittedExpression(firstElement) && ts3.isBindingElement(firstElement) && ts3.isIdentifier(firstElement.name)) {
         initializers.set(firstElement.name.text, node.initializer);
       }
     }
@@ -5411,7 +6833,7 @@ function collectNamedExpressionInitializers(root) {
 }
 function getPropertyNameText(name) {
   if (!name) return null;
-  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) {
     return name.text;
   }
   return null;
@@ -5421,23 +6843,23 @@ function collectNamedPropertyAliases(root) {
   const collectFromBindingPattern = (pattern, initializer, propertyPath) => {
     for (const element of pattern.elements) {
       if (element.dotDotDotToken) continue;
-      const propertyName = getPropertyNameText(element.propertyName) ?? getPropertyNameText(element.name);
-      if (!propertyName) continue;
-      const nextPath = [...propertyPath, propertyName];
-      if (ts.isIdentifier(element.name)) {
-        aliases.set(element.name.text, { initializer, propertyName, propertyPath: nextPath });
+      const propertyName2 = getPropertyNameText(element.propertyName) ?? getPropertyNameText(element.name);
+      if (!propertyName2) continue;
+      const nextPath = [...propertyPath, propertyName2];
+      if (ts3.isIdentifier(element.name)) {
+        aliases.set(element.name.text, { initializer, propertyName: propertyName2, propertyPath: nextPath });
         continue;
       }
-      if (ts.isObjectBindingPattern(element.name)) {
+      if (ts3.isObjectBindingPattern(element.name)) {
         collectFromBindingPattern(element.name, initializer, nextPath);
       }
     }
   };
   const visit = (node) => {
-    if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer) {
+    if (ts3.isVariableDeclaration(node) && ts3.isObjectBindingPattern(node.name) && node.initializer) {
       collectFromBindingPattern(node.name, node.initializer, []);
     }
-    if (ts.isParameter(node) && ts.isObjectBindingPattern(node.name)) {
+    if (ts3.isParameter(node) && ts3.isObjectBindingPattern(node.name)) {
       collectFromBindingPattern(node.name, void 0, []);
     }
     node.forEachChild(visit);
@@ -5447,28 +6869,28 @@ function collectNamedPropertyAliases(root) {
 }
 function resolveFunctionLikeHandler(expression, namedFunctions) {
   if (!expression) return null;
-  if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+  if (ts3.isArrowFunction(expression) || ts3.isFunctionExpression(expression)) {
     return expression;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     return namedFunctions.get(expression.text) ?? null;
   }
   return null;
 }
 function getFunctionLikeReturnExpressions(node) {
-  if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+  if (ts3.isArrowFunction(node) && !ts3.isBlock(node.body)) {
     return [node.body];
   }
   const body = node.body;
-  if (!body || !ts.isBlock(body)) {
+  if (!body || !ts3.isBlock(body)) {
     return [];
   }
   const expressions = [];
   const visit = (current) => {
-    if (current !== body && (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current) || ts.isGetAccessorDeclaration(current) || ts.isSetAccessorDeclaration(current) || ts.isConstructorDeclaration(current))) {
+    if (current !== body && (ts3.isFunctionDeclaration(current) || ts3.isFunctionExpression(current) || ts3.isArrowFunction(current) || ts3.isMethodDeclaration(current) || ts3.isGetAccessorDeclaration(current) || ts3.isSetAccessorDeclaration(current) || ts3.isConstructorDeclaration(current))) {
       return;
     }
-    if (ts.isReturnStatement(current) && current.expression) {
+    if (ts3.isReturnStatement(current) && current.expression) {
       expressions.push(current.expression);
       return;
     }
@@ -5484,7 +6906,7 @@ function bindFunctionLikeArguments(functionLike, args, namedExpressions) {
   const boundExpressions = new Map(namedExpressions);
   functionLike.parameters.forEach((parameter, index) => {
     const argument = args[index];
-    if (!argument || !ts.isIdentifier(parameter.name)) return;
+    if (!argument || !ts3.isIdentifier(parameter.name)) return;
     boundExpressions.set(parameter.name.text, argument);
   });
   return boundExpressions;
@@ -5496,12 +6918,12 @@ function getMemberAccessPropertyName(expression) {
   }
   return getExpressionLiteralValue(expression.argumentExpression);
 }
-function getObjectLiteralPropertyExpression(objectLiteral, propertyName, namedExpressions) {
+function getObjectLiteralPropertyExpression(objectLiteral, propertyName2, namedExpressions) {
   for (const property of objectLiteral.properties) {
-    if (ts.isPropertyAssignment(property) && getPropertyNameText(property.name) === propertyName) {
+    if (ts3.isPropertyAssignment(property) && getPropertyNameText(property.name) === propertyName2) {
       return property.initializer;
     }
-    if (ts.isShorthandPropertyAssignment(property) && property.name.text === propertyName) {
+    if (ts3.isShorthandPropertyAssignment(property) && property.name.text === propertyName2) {
       return namedExpressions.get(property.name.text) ?? null;
     }
   }
@@ -5520,10 +6942,10 @@ function resolveObjectLiteralExpressionAtPropertyPath(expression, sourceFile, pr
     depth + 1
   );
   if (!resolvedObjectLiteral) return null;
-  for (const propertyName of propertyPath) {
+  for (const propertyName2 of propertyPath) {
     const propertyExpression = getObjectLiteralPropertyExpression(
       resolvedObjectLiteral.objectLiteral,
-      propertyName,
+      propertyName2,
       resolvedObjectLiteral.namedExpressions
     );
     if (!propertyExpression) return null;
@@ -5567,7 +6989,7 @@ function resolveReturnedObjectLiteralExpression(functionLike, args, sourceFile,
 function resolveObjectLiteralExpression(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers, seenFunctions = /* @__PURE__ */ new Set(), depth = 0) {
   if (!expression) return null;
   if (depth > MAX_OPEN_REDIRECT_RESOLUTION_DEPTH) return null;
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return resolveObjectLiteralExpression(
       expression.expression,
       sourceFile,
@@ -5578,10 +7000,10 @@ function resolveObjectLiteralExpression(expression, sourceFile, namedExpressions
       depth + 1
     );
   }
-  if (ts.isObjectLiteralExpression(expression)) {
+  if (ts3.isObjectLiteralExpression(expression)) {
     return { objectLiteral: expression, namedExpressions };
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return null;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -5637,12 +7059,12 @@ function resolveObjectLiteralExpression(expression, sourceFile, namedExpressions
     );
   }
   if (isMemberAccessExpression(expression)) {
-    const propertyName = getMemberAccessPropertyName(expression);
-    if (!propertyName) return null;
+    const propertyName2 = getMemberAccessPropertyName(expression);
+    if (!propertyName2) return null;
     return resolveObjectLiteralExpressionAtPropertyPath(
       expression.expression,
       sourceFile,
-      [propertyName],
+      [propertyName2],
       namedExpressions,
       namedPropertyAliases,
       seenIdentifiers,
@@ -5652,15 +7074,15 @@ function resolveObjectLiteralExpression(expression, sourceFile, namedExpressions
   }
   return null;
 }
-function findFunctionLikeOnObjectLiteral(objectLiteral, propertyName, namedFunctions) {
+function findFunctionLikeOnObjectLiteral(objectLiteral, propertyName2, namedFunctions) {
   for (const property of objectLiteral.properties) {
-    if (ts.isMethodDeclaration(property) && getPropertyNameText(property.name) === propertyName) {
+    if (ts3.isMethodDeclaration(property) && getPropertyNameText(property.name) === propertyName2) {
       return property;
     }
-    if (ts.isPropertyAssignment(property) && getPropertyNameText(property.name) === propertyName) {
+    if (ts3.isPropertyAssignment(property) && getPropertyNameText(property.name) === propertyName2) {
       return resolveFunctionLikeHandler(property.initializer, namedFunctions);
     }
-    if (ts.isShorthandPropertyAssignment(property) && property.name.text === propertyName) {
+    if (ts3.isShorthandPropertyAssignment(property) && property.name.text === propertyName2) {
       return namedFunctions.get(property.name.text) ?? null;
     }
   }
@@ -5695,7 +7117,7 @@ function resolveTrackedOpenRedirectFunctionLike(expression, sourceFile, namedExp
   if (directFunctionLike) {
     return { functionLike: directFunctionLike, namedExpressions };
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return resolveTrackedOpenRedirectFunctionLike(
       expression.expression,
       sourceFile,
@@ -5728,7 +7150,7 @@ function resolveTrackedOpenRedirectFunctionLike(expression, sourceFile, namedExp
       depth + 1
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return null;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -5768,8 +7190,8 @@ function resolveTrackedOpenRedirectFunctionLike(expression, sourceFile, namedExp
   if (!isMemberAccessExpression(expression)) {
     return null;
   }
-  const propertyName = getMemberAccessPropertyName(expression);
-  if (!propertyName) return null;
+  const propertyName2 = getMemberAccessPropertyName(expression);
+  if (!propertyName2) return null;
   const resolvedObjectLiteral = resolveObjectLiteralExpression(
     expression.expression,
     sourceFile,
@@ -5782,7 +7204,7 @@ function resolveTrackedOpenRedirectFunctionLike(expression, sourceFile, namedExp
   if (!resolvedObjectLiteral) return null;
   const functionLike = findFunctionLikeOnObjectLiteral(
     resolvedObjectLiteral.objectLiteral,
-    propertyName,
+    propertyName2,
     namedFunctions
   );
   return functionLike ? { functionLike, namedExpressions: resolvedObjectLiteral.namedExpressions } : null;
@@ -5791,16 +7213,16 @@ function functionLikeReferencesOrigin(node) {
   let found = false;
   const visit = (current) => {
     if (found) return;
-    if (ts.isPropertyAccessExpression(current) && isPropertyNamed(current.name, "origin")) {
+    if (ts3.isPropertyAccessExpression(current) && isPropertyNamed(current.name, "origin")) {
       found = true;
       return;
     }
-    if (ts.isIdentifier(current) && current.text === "origin") {
+    if (ts3.isIdentifier(current) && current.text === "origin") {
       found = true;
       return;
     }
-    if (ts.isBindingElement(current)) {
-      if (ts.isIdentifier(current.name) && current.name.text === "origin") {
+    if (ts3.isBindingElement(current)) {
+      if (ts3.isIdentifier(current.name) && current.name.text === "origin") {
         found = true;
         return;
       }
@@ -5815,13 +7237,13 @@ function functionLikeReferencesOrigin(node) {
   return found;
 }
 function isAddEventListenerCall(node) {
-  return ts.isIdentifier(node.expression) && node.expression.text === "addEventListener" || ts.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "addEventListener");
+  return ts3.isIdentifier(node.expression) && node.expression.text === "addEventListener" || ts3.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "addEventListener");
 }
 function isCookieMutationSetCall(node) {
-  if (!ts.isPropertyAccessExpression(node.expression) || !isPropertyNamed(node.expression.name, "set")) {
+  if (!ts3.isPropertyAccessExpression(node.expression) || !isPropertyNamed(node.expression.name, "set")) {
     return false;
   }
-  return ts.isIdentifier(node.expression.expression) && ["Cookies", "cookieStore", "cookies"].includes(node.expression.expression.text) || ts.isPropertyAccessExpression(node.expression.expression) && isPropertyNamed(node.expression.expression.name, "cookies", "cookieStore");
+  return ts3.isIdentifier(node.expression.expression) && ["Cookies", "cookieStore", "cookies"].includes(node.expression.expression.text) || ts3.isPropertyAccessExpression(node.expression.expression) && isPropertyNamed(node.expression.expression.name, "cookies", "cookieStore");
 }
 function expressionLooksLikeAuthCookieName(node, sourceFile) {
   if (!node) return false;
@@ -5829,17 +7251,17 @@ function expressionLooksLikeAuthCookieName(node, sourceFile) {
   return hasAuthCredentialText(node, sourceFile);
 }
 function objectLiteralLooksLikeAuthCookieConfig(expression, sourceFile) {
-  if (!expression || !ts.isObjectLiteralExpression(expression)) return false;
+  if (!expression || !ts3.isObjectLiteralExpression(expression)) return false;
   for (const property of expression.properties) {
-    if (!ts.isPropertyAssignment(property)) continue;
-    const propertyName = ts.isIdentifier(property.name) ? property.name.text : ts.isStringLiteral(property.name) ? property.name.text : null;
-    if (!propertyName || !["name", "key", "cookie"].includes(propertyName)) continue;
+    if (!ts3.isPropertyAssignment(property)) continue;
+    const propertyName2 = ts3.isIdentifier(property.name) ? property.name.text : ts3.isStringLiteral(property.name) ? property.name.text : null;
+    if (!propertyName2 || !["name", "key", "cookie"].includes(propertyName2)) continue;
     return expressionLooksLikeAuthCookieName(property.initializer, sourceFile);
   }
   return false;
 }
 function hasExplicitAuthCookieHardening(expression) {
-  if (!expression || !ts.isObjectLiteralExpression(expression)) return false;
+  if (!expression || !ts3.isObjectLiteralExpression(expression)) return false;
   const httpOnly = getObjectLiteralBooleanPropertyValue(expression, "httpOnly", "http_only");
   const secure = getObjectLiteralBooleanPropertyValue(expression, "secure");
   const sameSite = getObjectLiteralStringPropertyValue(expression, "sameSite", "same_site");
@@ -5859,8 +7281,8 @@ function collectCookieHeaderStrings(expression) {
   if (!expression) return [];
   const literal = getExpressionLiteralValue(expression);
   if (literal !== null) return [literal];
-  if (ts.isArrayLiteralExpression(expression)) {
-    return expression.elements.map((element) => ts.isExpression(element) ? getExpressionLiteralValue(element) : null).filter((value) => value !== null);
+  if (ts3.isArrayLiteralExpression(expression)) {
+    return expression.elements.map((element) => ts3.isExpression(element) ? getExpressionLiteralValue(element) : null).filter((value) => value !== null);
   }
   return [];
 }
@@ -5868,16 +7290,16 @@ function isInsecureTransportUrl(value) {
   return typeof value === "string" && /^(?:http|ws):\/\//i.test(value.trim());
 }
 function isPropertyLikeAccessExpression(node) {
-  return Boolean(node && (ts.isPropertyAccessExpression(node) || ts.isPropertyAccessChain(node)));
+  return Boolean(node && (ts3.isPropertyAccessExpression(node) || ts3.isPropertyAccessChain(node)));
 }
 function isElementLikeAccessExpression(node) {
-  return Boolean(node && (ts.isElementAccessExpression(node) || ts.isElementAccessChain(node)));
+  return Boolean(node && (ts3.isElementAccessExpression(node) || ts3.isElementAccessChain(node)));
 }
 function isMemberAccessExpression(node) {
   return isPropertyLikeAccessExpression(node) || isElementLikeAccessExpression(node);
 }
 function isCallLikeExpression(node) {
-  return Boolean(node && (ts.isCallExpression(node) || ts.isCallChain(node)));
+  return Boolean(node && (ts3.isCallExpression(node) || ts3.isCallChain(node)));
 }
 function isMemberAccessNamed(node, ...names) {
   if (!node) return false;
@@ -5890,19 +7312,19 @@ function isMemberAccessNamed(node, ...names) {
   return false;
 }
 function isLocationObjectExpression(expression) {
-  return ts.isIdentifier(expression) && expression.text === "location" || (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) && ts.isIdentifier(expression.expression) && ["window", "globalThis", "document", "self", "parent", "top"].includes(
+  return ts3.isIdentifier(expression) && expression.text === "location" || (ts3.isPropertyAccessExpression(expression) || ts3.isElementAccessExpression(expression)) && ts3.isIdentifier(expression.expression) && ["window", "globalThis", "document", "self", "parent", "top"].includes(
     expression.expression.text
   ) && isMemberAccessNamed(expression, "location");
 }
 function isLocationAssignmentTarget(expression) {
-  return isLocationObjectExpression(expression) || (ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) && isLocationObjectExpression(expression.expression) && isMemberAccessNamed(expression, "href");
+  return isLocationObjectExpression(expression) || (ts3.isPropertyAccessExpression(expression) || ts3.isElementAccessExpression(expression)) && isLocationObjectExpression(expression.expression) && isMemberAccessNamed(expression, "href");
 }
 function isFetchLikeCall(node) {
-  return ts.isIdentifier(node.expression) && node.expression.text === "fetch" || ts.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "fetch");
+  return ts3.isIdentifier(node.expression) && node.expression.text === "fetch" || ts3.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "fetch");
 }
 function isAxiosLikeCall(node) {
-  if (!ts.isPropertyAccessExpression(node.expression)) return false;
-  return ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "axios" && isPropertyNamed(
+  if (!ts3.isPropertyAccessExpression(node.expression)) return false;
+  return ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "axios" && isPropertyNamed(
     node.expression.name,
     "get",
     "post",
@@ -5915,10 +7337,10 @@ function isAxiosLikeCall(node) {
   );
 }
 function isAxiosConfigCall(node) {
-  return ts.isIdentifier(node.expression) && node.expression.text === "axios";
+  return ts3.isIdentifier(node.expression) && node.expression.text === "axios";
 }
 function isRealtimeTransportConstructor(node) {
-  return ts.isIdentifier(node.expression) && (node.expression.text === "WebSocket" || node.expression.text === "EventSource");
+  return ts3.isIdentifier(node.expression) && (node.expression.text === "WebSocket" || node.expression.text === "EventSource");
 }
 function hasPlaceholderNavigationTarget(attributes) {
   const targetValue = getJsxAttributeLiteralValue(getJsxAttribute(attributes, "href", "to"));
@@ -5985,40 +7407,40 @@ function getSkipNavTargetId(attributes, tagName) {
 }
 function isAuthStorageKeyLiteral(node) {
   if (!node) return false;
-  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts3.isStringLiteral(node) || ts3.isNoSubstitutionTemplateLiteral(node)) {
     if (node.text === "decantr_authenticated") return false;
     return /(?:token|auth|jwt|session|access_token|refresh_token)/i.test(node.text);
   }
   return false;
 }
 function isBrowserStorageObject(node) {
-  return ts.isIdentifier(node) && (node.text === "localStorage" || node.text === "sessionStorage");
+  return ts3.isIdentifier(node) && (node.text === "localStorage" || node.text === "sessionStorage");
 }
 function isDocumentObject(node) {
-  return ts.isIdentifier(node) && node.text === "document";
+  return ts3.isIdentifier(node) && node.text === "document";
 }
 function isCookiePropertyAccess(node) {
-  return ts.isPropertyAccessExpression(node) && isDocumentObject(node.expression) && isPropertyNamed(node.name, "cookie");
+  return ts3.isPropertyAccessExpression(node) && isDocumentObject(node.expression) && isPropertyNamed(node.name, "cookie");
 }
 function hasAuthCredentialText(node, sourceFile) {
   return /(?:token|auth|jwt|session|access_token|refresh_token)/i.test(node.getText(sourceFile));
 }
 function isAuthorizationHeaderName(node) {
   if (!node) return false;
-  if (ts.isIdentifier(node)) {
+  if (ts3.isIdentifier(node)) {
     return /^authorization$/i.test(node.text);
   }
-  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+  if (ts3.isStringLiteral(node) || ts3.isNoSubstitutionTemplateLiteral(node)) {
     return /^authorization$/i.test(node.text);
   }
-  if (ts.isComputedPropertyName(node)) {
+  if (ts3.isComputedPropertyName(node)) {
     return isAuthorizationHeaderName(node.expression);
   }
   return false;
 }
 function isAuthorizationHeaderAccess(node) {
   if (!node) return false;
-  return ts.isPropertyAccessExpression(node) && isAuthorizationHeaderName(node.name) || ts.isElementAccessExpression(node) && isAuthorizationHeaderName(node.argumentExpression);
+  return ts3.isPropertyAccessExpression(node) && isAuthorizationHeaderName(node.name) || ts3.isElementAccessExpression(node) && isAuthorizationHeaderName(node.argumentExpression);
 }
 function isHeaderClearValue(node) {
   if (!node) return false;
@@ -6026,7 +7448,7 @@ function isHeaderClearValue(node) {
   if (literal !== null) {
     return literal.trim().length === 0;
   }
-  return node.kind === ts.SyntaxKind.NullKeyword || node.kind === ts.SyntaxKind.UndefinedKeyword || ts.isIdentifier(node) && node.text === "undefined";
+  return node.kind === ts3.SyntaxKind.NullKeyword || node.kind === ts3.SyntaxKind.UndefinedKeyword || ts3.isIdentifier(node) && node.text === "undefined";
 }
 function countAuthGuardSignals(code) {
   const patterns = [
@@ -6775,7 +8197,7 @@ function propertyPathLooksLikeOpenRedirectQueryContainerBase(propertyPath) {
 }
 function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFile, namedExpressions = /* @__PURE__ */ new Map(), namedPropertyAliases = /* @__PURE__ */ new Map(), seenIdentifiers = /* @__PURE__ */ new Set(), seenFunctions = /* @__PURE__ */ new Set()) {
   if (!expression) return false;
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryGetterFunction(
       expression.expression,
       sourceFile,
@@ -6802,7 +8224,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       )
     );
   }
-  if (ts.isBinaryExpression(expression) && (expression.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken || expression.operatorToken.kind === ts.SyntaxKind.BarBarToken)) {
+  if (ts3.isBinaryExpression(expression) && (expression.operatorToken.kind === ts3.SyntaxKind.QuestionQuestionToken || expression.operatorToken.kind === ts3.SyntaxKind.BarBarToken)) {
     return expressionLooksLikeOpenRedirectQueryGetterFunction(
       expression.left,
       sourceFile,
@@ -6819,7 +8241,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       seenFunctions
     );
   }
-  if (ts.isConditionalExpression(expression)) {
+  if (ts3.isConditionalExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryGetterFunction(
       expression.whenTrue,
       sourceFile,
@@ -6836,7 +8258,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       seenFunctions
     );
   }
-  if (ts.isTemplateExpression(expression)) {
+  if (ts3.isTemplateExpression(expression)) {
     return expression.templateSpans.some(
       (span) => expressionLooksLikeOpenRedirectQueryGetterFunction(
         span.expression,
@@ -6848,7 +8270,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       )
     );
   }
-  if (ts.isTaggedTemplateExpression(expression)) {
+  if (ts3.isTaggedTemplateExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryGetterFunction(
       expression.template,
       sourceFile,
@@ -6858,7 +8280,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
       seenFunctions
     );
   }
-  if (ts.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalBooleanHelper(
+  if (ts3.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalBooleanHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -6874,7 +8296,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalNumberHelper(
+  if (ts3.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalNumberHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -6890,7 +8312,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalObjectHelper(
+  if (ts3.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalObjectHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -6906,7 +8328,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalStringHelper(
+  if (ts3.isNewExpression(expression) && expression.arguments && expression.arguments.length > 0 && expressionLooksLikeBrowserGlobalStringHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -6938,7 +8360,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalSymbolHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalSymbolHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7002,7 +8424,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBigIntHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBigIntHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7066,7 +8488,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBooleanHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBooleanHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7130,7 +8552,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalNumberHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalNumberHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7194,7 +8616,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalObjectHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalObjectHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7242,7 +8664,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && ts.isIdentifier(expression.expression) && [
+  if (isCallLikeExpression(expression) && ts3.isIdentifier(expression.expression) && [
     "String",
     "atob",
     "btoa",
@@ -7278,7 +8700,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeJsonStringifyHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeJsonStringifyHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7342,7 +8764,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeJsonParseHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeJsonParseHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7406,7 +8828,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeStructuredCloneHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeStructuredCloneHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7470,7 +8892,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalStringHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalStringHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7550,7 +8972,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalUriCodecHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalUriCodecHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7598,7 +9020,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBase64Helper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBrowserGlobalBase64Helper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7646,7 +9068,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && (ts.isIdentifier(expression.expression) || isMemberAccessExpression(expression.expression)) && expression.arguments.length > 0 && expressionLooksLikeBufferFromHelper(
+  if (isCallLikeExpression(expression) && (ts3.isIdentifier(expression.expression) || isMemberAccessExpression(expression.expression)) && expression.arguments.length > 0 && expressionLooksLikeBufferFromHelper(
     expression.expression,
     sourceFile,
     namedExpressions,
@@ -7698,7 +9120,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBufferFromHelper(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && expression.arguments.length > 2 && expressionLooksLikeBufferFromHelper(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7746,7 +9168,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "from") && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Buffer" && expression.arguments.length > 0 && expressionLooksLikeOpenRedirectQueryGetterFunction(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "from") && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Buffer" && expression.arguments.length > 0 && expressionLooksLikeOpenRedirectQueryGetterFunction(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7925,7 +9347,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isElementLikeAccessExpression(expression) && ts.isNumericLiteral(expression.argumentExpression) && expression.argumentExpression.text === "1" && isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "value") && isCallLikeExpression(expression.expression.expression) && isMemberAccessExpression(expression.expression.expression.expression) && isMemberAccessNamed(expression.expression.expression.expression, "next") && isCallLikeExpression(expression.expression.expression.expression.expression) && isMemberAccessExpression(expression.expression.expression.expression.expression.expression) && isMemberAccessNamed(
+  if (isElementLikeAccessExpression(expression) && ts3.isNumericLiteral(expression.argumentExpression) && expression.argumentExpression.text === "1" && isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "value") && isCallLikeExpression(expression.expression.expression) && isMemberAccessExpression(expression.expression.expression.expression) && isMemberAccessNamed(expression.expression.expression.expression, "next") && isCallLikeExpression(expression.expression.expression.expression.expression) && isMemberAccessExpression(expression.expression.expression.expression.expression.expression) && isMemberAccessNamed(
     expression.expression.expression.expression.expression.expression,
     "entries"
   ) && expressionLooksLikeOpenRedirectQueryGetterFunction(
@@ -7958,7 +9380,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Array" && isPropertyNamed(expression.expression.name, "from") && expression.arguments.length > 0 && expressionLooksLikeOpenRedirectQueryGetterFunction(
+  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Array" && isPropertyNamed(expression.expression.name, "from") && expression.arguments.length > 0 && expressionLooksLikeOpenRedirectQueryGetterFunction(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -7968,8 +9390,8 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts.isArrayLiteralExpression(expression) && expression.elements.some(
-    (element) => ts.isSpreadElement(element) && expressionLooksLikeOpenRedirectQueryGetterFunction(
+  if (ts3.isArrayLiteralExpression(expression) && expression.elements.some(
+    (element) => ts3.isSpreadElement(element) && expressionLooksLikeOpenRedirectQueryGetterFunction(
       element.expression,
       sourceFile,
       namedExpressions,
@@ -8020,7 +9442,7 @@ function expressionLooksLikeOpenRedirectQueryGetterFunction(expression, sourceFi
   )) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -8054,7 +9476,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
   if (OPEN_REDIRECT_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionContainsOpenRedirectSource(
       expression.expression,
       sourceFile,
@@ -8064,7 +9486,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       seenFunctions
     );
   }
-  if (ts.isBinaryExpression(expression)) {
+  if (ts3.isBinaryExpression(expression)) {
     return expressionContainsOpenRedirectSource(
       expression.left,
       sourceFile,
@@ -8081,7 +9503,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       seenFunctions
     );
   }
-  if (ts.isConditionalExpression(expression)) {
+  if (ts3.isConditionalExpression(expression)) {
     return expressionContainsOpenRedirectSource(
       expression.condition,
       sourceFile,
@@ -8105,7 +9527,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       seenFunctions
     );
   }
-  if (ts.isTemplateExpression(expression)) {
+  if (ts3.isTemplateExpression(expression)) {
     return expression.templateSpans.some(
       (span) => expressionContainsOpenRedirectSource(
         span.expression,
@@ -8117,7 +9539,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       )
     );
   }
-  if (ts.isTaggedTemplateExpression(expression)) {
+  if (ts3.isTaggedTemplateExpression(expression)) {
     return expressionContainsOpenRedirectSource(
       expression.template,
       sourceFile,
@@ -8127,7 +9549,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       seenFunctions
     );
   }
-  if (ts.isNewExpression(expression)) {
+  if (ts3.isNewExpression(expression)) {
     return (expression.arguments ?? []).some(
       (argument) => expressionContainsOpenRedirectSource(
         argument,
@@ -8139,9 +9561,9 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       )
     );
   }
-  if (ts.isArrayLiteralExpression(expression)) {
+  if (ts3.isArrayLiteralExpression(expression)) {
     return expression.elements.some((element) => {
-      if (ts.isSpreadElement(element)) {
+      if (ts3.isSpreadElement(element)) {
         return expressionContainsOpenRedirectSource(
           element.expression,
           sourceFile,
@@ -8151,7 +9573,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
           seenFunctions
         );
       }
-      return ts.isExpression(element) && expressionContainsOpenRedirectSource(
+      return ts3.isExpression(element) && expressionContainsOpenRedirectSource(
         element,
         sourceFile,
         namedExpressions,
@@ -8161,9 +9583,9 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       );
     });
   }
-  if (ts.isObjectLiteralExpression(expression)) {
+  if (ts3.isObjectLiteralExpression(expression)) {
     return expression.properties.some((property) => {
-      if (ts.isPropertyAssignment(property)) {
+      if (ts3.isPropertyAssignment(property)) {
         return expressionContainsOpenRedirectSource(
           property.initializer,
           sourceFile,
@@ -8173,7 +9595,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
           seenFunctions
         );
       }
-      if (ts.isShorthandPropertyAssignment(property)) {
+      if (ts3.isShorthandPropertyAssignment(property)) {
         return expressionContainsOpenRedirectSource(
           property.name,
           sourceFile,
@@ -8183,7 +9605,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
           seenFunctions
         );
       }
-      if (ts.isSpreadAssignment(property)) {
+      if (ts3.isSpreadAssignment(property)) {
         return expressionContainsOpenRedirectSource(
           property.expression,
           sourceFile,
@@ -8238,7 +9660,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
       }
     }
   }
-  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && isOpenRedirectQueryKeyExpression(
+  if (isCallLikeExpression(expression) && isMemberAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Reflect" && isMemberAccessNamed(expression.expression, "apply") && isOpenRedirectQueryKeyExpression(
     getAliasedApplyArgumentExpression(expression.arguments[2], 0, namedExpressions, /* @__PURE__ */ new Set()),
     namedExpressions,
     seenIdentifiers
@@ -8354,7 +9776,7 @@ function expressionContainsOpenRedirectSource(expression, sourceFile, namedExpre
   )) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) {
       return false;
     }
@@ -8392,14 +9814,14 @@ function isOpenRedirectQueryKeyExpression(expression, namedExpressions = /* @__P
     return true;
   }
   if (!expression) return false;
-  if (ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression) || ts.isParenthesizedExpression(expression)) {
+  if (ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression) || ts3.isParenthesizedExpression(expression)) {
     return isOpenRedirectQueryKeyExpression(
       expression.expression,
       namedExpressions,
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -8415,7 +9837,7 @@ function expressionLooksLikeOpenRedirectQueryCarrier(expression, sourceFile, nam
   if (OPEN_REDIRECT_QUERY_CARRIER_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryCarrier(
       expression.expression,
       sourceFile,
@@ -8424,7 +9846,7 @@ function expressionLooksLikeOpenRedirectQueryCarrier(expression, sourceFile, nam
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Object" && isPropertyNamed(expression.expression.name, "fromEntries") && expression.arguments.length > 0) {
+  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Object" && isPropertyNamed(expression.expression.name, "fromEntries") && expression.arguments.length > 0) {
     const entriesExpression = expression.arguments[0];
     if (expressionLooksLikeOpenRedirectSearchParamsCarrier(
       entriesExpression,
@@ -8454,7 +9876,7 @@ function expressionLooksLikeOpenRedirectQueryCarrier(expression, sourceFile, nam
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -8487,7 +9909,7 @@ function expressionLooksLikeOpenRedirectQueryCarrier(expression, sourceFile, nam
 }
 function expressionLooksLikeOpenRedirectEntriesCarrier(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectEntriesCarrier(
       expression.expression,
       sourceFile,
@@ -8496,7 +9918,7 @@ function expressionLooksLikeOpenRedirectEntriesCarrier(expression, sourceFile, n
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Array" && isPropertyNamed(expression.expression.name, "from") && expression.arguments.length > 0 && (expressionLooksLikeOpenRedirectEntriesCarrier(
+  if (isCallLikeExpression(expression) && isPropertyLikeAccessExpression(expression.expression) && ts3.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "Array" && isPropertyNamed(expression.expression.name, "from") && expression.arguments.length > 0 && (expressionLooksLikeOpenRedirectEntriesCarrier(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -8511,8 +9933,8 @@ function expressionLooksLikeOpenRedirectEntriesCarrier(expression, sourceFile, n
   ))) {
     return true;
   }
-  if (ts.isArrayLiteralExpression(expression) && expression.elements.some(
-    (element) => ts.isSpreadElement(element) && (expressionLooksLikeOpenRedirectEntriesCarrier(
+  if (ts3.isArrayLiteralExpression(expression) && expression.elements.some(
+    (element) => ts3.isSpreadElement(element) && (expressionLooksLikeOpenRedirectEntriesCarrier(
       element.expression,
       sourceFile,
       namedExpressions,
@@ -8537,7 +9959,7 @@ function expressionLooksLikeOpenRedirectEntriesCarrier(expression, sourceFile, n
   )) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -8559,7 +9981,7 @@ function expressionLooksLikeOpenRedirectQueryContainerBase(expression, sourceFil
   if (OPEN_REDIRECT_QUERY_CONTAINER_BASE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectQueryContainerBase(
       expression.expression,
       sourceFile,
@@ -8568,10 +9990,10 @@ function expressionLooksLikeOpenRedirectQueryContainerBase(expression, sourceFil
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && (ts.isIdentifier(expression.expression) && expression.expression.text === "useRouter" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useRouter"))) {
+  if (isCallLikeExpression(expression) && (ts3.isIdentifier(expression.expression) && expression.expression.text === "useRouter" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useRouter"))) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -8609,7 +10031,7 @@ function expressionLooksLikeLocationQuerySource(expression, sourceFile, namedExp
   if (LOCATION_QUERY_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationQuerySource(
       expression.expression,
       sourceFile,
@@ -8642,7 +10064,7 @@ function expressionLooksLikeLocationQuerySource(expression, sourceFile, namedExp
   ))) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -8678,10 +10100,10 @@ function expressionLooksLikeLocationQuerySource(expression, sourceFile, namedExp
 }
 function expressionLooksLikeWindowObjectSource(expression, sourceFile, namedExpressions, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && ["window", "globalThis", "document", "self", "parent", "top"].includes(expression.text)) {
+  if (ts3.isIdentifier(expression) && ["window", "globalThis", "document", "self", "parent", "top"].includes(expression.text)) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeWindowObjectSource(
       expression.expression,
       sourceFile,
@@ -8689,7 +10111,7 @@ function expressionLooksLikeWindowObjectSource(expression, sourceFile, namedExpr
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -8710,7 +10132,7 @@ function expressionLooksLikeLocationObjectSource(expression, sourceFile, namedEx
   if (isLocationObjectExpression(expression)) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationObjectSource(
       expression.expression,
       sourceFile,
@@ -8719,7 +10141,7 @@ function expressionLooksLikeLocationObjectSource(expression, sourceFile, namedEx
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && (ts.isIdentifier(expression.expression) && expression.expression.text === "useLocation" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useLocation"))) {
+  if (isCallLikeExpression(expression) && (ts3.isIdentifier(expression.expression) && expression.expression.text === "useLocation" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useLocation"))) {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "location") && expressionLooksLikeWindowObjectSource(
@@ -8730,7 +10152,7 @@ function expressionLooksLikeLocationObjectSource(expression, sourceFile, namedEx
   )) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -8759,10 +10181,10 @@ function expressionLooksLikeLocationObjectSource(expression, sourceFile, namedEx
 }
 function expressionLooksLikeHistoryObjectSource(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "history") {
+  if (ts3.isIdentifier(expression) && expression.text === "history") {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeHistoryObjectSource(
       expression.expression,
       sourceFile,
@@ -8779,7 +10201,7 @@ function expressionLooksLikeHistoryObjectSource(expression, sourceFile, namedExp
   )) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -8808,10 +10230,10 @@ function expressionLooksLikeHistoryObjectSource(expression, sourceFile, namedExp
 }
 function expressionLooksLikeBufferObjectSource(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "Buffer") {
+  if (ts3.isIdentifier(expression) && expression.text === "Buffer") {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBufferObjectSource(
       expression.expression,
       sourceFile,
@@ -8828,7 +10250,7 @@ function expressionLooksLikeBufferObjectSource(expression, sourceFile, namedExpr
   )) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -8875,7 +10297,7 @@ function expressionLooksLikeBufferFromHelper(expression, sourceFile, namedExpres
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBufferFromHelper(
       expression.expression,
       sourceFile,
@@ -8884,7 +10306,7 @@ function expressionLooksLikeBufferFromHelper(expression, sourceFile, namedExpres
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -8914,10 +10336,10 @@ function expressionLooksLikeBufferFromHelper(expression, sourceFile, namedExpres
 }
 function expressionLooksLikeJsonObjectSource(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "JSON") {
+  if (ts3.isIdentifier(expression) && expression.text === "JSON") {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeJsonObjectSource(
       expression.expression,
       sourceFile,
@@ -8934,7 +10356,7 @@ function expressionLooksLikeJsonObjectSource(expression, sourceFile, namedExpres
   )) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -8981,7 +10403,7 @@ function expressionLooksLikeJsonStringifyHelper(expression, sourceFile, namedExp
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeJsonStringifyHelper(
       expression.expression,
       sourceFile,
@@ -8990,7 +10412,7 @@ function expressionLooksLikeJsonStringifyHelper(expression, sourceFile, namedExp
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9038,7 +10460,7 @@ function expressionLooksLikeJsonParseHelper(expression, sourceFile, namedExpress
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeJsonParseHelper(
       expression.expression,
       sourceFile,
@@ -9047,7 +10469,7 @@ function expressionLooksLikeJsonParseHelper(expression, sourceFile, namedExpress
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9077,7 +10499,7 @@ function expressionLooksLikeJsonParseHelper(expression, sourceFile, namedExpress
 }
 function expressionLooksLikeStructuredCloneHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "structuredClone") {
+  if (ts3.isIdentifier(expression) && expression.text === "structuredClone") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "structuredClone") && expressionLooksLikeWindowObjectSource(
@@ -9097,7 +10519,7 @@ function expressionLooksLikeStructuredCloneHelper(expression, sourceFile, namedE
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeStructuredCloneHelper(
       expression.expression,
       sourceFile,
@@ -9106,7 +10528,7 @@ function expressionLooksLikeStructuredCloneHelper(expression, sourceFile, namedE
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9135,7 +10557,7 @@ function expressionLooksLikeStructuredCloneHelper(expression, sourceFile, namedE
 }
 function expressionLooksLikeBrowserGlobalSymbolHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "Symbol") {
+  if (ts3.isIdentifier(expression) && expression.text === "Symbol") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "Symbol") && expressionLooksLikeWindowObjectSource(
@@ -9155,7 +10577,7 @@ function expressionLooksLikeBrowserGlobalSymbolHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalSymbolHelper(
       expression.expression,
       sourceFile,
@@ -9164,7 +10586,7 @@ function expressionLooksLikeBrowserGlobalSymbolHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9193,7 +10615,7 @@ function expressionLooksLikeBrowserGlobalSymbolHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalBigIntHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "BigInt") {
+  if (ts3.isIdentifier(expression) && expression.text === "BigInt") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "BigInt") && expressionLooksLikeWindowObjectSource(
@@ -9213,7 +10635,7 @@ function expressionLooksLikeBrowserGlobalBigIntHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalBigIntHelper(
       expression.expression,
       sourceFile,
@@ -9222,7 +10644,7 @@ function expressionLooksLikeBrowserGlobalBigIntHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9251,7 +10673,7 @@ function expressionLooksLikeBrowserGlobalBigIntHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalBooleanHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "Boolean") {
+  if (ts3.isIdentifier(expression) && expression.text === "Boolean") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "Boolean") && expressionLooksLikeWindowObjectSource(
@@ -9271,7 +10693,7 @@ function expressionLooksLikeBrowserGlobalBooleanHelper(expression, sourceFile, n
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalBooleanHelper(
       expression.expression,
       sourceFile,
@@ -9280,7 +10702,7 @@ function expressionLooksLikeBrowserGlobalBooleanHelper(expression, sourceFile, n
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9309,7 +10731,7 @@ function expressionLooksLikeBrowserGlobalBooleanHelper(expression, sourceFile, n
 }
 function expressionLooksLikeBrowserGlobalNumberHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "Number") {
+  if (ts3.isIdentifier(expression) && expression.text === "Number") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "Number") && expressionLooksLikeWindowObjectSource(
@@ -9329,7 +10751,7 @@ function expressionLooksLikeBrowserGlobalNumberHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalNumberHelper(
       expression.expression,
       sourceFile,
@@ -9338,7 +10760,7 @@ function expressionLooksLikeBrowserGlobalNumberHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9367,7 +10789,7 @@ function expressionLooksLikeBrowserGlobalNumberHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalObjectHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "Object") {
+  if (ts3.isIdentifier(expression) && expression.text === "Object") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "Object") && expressionLooksLikeWindowObjectSource(
@@ -9387,7 +10809,7 @@ function expressionLooksLikeBrowserGlobalObjectHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalObjectHelper(
       expression.expression,
       sourceFile,
@@ -9396,7 +10818,7 @@ function expressionLooksLikeBrowserGlobalObjectHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9425,7 +10847,7 @@ function expressionLooksLikeBrowserGlobalObjectHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalStringHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && expression.text === "String") {
+  if (ts3.isIdentifier(expression) && expression.text === "String") {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "String") && expressionLooksLikeWindowObjectSource(
@@ -9445,7 +10867,7 @@ function expressionLooksLikeBrowserGlobalStringHelper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalStringHelper(
       expression.expression,
       sourceFile,
@@ -9454,7 +10876,7 @@ function expressionLooksLikeBrowserGlobalStringHelper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9483,7 +10905,7 @@ function expressionLooksLikeBrowserGlobalStringHelper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalBase64Helper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && ["atob", "btoa"].includes(expression.text)) {
+  if (ts3.isIdentifier(expression) && ["atob", "btoa"].includes(expression.text)) {
     return true;
   }
   if (isMemberAccessExpression(expression) && isMemberAccessNamed(expression, "atob", "btoa") && expressionLooksLikeWindowObjectSource(
@@ -9503,7 +10925,7 @@ function expressionLooksLikeBrowserGlobalBase64Helper(expression, sourceFile, na
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalBase64Helper(
       expression.expression,
       sourceFile,
@@ -9512,7 +10934,7 @@ function expressionLooksLikeBrowserGlobalBase64Helper(expression, sourceFile, na
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9541,7 +10963,7 @@ function expressionLooksLikeBrowserGlobalBase64Helper(expression, sourceFile, na
 }
 function expressionLooksLikeBrowserGlobalUriCodecHelper(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isIdentifier(expression) && [
+  if (ts3.isIdentifier(expression) && [
     "decodeURI",
     "decodeURIComponent",
     "encodeURI",
@@ -9576,7 +10998,7 @@ function expressionLooksLikeBrowserGlobalUriCodecHelper(expression, sourceFile,
   )) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeBrowserGlobalUriCodecHelper(
       expression.expression,
       sourceFile,
@@ -9585,7 +11007,7 @@ function expressionLooksLikeBrowserGlobalUriCodecHelper(expression, sourceFile,
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9624,7 +11046,7 @@ function expressionLooksLikeLocationUrlSource(expression, sourceFile, namedExpre
   if (LOCATION_URL_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationUrlSource(
       expression.expression,
       sourceFile,
@@ -9633,7 +11055,7 @@ function expressionLooksLikeLocationUrlSource(expression, sourceFile, namedExpre
       seenIdentifiers
     );
   }
-  if (ts.isNewExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "URL") {
+  if (ts3.isNewExpression(expression) && ts3.isIdentifier(expression.expression) && expression.expression.text === "URL") {
     return expressionLooksLikeLocationUrlInput(
       expression.arguments?.[0],
       sourceFile,
@@ -9642,7 +11064,7 @@ function expressionLooksLikeLocationUrlSource(expression, sourceFile, namedExpre
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -9664,7 +11086,7 @@ function expressionLooksLikeLocationUrlInput(expression, sourceFile, namedExpres
   if (LOCATION_URL_INPUT_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationUrlInput(
       expression.expression,
       sourceFile,
@@ -9682,7 +11104,7 @@ function expressionLooksLikeLocationUrlInput(expression, sourceFile, namedExpres
   )) {
     return true;
   }
-  if (isCallLikeExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "String" && expression.arguments.length > 0 && (expressionLooksLikeLocationObjectSource(
+  if (isCallLikeExpression(expression) && ts3.isIdentifier(expression.expression) && expression.expression.text === "String" && expression.arguments.length > 0 && (expressionLooksLikeLocationObjectSource(
     expression.arguments[0],
     sourceFile,
     namedExpressions,
@@ -9735,7 +11157,7 @@ function expressionLooksLikeLocationUrlInput(expression, sourceFile, namedExpres
   )) {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9782,7 +11204,7 @@ function expressionLooksLikeRequestObjectSource(expression, sourceFile, namedExp
   if (REQUEST_OBJECT_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeRequestObjectSource(
       expression.expression,
       sourceFile,
@@ -9790,7 +11212,7 @@ function expressionLooksLikeRequestObjectSource(expression, sourceFile, namedExp
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return false;
@@ -9811,7 +11233,7 @@ function expressionLooksLikeNextUrlSource(expression, sourceFile, namedExpressio
   if (NEXT_URL_SOURCE_REGEX.test(expression.getText(sourceFile))) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeNextUrlSource(
       expression.expression,
       sourceFile,
@@ -9837,7 +11259,7 @@ function expressionLooksLikeNextUrlSource(expression, sourceFile, namedExpressio
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9871,7 +11293,7 @@ function expressionLooksLikeOpenRedirectSearchParamsCarrier(expression, sourceFi
   if (/\b(?:searchParams|(?:request|req)\.nextUrl\.searchParams|url\.searchParams)\b/i.test(text)) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeOpenRedirectSearchParamsCarrier(
       expression.expression,
       sourceFile,
@@ -9880,7 +11302,7 @@ function expressionLooksLikeOpenRedirectSearchParamsCarrier(expression, sourceFi
       seenIdentifiers
     );
   }
-  if (ts.isNewExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "URLSearchParams") {
+  if (ts3.isNewExpression(expression) && ts3.isIdentifier(expression.expression) && expression.expression.text === "URLSearchParams") {
     return expressionLooksLikeLocationQuerySource(
       expression.arguments?.[0],
       sourceFile,
@@ -9889,7 +11311,7 @@ function expressionLooksLikeOpenRedirectSearchParamsCarrier(expression, sourceFi
       seenIdentifiers
     );
   }
-  if (isCallLikeExpression(expression) && (ts.isIdentifier(expression.expression) && expression.expression.text === "useSearchParams" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useSearchParams"))) {
+  if (isCallLikeExpression(expression) && (ts3.isIdentifier(expression.expression) && expression.expression.text === "useSearchParams" || isMemberAccessExpression(expression.expression) && isMemberAccessNamed(expression.expression, "useSearchParams"))) {
     return true;
   }
   if (isPropertyLikeAccessExpression(expression) && isPropertyNamed(expression.name, "searchParams")) {
@@ -9907,7 +11329,7 @@ function expressionLooksLikeOpenRedirectSearchParamsCarrier(expression, sourceFi
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -9947,7 +11369,7 @@ function expressionLooksLikeLocationAssignmentTarget(expression, sourceFile, nam
   if (isLocationAssignmentTarget(expression)) {
     return true;
   }
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationAssignmentTarget(
       expression.expression,
       sourceFile,
@@ -9969,7 +11391,7 @@ function expressionLooksLikeLocationAssignmentTarget(expression, sourceFile, nam
 }
 function expressionLooksLikeLocationMutationCall(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeLocationMutationCall(
       expression.expression,
       sourceFile,
@@ -9996,7 +11418,7 @@ function expressionLooksLikeLocationMutationCall(expression, sourceFile, namedEx
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10035,7 +11457,7 @@ function expressionLooksLikeLocationMutationCall(expression, sourceFile, namedEx
 }
 function expressionLooksLikeWindowOpenCall(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeWindowOpenCall(
       expression.expression,
       sourceFile,
@@ -10053,10 +11475,10 @@ function expressionLooksLikeWindowOpenCall(expression, sourceFile, namedExpressi
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression) && expression.text === "open") {
+  if (ts3.isIdentifier(expression) && expression.text === "open") {
     return true;
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10092,7 +11514,7 @@ function expressionLooksLikeWindowOpenCall(expression, sourceFile, namedExpressi
 }
 function expressionLooksLikeHistoryMutationCall(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeHistoryMutationCall(
       expression.expression,
       sourceFile,
@@ -10119,7 +11541,7 @@ function expressionLooksLikeHistoryMutationCall(expression, sourceFile, namedExp
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return false;
     const initializer = namedExpressions.get(expression.text);
     if (initializer) {
@@ -10158,7 +11580,7 @@ function expressionLooksLikeHistoryMutationCall(expression, sourceFile, namedExp
 }
 function expressionLooksLikeRouteTransitionCall(expression, sourceFile, namedExpressions, namedPropertyAliases, seenIdentifiers) {
   if (!expression) return false;
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return expressionLooksLikeRouteTransitionCall(
       expression.expression,
       sourceFile,
@@ -10185,7 +11607,7 @@ function expressionLooksLikeRouteTransitionCall(expression, sourceFile, namedExp
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (["redirect", "navigate"].includes(expression.text)) {
       return true;
     }
@@ -10231,7 +11653,7 @@ function expressionLooksLikeRouteTransitionCall(expression, sourceFile, namedExp
   );
 }
 function getRouteTransitionTargetExpression(node, sourceFile, namedExpressions, namedPropertyAliases) {
-  if (isMemberAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeRouteTransitionCall(
+  if (isMemberAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeRouteTransitionCall(
     node.arguments[0],
     sourceFile,
     namedExpressions,
@@ -10276,7 +11698,7 @@ function getRouteTransitionTargetExpression(node, sourceFile, namedExpressions,
   )) {
     return getAliasedApplyArgumentExpression(node.arguments[1], 2, namedExpressions, /* @__PURE__ */ new Set());
   }
-  if (isMemberAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeHistoryMutationCall(
+  if (isMemberAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeHistoryMutationCall(
     node.arguments[0],
     sourceFile,
     namedExpressions,
@@ -10307,7 +11729,7 @@ function getRouteTransitionTargetExpression(node, sourceFile, namedExpressions,
 }
 function getAliasedApplyArgumentExpression(expression, index, namedExpressions, seenIdentifiers) {
   if (!expression) return void 0;
-  if (ts.isParenthesizedExpression(expression) || ts.isAsExpression(expression) || ts.isTypeAssertionExpression(expression) || ts.isNonNullExpression(expression)) {
+  if (ts3.isParenthesizedExpression(expression) || ts3.isAsExpression(expression) || ts3.isTypeAssertionExpression(expression) || ts3.isNonNullExpression(expression)) {
     return getAliasedApplyArgumentExpression(
       expression.expression,
       index,
@@ -10315,7 +11737,7 @@ function getAliasedApplyArgumentExpression(expression, index, namedExpressions,
       seenIdentifiers
     );
   }
-  if (ts.isIdentifier(expression)) {
+  if (ts3.isIdentifier(expression)) {
     if (seenIdentifiers.has(expression.text)) return void 0;
     const initializer = namedExpressions.get(expression.text);
     if (!initializer) return void 0;
@@ -10329,12 +11751,12 @@ function getAliasedApplyArgumentExpression(expression, index, namedExpressions,
     seenIdentifiers.delete(expression.text);
     return result;
   }
-  if (!ts.isArrayLiteralExpression(expression)) return void 0;
+  if (!ts3.isArrayLiteralExpression(expression)) return void 0;
   const argument = expression.elements[index];
-  return ts.isExpression(argument) ? argument : void 0;
+  return ts3.isExpression(argument) ? argument : void 0;
 }
 function getLocationMutationTargetExpression(node, sourceFile, namedExpressions, namedPropertyAliases) {
-  if (isMemberAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeLocationMutationCall(
+  if (isMemberAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeLocationMutationCall(
     node.arguments[0],
     sourceFile,
     namedExpressions,
@@ -10373,7 +11795,7 @@ function getLocationMutationTargetExpression(node, sourceFile, namedExpressions,
   return void 0;
 }
 function getWindowOpenTargetExpression(node, sourceFile, namedExpressions, namedPropertyAliases) {
-  if (isMemberAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeWindowOpenCall(
+  if (isMemberAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "Reflect" && isMemberAccessNamed(node.expression, "apply") && expressionLooksLikeWindowOpenCall(
     node.arguments[0],
     sourceFile,
     namedExpressions,
@@ -10512,28 +11934,28 @@ var DYNAMIC_GEOMETRY_STYLE_PROPS = /* @__PURE__ */ new Set([
   "y"
 ]);
 function getJsxAttributeExpression(initializer) {
-  if (!initializer || !ts.isJsxExpression(initializer)) return null;
+  if (!initializer || !ts3.isJsxExpression(initializer)) return null;
   return initializer.expression ?? null;
 }
 function getStylePropertyName(name) {
-  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+  if (ts3.isIdentifier(name) || ts3.isStringLiteral(name) || ts3.isNumericLiteral(name)) {
     return name.text;
   }
-  if (ts.isComputedPropertyName(name)) {
+  if (ts3.isComputedPropertyName(name)) {
     return getExpressionLiteralValue(name.expression);
   }
   return null;
 }
 function unwrapStyleExpression(expression) {
   let current = expression;
-  while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isTypeAssertionExpression(current) || ts.isNonNullExpression(current) || ts.isSatisfiesExpression(current)) {
+  while (ts3.isParenthesizedExpression(current) || ts3.isAsExpression(current) || ts3.isTypeAssertionExpression(current) || ts3.isNonNullExpression(current) || ts3.isSatisfiesExpression(current)) {
     current = current.expression;
   }
   return current;
 }
 function isDynamicStyleValue(expression) {
   const unwrapped = unwrapStyleExpression(expression);
-  if (ts.isStringLiteral(unwrapped) || ts.isNoSubstitutionTemplateLiteral(unwrapped) || ts.isNumericLiteral(unwrapped) || unwrapped.kind === ts.SyntaxKind.TrueKeyword || unwrapped.kind === ts.SyntaxKind.FalseKeyword || unwrapped.kind === ts.SyntaxKind.NullKeyword) {
+  if (ts3.isStringLiteral(unwrapped) || ts3.isNoSubstitutionTemplateLiteral(unwrapped) || ts3.isNumericLiteral(unwrapped) || unwrapped.kind === ts3.SyntaxKind.TrueKeyword || unwrapped.kind === ts3.SyntaxKind.FalseKeyword || unwrapped.kind === ts3.SyntaxKind.NullKeyword) {
     return false;
   }
   return true;
@@ -10542,13 +11964,13 @@ function isAllowedInlineStyleObject(objectLiteral) {
   let sawGeometryProperty = false;
   let sawDynamicGeometryValue = false;
   for (const property of objectLiteral.properties) {
-    if (!ts.isPropertyAssignment(property)) return false;
-    const propertyName = getStylePropertyName(property.name);
-    if (!propertyName) return false;
-    if (propertyName.startsWith("--d-")) {
+    if (!ts3.isPropertyAssignment(property)) return false;
+    const propertyName2 = getStylePropertyName(property.name);
+    if (!propertyName2) return false;
+    if (propertyName2.startsWith("--d-")) {
       continue;
     }
-    if (!DYNAMIC_GEOMETRY_STYLE_PROPS.has(propertyName)) {
+    if (!DYNAMIC_GEOMETRY_STYLE_PROPS.has(propertyName2)) {
       return false;
     }
     sawGeometryProperty = true;
@@ -10571,10 +11993,10 @@ function isAllowedInlineStyleAttribute(attribute, sourceFile, namedExpressions,
   return resolved ? isAllowedInlineStyleObject(resolved.objectLiteral) : false;
 }
 function analyzeAstSignals(filePath, code) {
-  const sourceFile = ts.createSourceFile(
+  const sourceFile = ts3.createSourceFile(
     filePath,
     code,
-    ts.ScriptTarget.Latest,
+    ts3.ScriptTarget.Latest,
     true,
     getScriptKind(filePath)
   );
@@ -10659,7 +12081,7 @@ function analyzeAstSignals(filePath, code) {
   let navigationLandmarkCount = 0;
   let unlabeledNavigationLandmarkCount = 0;
   const walk = (node) => {
-    if (ts.isJsxAttribute(node)) {
+    if (ts3.isJsxAttribute(node)) {
       if (isPropertyNamed(node.name, "style") && node.initializer) {
         if (!isAllowedInlineStyleAttribute(
           node,
@@ -10673,7 +12095,7 @@ function analyzeAstSignals(filePath, code) {
       if (isPropertyNamed(node.name, "dangerouslySetInnerHTML") && !isSafeJsonLdDangerouslySetInnerHtml(node)) {
         signals.dangerousHtmlCount += 1;
       }
-      if (isPropertyNamed(node.name, "href", "to") && node.initializer && ts.isJsxExpression(node.initializer) && expressionContainsOpenRedirectSource(
+      if (isPropertyNamed(node.name, "href", "to") && node.initializer && ts3.isJsxExpression(node.initializer) && expressionContainsOpenRedirectSource(
         node.initializer.expression,
         sourceFile,
         namedExpressionInitializers,
@@ -10691,10 +12113,10 @@ function analyzeAstSignals(filePath, code) {
         signals.authProviderNonceMissingCount += 1;
       }
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && isPropertyNamed(node.left.name, "innerHTML", "outerHTML")) {
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && ts3.isPropertyAccessExpression(node.left) && isPropertyNamed(node.left.name, "innerHTML", "outerHTML")) {
       signals.rawHtmlInjectionCount += 1;
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
       node.left,
       sourceFile,
       namedExpressionInitializers,
@@ -10708,7 +12130,7 @@ function analyzeAstSignals(filePath, code) {
     )) {
       signals.authOpenRedirectSignalCount += 1;
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
       node.left,
       sourceFile,
       namedExpressionInitializers,
@@ -10717,7 +12139,7 @@ function analyzeAstSignals(filePath, code) {
     ) && isInsecureTransportUrl(getExpressionLiteralValue(node.right))) {
       signals.insecureTransportEndpointCount += 1;
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
       node.left,
       sourceFile,
       namedExpressionInitializers,
@@ -10735,7 +12157,7 @@ function analyzeAstSignals(filePath, code) {
         signals.authProviderNonceMissingCount += 1;
       }
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && expressionLooksLikeLocationAssignmentTarget(
       node.left,
       sourceFile,
       namedExpressionInitializers,
@@ -10749,36 +12171,36 @@ function analyzeAstSignals(filePath, code) {
     )) {
       signals.authOpenRedirectSignalCount += 1;
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && isPropertyNamed(node.left.name, "onmessage")) {
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && ts3.isPropertyAccessExpression(node.left) && isPropertyNamed(node.left.name, "onmessage")) {
       const handler = resolveFunctionLikeHandler(node.right, namedFunctionDeclarations);
       if (handler && !functionLikeReferencesOrigin(handler)) {
         signals.messageListenerWithoutOriginCheckCount += 1;
       }
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && isBrowserStorageObject(node.left.expression) && /(?:token|auth|jwt|session)/i.test(node.left.name.text)) {
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && ts3.isPropertyAccessExpression(node.left) && isBrowserStorageObject(node.left.expression) && /(?:token|auth|jwt|session)/i.test(node.left.name.text)) {
       signals.authStorageWriteCount += 1;
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isElementAccessExpression(node.left) && isBrowserStorageObject(node.left.expression) && isAuthStorageKeyLiteral(node.left.argumentExpression)) {
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && ts3.isElementAccessExpression(node.left) && isBrowserStorageObject(node.left.expression) && isAuthStorageKeyLiteral(node.left.argumentExpression)) {
       signals.authStorageWriteCount += 1;
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && isCookiePropertyAccess(node.left) && hasAuthCredentialText(node.right, sourceFile)) {
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && isCookiePropertyAccess(node.left) && hasAuthCredentialText(node.right, sourceFile)) {
       signals.authCookieWriteCount += 1;
     }
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && isAuthorizationHeaderAccess(node.left)) {
+    if (ts3.isBinaryExpression(node) && node.operatorToken.kind === ts3.SyntaxKind.EqualsToken && isAuthorizationHeaderAccess(node.left)) {
       if (isHeaderClearValue(node.right)) {
         signals.authHeaderClearCount += 1;
       } else {
         signals.authHeaderWriteCount += 1;
       }
     }
-    if (ts.isPropertyAssignment(node) && isAuthorizationHeaderName(node.name)) {
+    if (ts3.isPropertyAssignment(node) && isAuthorizationHeaderName(node.name)) {
       if (isHeaderClearValue(node.initializer)) {
         signals.authHeaderClearCount += 1;
       } else {
         signals.authHeaderWriteCount += 1;
       }
     }
-    if (ts.isDeleteExpression(node) && isAuthorizationHeaderAccess(node.expression)) {
+    if (ts3.isDeleteExpression(node) && isAuthorizationHeaderAccess(node.expression)) {
       signals.authHeaderClearCount += 1;
     }
     if (isCallLikeExpression(node)) {
@@ -10809,10 +12231,10 @@ function analyzeAstSignals(filePath, code) {
         namedPropertyAliases
       );
       const windowOpenTargetLiteral = getExpressionLiteralValue(windowOpenTargetExpression);
-      if (ts.isIdentifier(node.expression) && node.expression.text === "eval") {
+      if (ts3.isIdentifier(node.expression) && node.expression.text === "eval") {
         signals.dynamicEvalCount += 1;
       }
-      if ((ts.isIdentifier(node.expression) && ["setTimeout", "setInterval"].includes(node.expression.text) || ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && isPropertyNamed(node.expression.name, "setTimeout", "setInterval")) && typeof firstArgumentLiteral === "string") {
+      if ((ts3.isIdentifier(node.expression) && ["setTimeout", "setInterval"].includes(node.expression.text) || ts3.isPropertyAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && isPropertyNamed(node.expression.name, "setTimeout", "setInterval")) && typeof firstArgumentLiteral === "string") {
         signals.dynamicEvalCount += 1;
       }
       if ((isFetchLikeCall(node) || isAxiosLikeCall(node)) && isInsecureTransportUrl(firstArgumentLiteral)) {
@@ -10894,7 +12316,7 @@ function analyzeAstSignals(filePath, code) {
           signals.authProviderNonceMissingCount += 1;
         }
       }
-      if (ts.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "postMessage") && secondArgumentLiteral === "*") {
+      if (ts3.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "postMessage") && secondArgumentLiteral === "*") {
         signals.wildcardPostMessageCount += 1;
       }
       if (isAddEventListenerCall(node) && firstArgumentLiteral === "message") {
@@ -10903,7 +12325,7 @@ function analyzeAstSignals(filePath, code) {
           signals.messageListenerWithoutOriginCheckCount += 1;
         }
       }
-      if (ts.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "setHeader", "append", "set") && isSetCookieHeaderName(node.arguments[0])) {
+      if (ts3.isPropertyAccessExpression(node.expression) && isPropertyNamed(node.expression.name, "setHeader", "append", "set") && isSetCookieHeaderName(node.arguments[0])) {
         const cookieStrings = collectCookieHeaderStrings(node.arguments[1]);
         const authCookieStrings = cookieStrings.filter(cookieHeaderStringLooksAuthLike);
         if (authCookieStrings.length > 0) {
@@ -10921,13 +12343,13 @@ function analyzeAstSignals(filePath, code) {
           }
         }
       }
-      if ((ts.isIdentifier(node.expression) && node.expression.text === "open" || ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && isPropertyNamed(node.expression.name, "open")) && secondArgumentLiteral === "_blank") {
+      if ((ts3.isIdentifier(node.expression) && node.expression.text === "open" || ts3.isPropertyAccessExpression(node.expression) && ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "window" && isPropertyNamed(node.expression.name, "open")) && secondArgumentLiteral === "_blank") {
         const featureLiteral = getExpressionLiteralValue(node.arguments[2])?.toLowerCase() ?? "";
         if (!featureLiteral.includes("noopener") || !featureLiteral.includes("noreferrer")) {
           signals.windowOpenWithoutNoopenerCount += 1;
         }
       }
-      if (ts.isPropertyAccessExpression(node.expression)) {
+      if (ts3.isPropertyAccessExpression(node.expression)) {
         if (isPropertyNamed(node.expression.name, "insertAdjacentHTML")) {
           signals.rawHtmlInjectionCount += 1;
         }
@@ -10936,7 +12358,7 @@ function analyzeAstSignals(filePath, code) {
         }
         if (isCookieMutationSetCall(node)) {
           const firstArgument = node.arguments[0];
-          const isObjectConfigCall = ts.isObjectLiteralExpression(firstArgument);
+          const isObjectConfigCall = ts3.isObjectLiteralExpression(firstArgument);
           const isAuthCookieWrite = isObjectConfigCall ? objectLiteralLooksLikeAuthCookieConfig(firstArgument, sourceFile) : expressionLooksLikeAuthCookieName(firstArgument, sourceFile);
           if (isAuthCookieWrite) {
             signals.authCookieWriteCount += 1;
@@ -10956,7 +12378,7 @@ function analyzeAstSignals(filePath, code) {
             signals.authHeaderWriteCount += 1;
           }
         }
-        if (ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "document" && isPropertyNamed(node.expression.name, "write")) {
+        if (ts3.isIdentifier(node.expression.expression) && node.expression.expression.text === "document" && isPropertyNamed(node.expression.name, "write")) {
           signals.rawHtmlInjectionCount += 1;
         }
         if (isPropertyNamed(node.expression.name, "eval")) {
@@ -10964,16 +12386,16 @@ function analyzeAstSignals(filePath, code) {
         }
       }
     }
-    if (ts.isNewExpression(node) && isRealtimeTransportConstructor(node) && isInsecureTransportUrl(getExpressionLiteralValue(node.arguments?.[0]))) {
+    if (ts3.isNewExpression(node) && isRealtimeTransportConstructor(node) && isInsecureTransportUrl(getExpressionLiteralValue(node.arguments?.[0]))) {
       signals.insecureTransportEndpointCount += 1;
     }
-    if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "Function") {
+    if (ts3.isNewExpression(node) && ts3.isIdentifier(node.expression) && node.expression.text === "Function") {
       signals.dynamicEvalCount += 1;
     }
-    if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && ["WebSocket", "EventSource"].includes(node.expression.text) && isInsecureTransportUrl(getExpressionLiteralValue(node.arguments?.[0]))) {
+    if (ts3.isNewExpression(node) && ts3.isIdentifier(node.expression) && ["WebSocket", "EventSource"].includes(node.expression.text) && isInsecureTransportUrl(getExpressionLiteralValue(node.arguments?.[0]))) {
       signals.insecureTransportEndpointCount += 1;
     }
-    if (ts.isJsxSelfClosingElement(node)) {
+    if (ts3.isJsxSelfClosingElement(node)) {
       const tagName = getJsxTagName(node);
       if (hasMainLandmarkSignal(node.attributes, tagName)) {
         signals.mainLandmarkCount += 1;
@@ -11066,7 +12488,7 @@ function analyzeAstSignals(filePath, code) {
         signals.formControlWithoutLabelCount += 1;
       }
     }
-    if (ts.isJsxElement(node)) {
+    if (ts3.isJsxElement(node)) {
       const tagName = getJsxTagName(node.openingElement);
       const textContent = getJsxTextContent(node).replace(/\s+/g, " ").trim();
       if (hasMainLandmarkSignal(node.openingElement.attributes, tagName)) {
@@ -11182,7 +12604,7 @@ function analyzeAstSignals(filePath, code) {
         signals.formControlWithoutLabelCount += 1;
       }
     }
-    ts.forEachChild(node, walk);
+    ts3.forEachChild(node, walk);
   };
   walk(sourceFile);
   signals.unlabeledNavigationLandmarkCount = navigationLandmarkCount > 1 ? unlabeledNavigationLandmarkCount : 0;
@@ -12936,10 +14358,10 @@ function critiqueSource({
   };
 }
 function resolveProjectFilePath(projectRoot, filePath) {
-  const root = existsSync3(projectRoot) ? realpathSync.native(projectRoot) : resolve(projectRoot);
+  const root = existsSync4(projectRoot) ? realpathSync.native(projectRoot) : resolve(projectRoot);
   const candidatePath = isAbsolute2(filePath) ? resolve(filePath) : resolve(root, filePath);
-  const resolvedPath = existsSync3(candidatePath) ? realpathSync.native(candidatePath) : candidatePath;
-  const relativePath = relative2(root, resolvedPath);
+  const resolvedPath = existsSync4(candidatePath) ? realpathSync.native(candidatePath) : candidatePath;
+  const relativePath = relative4(root, resolvedPath);
   if (relativePath.startsWith("..") || isAbsolute2(relativePath)) {
     throw new Error(`Path escapes the project root: ${filePath}`);
   }
@@ -12948,7 +14370,7 @@ function resolveProjectFilePath(projectRoot, filePath) {
 async function critiqueFile(filePath, projectRoot) {
   const resolvedPath = resolveProjectFilePath(projectRoot, filePath);
   const code = await readFile(resolvedPath, "utf-8");
-  const treatmentsCss = readTextIfExists(join3(projectRoot, "src", "styles", "treatments.css"));
+  const treatmentsCss = readTextIfExists(join4(projectRoot, "src", "styles", "treatments.css"));
   const reviewPack = loadReviewPack(projectRoot);
   const packManifest = loadPackManifest(projectRoot);
   const adoptionMode = readProjectAdoptionMode(projectRoot);
@@ -12962,23 +14384,34 @@ async function critiqueFile(filePath, projectRoot) {
   });
 }
 export {
+  COMPONENT_REUSE_RULE_ID,
   EVIDENCE_BUNDLE_SCHEMA_URL,
   INTERACTION_SIGNALS,
+  KNOWN_VERIFICATION_DIAGNOSTICS,
+  RAW_CONTROL_REUSE_RULE_ID,
   SCAN_REPORT_SCHEMA_URL,
+  STYLE_BRIDGE_ARBITRARY_VALUE_RULE_ID,
   VERIFICATION_SCHEMA_URLS,
+  anchorFindingsToGraph,
   auditBuiltDist,
+  auditComponentReuse,
   auditProject,
+  auditStyleBridgeDrift,
+  buildProjectHealthRepairPlan,
   collectMissingPackManifestFiles,
+  collectProjectSourceFiles,
   createContractAssertions,
   createEvidenceBundle,
   createUnavailableScanReport,
   critiqueFile,
   critiqueSource,
+  deriveVerificationDiagnostic,
   emptyRuntimeAudit,
   extractRouteHintsFromEssence,
   listKnownInteractions,
   probePublishedSite,
   resolveGitHubScanInput,
+  resolveGraphAnchorForFinding,
   scanProject,
   verifyInteractionsInSource
 };