@vibgrate/cli 2026.708.3 → 2026.709.2

package/dist/chunk-FU4MOQTC.js

@@ -0,0 +1,3735 @@
+import { runCoreScan, writeJsonFile, compactUiPurpose } from './chunk-PIWHQSAR.js';
+import { findPackageJsonFiles, readJsonFile, findFiles, readTextFile, pathExists } from './chunk-GI6W53LM.js';
+import * as path3 from 'path';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import * as semver from 'semver';
+import * as fs from 'fs/promises';
+
+var NATIVE_MODULE_PACKAGES = /* @__PURE__ */ new Set([
+  // Image / media processing
+  "sharp",
+  // libvips native bindings
+  "canvas",
+  // node-canvas (Cairo native)
+  "jimp",
+  // pure JS but optionally uses native
+  "@napi-rs/image",
+  // NAPI-RS image processing
+  "imagemagick",
+  // ImageMagick bindings
+  "gm",
+  // GraphicsMagick
+  "fluent-ffmpeg",
+  // FFmpeg bindings
+  "ffmpeg-static",
+  // bundled FFmpeg binary
+  "puppeteer",
+  // ships Chromium binary
+  "playwright",
+  // ships browser binaries
+  "playwright-core",
+  // browser binaries
+  // Cryptography / security
+  "bcrypt",
+  // native bcrypt
+  "argon2",
+  // native argon2 hashing
+  "sodium-native",
+  // libsodium bindings
+  "libsodium-wrappers",
+  // libsodium WASM/native
+  "node-forge",
+  // mostly JS but linked to native in some envs
+  "ssh2",
+  // native SSH bindings (optional)
+  "keytar",
+  // OS keychain native bindings
+  // Database drivers
+  "better-sqlite3",
+  // native SQLite
+  "sqlite3",
+  // native SQLite
+  "pg-native",
+  // PostgreSQL native bindings
+  "oracledb",
+  // Oracle native client
+  "odbc",
+  // native ODBC
+  "ibm_db",
+  // IBM DB2 native
+  "couchbase",
+  // native Couchbase SDK
+  "rocksdb",
+  // native RocksDB store
+  "leveldown",
+  // native LevelDB
+  "lmdb",
+  // native LMDB bindings
+  // Compilation & build tools
+  "node-gyp",
+  // native build tool itself
+  "node-pre-gyp",
+  // native binary distribution
+  "@mapbox/node-pre-gyp",
+  // native binary distribution
+  "prebuild",
+  // prebuilt native bindings
+  "prebuild-install",
+  // prebuilt native installer
+  "esbuild",
+  // platform-specific Go binary
+  "@swc/core",
+  // platform-specific Rust binary
+  "@rspack/core",
+  // platform-specific Rust binary
+  "@biomejs/biome",
+  // platform-specific Rust binary
+  "node-sass",
+  // deprecated, native libsass
+  "sass-embedded",
+  // Dart Sass embedded binary
+  "turbo",
+  // Turborepo Go/Rust binary
+  "@vercel/nft",
+  // native file tracing (optional)
+  // System / hardware access
+  "fsevents",
+  // macOS-only file watching
+  "cpu-features",
+  // CPU instruction detection
+  "deasync",
+  // native event loop control
+  "usb",
+  // USB device access
+  "serialport",
+  // serial port access
+  "node-hid",
+  // HID device access
+  "i2c-bus",
+  // I2C bus access
+  "spi-device",
+  // SPI bus access
+  "node-bluetooth",
+  // Bluetooth
+  "mdns",
+  // mDNS/Bonjour
+  // Compression
+  "snappy",
+  // native Snappy compression
+  "zstd-napi",
+  // native Zstandard
+  "lz4",
+  // native LZ4
+  "brotli",
+  // native Brotli (older, node has built-in)
+  // Regex / text
+  "re2",
+  // native RE2 regex engine
+  "oniguruma",
+  // native Oniguruma regex
+  "vscode-oniguruma",
+  // native Oniguruma (VS Code)
+  "tree-sitter",
+  // native parser generator
+  "node-tree-sitter",
+  // native Tree-sitter
+  // XML / HTML
+  "libxmljs",
+  // native libxml2
+  "libxmljs2",
+  // native libxml2
+  "node-expat",
+  // native Expat XML parser
+  "htmlparser2",
+  // mostly JS, optional native
+  // Networking / IPC
+  "@grpc/grpc-js",
+  // gRPC (JS but has native dep for HTTP/2)
+  "grpc",
+  // deprecated native gRPC
+  "zeromq",
+  // native ZeroMQ
+  "nanomsg",
+  // native nanomsg
+  "unix-dgram",
+  // native Unix sockets
+  // Observability
+  "dtrace-provider",
+  // native DTrace
+  "v8-profiler-next",
+  // native V8 profiler
+  "heapdump",
+  // native V8 heap dump
+  // Misc
+  "farmhash",
+  // native FarmHash
+  "xxhash",
+  // native xxHash
+  "xxhash-addon",
+  // native xxHash
+  "iconv",
+  // native iconv
+  "ref-napi",
+  // native FFI
+  "ffi-napi",
+  // native FFI
+  "node-pty",
+  // native pseudo-terminal
+  "robotjs",
+  // native desktop automation
+  "electron",
+  // ships Chromium + Node binary
+  "xdg-open",
+  // OS-specific
+  "windows-process-tree"
+  // Windows-only
+]);
+var OS_PATTERNS = [
+  { pattern: /\bcmd\.exe\b|\.bat\b|\.cmd\b/i, label: "windows-scripts" },
+  { pattern: /\bpowershell\b|\bpwsh\b/i, label: "powershell" },
+  { pattern: /\bbash\b|#!\/bin\/bash/i, label: "bash-scripts" },
+  { pattern: /\\\\/g, label: "backslash-paths" }
+];
+async function scanPlatformMatrix(rootDir, cache) {
+  const result = {
+    dotnetTargetFrameworks: [],
+    nativeModules: [],
+    osAssumptions: [],
+    dockerBaseImages: [],
+    nodeVersionFiles: []
+  };
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
+  const allDeps = /* @__PURE__ */ new Set();
+  const osAssumptions = /* @__PURE__ */ new Set();
+  for (const pjPath of pkgFiles) {
+    try {
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
+      if (pj.engines?.node && !result.nodeEngines) result.nodeEngines = pj.engines.node;
+      if (pj.engines?.npm && !result.npmEngines) result.npmEngines = pj.engines.npm;
+      if (pj.engines?.pnpm && !result.pnpmEngines) {
+        result.pnpmEngines = pj.engines.pnpm;
+      }
+      for (const section of ["dependencies", "devDependencies", "optionalDependencies"]) {
+        const deps = pj[section];
+        if (deps) {
+          for (const name of Object.keys(deps)) {
+            allDeps.add(name);
+          }
+        }
+      }
+      const scripts = pj.scripts;
+      if (scripts && typeof scripts === "object") {
+        for (const val of Object.values(scripts)) {
+          if (typeof val !== "string") continue;
+          const firstToken = val.split(/\s/)[0] ?? "";
+          for (const { pattern, label } of OS_PATTERNS) {
+            if (pattern.test(firstToken)) {
+              osAssumptions.add(label);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  for (const dep of allDeps) {
+    if (NATIVE_MODULE_PACKAGES.has(dep)) {
+      result.nativeModules.push(dep);
+    }
+  }
+  result.nativeModules.sort();
+  result.osAssumptions = [...osAssumptions].sort();
+  const csprojFiles = cache ? await cache.findFiles(rootDir, (name) => name.endsWith(".csproj") || name.endsWith(".vbproj")) : await findFiles(rootDir, (name) => name.endsWith(".csproj") || name.endsWith(".vbproj"));
+  const tfms = /* @__PURE__ */ new Set();
+  for (const csprojPath of csprojFiles) {
+    try {
+      const xml = cache ? await cache.readTextFile(csprojPath) : await readTextFile(csprojPath);
+      const tfMatch = xml.match(/<TargetFramework>(.*?)<\/TargetFramework>/);
+      if (tfMatch?.[1]) tfms.add(tfMatch[1]);
+      const tfsMatch = xml.match(/<TargetFrameworks>(.*?)<\/TargetFrameworks>/);
+      if (tfsMatch?.[1]) {
+        for (const tfm of tfsMatch[1].split(";")) {
+          if (tfm.trim()) tfms.add(tfm.trim());
+        }
+      }
+    } catch {
+    }
+  }
+  result.dotnetTargetFrameworks = [...tfms].sort();
+  const dockerfiles = cache ? await cache.findFiles(
+    rootDir,
+    (name) => name === "Dockerfile" || name.startsWith("Dockerfile.")
+  ) : await findFiles(
+    rootDir,
+    (name) => name === "Dockerfile" || name.startsWith("Dockerfile.")
+  );
+  const baseImages = /* @__PURE__ */ new Set();
+  for (const df of dockerfiles) {
+    try {
+      const content = cache ? await cache.readTextFile(df) : await readTextFile(df);
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (/^FROM\s+/i.test(trimmed)) {
+          const parts = trimmed.split(/\s+/);
+          if (parts[1] && !parts[1].startsWith("--")) {
+            baseImages.add(parts[1]);
+          } else if (parts[1]?.startsWith("--")) {
+            const imageIdx = parts[1].includes("=") ? 2 : 3;
+            if (parts[imageIdx]) baseImages.add(parts[imageIdx]);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  result.dockerBaseImages = [...baseImages].sort();
+  for (const file of [".nvmrc", ".node-version", ".tool-versions"]) {
+    const exists = cache ? await cache.pathExists(path3.join(rootDir, file)) : await pathExists(path3.join(rootDir, file));
+    if (exists) {
+      result.nodeVersionFiles.push(file);
+    }
+  }
+  return result;
+}
+
+// src/reporting/scanners/dependency-risk.ts
+var DEPRECATED_PACKAGES = /* @__PURE__ */ new Set([
+  "request",
+  "node-sass",
+  "tslint",
+  "istanbul",
+  "popper.js",
+  "Left-pad",
+  "left-pad",
+  "bower",
+  "grunt",
+  "gulp",
+  "coffee-script",
+  "coffeescript",
+  "merge",
+  "nomnom",
+  "optimist",
+  "natives",
+  "querystring",
+  "domain-browser",
+  "sys",
+  "punycode"
+]);
+var NATIVE_MODULE_PACKAGES2 = /* @__PURE__ */ new Set([
+  "sharp",
+  "canvas",
+  "bcrypt",
+  "node-gyp",
+  "fsevents",
+  "better-sqlite3",
+  "sqlite3",
+  "leveldown",
+  "sodium-native",
+  "node-sass",
+  "argon2",
+  "usb",
+  "serialport",
+  "re2",
+  "libxmljs",
+  "libxmljs2",
+  "cpu-features",
+  "deasync",
+  "farmhash",
+  "grpc",
+  "@grpc/grpc-js"
+]);
+function scanDependencyRisk(projects) {
+  const deprecated = /* @__PURE__ */ new Set();
+  const nativeModules = /* @__PURE__ */ new Set();
+  let totalDeps = 0;
+  for (const project of projects) {
+    for (const dep of project.dependencies) {
+      totalDeps++;
+      if (DEPRECATED_PACKAGES.has(dep.package)) {
+        deprecated.add(dep.package);
+      }
+      if (NATIVE_MODULE_PACKAGES2.has(dep.package)) {
+        nativeModules.add(dep.package);
+      }
+    }
+  }
+  return {
+    deprecatedPackages: [...deprecated].sort(),
+    nativeModulePackages: [...nativeModules].sort(),
+    totalDependencies: totalDeps
+  };
+}
+function parsePnpmLock(content) {
+  const entries = [];
+  const regex = /^\s+\/?(@?[^@\s][^@\s]*?)@(\d+\.\d+\.\d+[^:\s]*)\s*:/gm;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match[1] && match[2]) {
+      entries.push({ name: match[1], version: match[2] });
+    }
+  }
+  return entries;
+}
+function parseNpmLock(content) {
+  const entries = [];
+  try {
+    const lock = JSON.parse(content);
+    if (lock.packages && typeof lock.packages === "object") {
+      for (const [key, value] of Object.entries(lock.packages)) {
+        if (key === "") continue;
+        const v = value;
+        if (v.version) {
+          const name = key.replace(/^node_modules\//, "").replace(/.*node_modules\//, "");
+          entries.push({ name, version: v.version });
+        }
+      }
+    } else if (lock.dependencies && typeof lock.dependencies === "object") {
+      let walkDeps2 = function(deps) {
+        for (const [name, data] of Object.entries(deps)) {
+          if (data.version) entries.push({ name, version: data.version });
+          if (data.dependencies) walkDeps2(data.dependencies);
+        }
+      };
+      var walkDeps = walkDeps2;
+      walkDeps2(lock.dependencies);
+    }
+  } catch {
+  }
+  return entries;
+}
+function parseYarnLock(content) {
+  const entries = [];
+  const regex = /^"?(@?[^\s"@]+)@[^:]+:\s*\n\s+version\s+"([^"]+)"/gm;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    if (match[1] && match[2]) {
+      entries.push({ name: match[1], version: match[2] });
+    }
+  }
+  return entries;
+}
+async function scanDependencyGraph(rootDir, cache) {
+  const result = {
+    lockfileType: null,
+    totalUnique: 0,
+    totalInstalled: 0,
+    duplicatedPackages: [],
+    phantomDependencies: []
+  };
+  let entries = [];
+  const pnpmLock = path3.join(rootDir, "pnpm-lock.yaml");
+  const npmLock = path3.join(rootDir, "package-lock.json");
+  const yarnLock = path3.join(rootDir, "yarn.lock");
+  const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
+  const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
+  if (await _pathExists(pnpmLock)) {
+    result.lockfileType = "pnpm";
+    const content = await _readTextFile(pnpmLock);
+    entries = parsePnpmLock(content);
+  } else if (await _pathExists(npmLock)) {
+    result.lockfileType = "npm";
+    const content = await _readTextFile(npmLock);
+    entries = parseNpmLock(content);
+  } else if (await _pathExists(yarnLock)) {
+    result.lockfileType = "yarn";
+    const content = await _readTextFile(yarnLock);
+    entries = parseYarnLock(content);
+  }
+  if (entries.length === 0) return result;
+  const versionMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = versionMap.get(entry.name);
+    if (existing) {
+      existing.add(entry.version);
+    } else {
+      versionMap.set(entry.name, /* @__PURE__ */ new Set([entry.version]));
+    }
+  }
+  result.totalInstalled = entries.length;
+  result.totalUnique = versionMap.size;
+  const duplicated = [];
+  for (const [name, versions] of versionMap) {
+    if (versions.size > 1) {
+      duplicated.push({
+        name,
+        versions: [...versions].sort(),
+        consumers: versions.size
+      });
+    }
+  }
+  duplicated.sort((a, b) => b.versions.length - a.versions.length || a.name.localeCompare(b.name));
+  result.duplicatedPackages = duplicated;
+  const lockedNames = new Set(versionMap.keys());
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
+  const phantoms = /* @__PURE__ */ new Set();
+  const phantomDetails = [];
+  for (const pjPath of pkgFiles) {
+    try {
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
+      const relPath = path3.relative(rootDir, pjPath);
+      for (const section of ["dependencies", "devDependencies"]) {
+        const deps = pj[section];
+        if (!deps) continue;
+        for (const [name, version] of Object.entries(deps)) {
+          const ver = typeof version === "string" ? version : "";
+          if (!lockedNames.has(name) && !ver.startsWith("workspace:")) {
+            phantoms.add(name);
+            phantomDetails.push({ package: name, spec: ver, sourcePath: relPath });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  result.phantomDependencies = [...phantoms].sort();
+  result.phantomDependencyDetails = phantomDetails.sort((a, b) => a.sourcePath.localeCompare(b.sourcePath) || a.package.localeCompare(b.package));
+  return result;
+}
+
+// src/reporting/scanners/tooling-inventory.ts
+var CATEGORIES = {
+  frontend: {
+    "react": "React",
+    "react-dom": "React DOM",
+    "vue": "Vue",
+    "@angular/core": "Angular",
+    "svelte": "Svelte",
+    "solid-js": "Solid",
+    "qwik": "Qwik",
+    "htmx.org": "htmx",
+    "preact": "Preact",
+    "lit": "Lit",
+    "alpinejs": "Alpine.js",
+    "stimulus": "Stimulus",
+    "petite-vue": "petite-vue",
+    "mithril": "Mithril",
+    "inferno": "Inferno",
+    "hyperapp": "Hyperapp",
+    "marko": "Marko",
+    "@builder.io/qwik": "Qwik (Builder)",
+    "million": "Million",
+    "ember-source": "Ember"
+  },
+  metaFrameworks: {
+    "next": "Next.js",
+    "nuxt": "Nuxt",
+    "@analogjs/platform": "Analog",
+    "astro": "Astro",
+    "@remix-run/react": "Remix",
+    "gatsby": "Gatsby",
+    "@sveltejs/kit": "SvelteKit",
+    "@tanstack/start": "TanStack Start",
+    "@adonisjs/core": "AdonisJS",
+    "@redwoodjs/core": "RedwoodJS",
+    "blitz": "Blitz.js",
+    "@solidjs/start": "SolidStart",
+    "fresh": "Fresh (Deno)"
+  },
+  bundlers: {
+    "vite": "Vite",
+    "webpack": "webpack",
+    "rollup": "Rollup",
+    "esbuild": "esbuild",
+    "parcel": "Parcel",
+    "turbo": "Turbo",
+    "tsup": "tsup",
+    "unbuild": "unbuild",
+    "@swc/core": "SWC",
+    "bun": "Bun",
+    "pkg": "pkg",
+    "ncc": "ncc",
+    "@vercel/ncc": "Vercel ncc",
+    "microbundle": "microbundle",
+    "tsc-watch": "tsc-watch",
+    "ts-node": "ts-node",
+    "tsx": "tsx",
+    "jiti": "jiti",
+    "@rspack/core": "Rspack",
+    "farm": "Farm"
+  },
+  css: {
+    "tailwindcss": "Tailwind CSS",
+    "@mui/material": "MUI",
+    "vuetify": "Vuetify",
+    "bootstrap": "Bootstrap",
+    "styled-components": "styled-components",
+    "@emotion/react": "Emotion",
+    "@chakra-ui/react": "Chakra UI",
+    "sass": "Sass",
+    "@mantine/core": "Mantine",
+    "antd": "Ant Design",
+    "@radix-ui/react-slot": "Radix UI",
+    "@headlessui/react": "Headless UI",
+    "daisyui": "DaisyUI",
+    "@shadcn/ui": "shadcn/ui",
+    "primereact": "PrimeReact",
+    "primevue": "PrimeVue",
+    "@nextui-org/react": "NextUI",
+    "@ariakit/react": "Ariakit",
+    "windstitch": "Windstitch",
+    "vanilla-extract": "vanilla-extract",
+    "@vanilla-extract/css": "vanilla-extract",
+    "linaria": "Linaria",
+    "stylex": "StyleX",
+    "@stylexjs/stylex": "StyleX",
+    "unocss": "UnoCSS",
+    "postcss": "PostCSS",
+    "autoprefixer": "Autoprefixer",
+    "lightningcss": "Lightning CSS",
+    "less": "Less",
+    "stylus": "Stylus",
+    "open-props": "Open Props",
+    "@ark-ui/react": "Ark UI"
+  },
+  backend: {
+    "express": "Express",
+    "fastify": "Fastify",
+    "@nestjs/core": "NestJS",
+    "hono": "Hono",
+    "koa": "Koa",
+    "@hapi/hapi": "Hapi",
+    "restify": "Restify",
+    "elysia": "Elysia",
+    "@elysiajs/eden": "Elysia Eden",
+    "moleculer": "Moleculer",
+    "@feathersjs/feathers": "Feathers",
+    "sails": "Sails",
+    "micro": "Micro",
+    "polka": "Polka",
+    "h3": "h3",
+    "nitro": "Nitro",
+    "@trpc/server": "tRPC Server",
+    "@trpc/client": "tRPC Client",
+    "middy": "Middy (Lambda)",
+    "serverless": "Serverless Framework",
+    "aws-lambda": "AWS Lambda",
+    "@aws-sdk/client-lambda": "AWS Lambda SDK",
+    "@cloudflare/workers-types": "Cloudflare Workers",
+    "wrangler": "Wrangler"
+  },
+  orm: {
+    "prisma": "Prisma",
+    "@prisma/client": "Prisma Client",
+    "drizzle-orm": "Drizzle",
+    "typeorm": "TypeORM",
+    "sequelize": "Sequelize",
+    "knex": "Knex",
+    "pg": "pg (PostgreSQL)",
+    "mysql2": "mysql2",
+    "mongodb": "MongoDB",
+    "ioredis": "ioredis",
+    "redis": "Redis",
+    "better-sqlite3": "better-sqlite3",
+    "@mikro-orm/core": "MikroORM",
+    "mongoose": "Mongoose",
+    "mssql": "mssql",
+    "kysely": "Kysely",
+    "objection": "Objection.js",
+    "@planetscale/database": "PlanetScale",
+    "@neondatabase/serverless": "Neon",
+    "@libsql/client": "libSQL (Turso)",
+    "@electric-sql/pglite": "PGlite",
+    "sql.js": "sql.js",
+    "oracledb": "Oracle DB",
+    "cassandra-driver": "Cassandra",
+    "neo4j-driver": "Neo4j",
+    "@upstash/redis": "Upstash Redis",
+    "@upstash/kafka": "Upstash Kafka",
+    "dynamoose": "Dynamoose",
+    "fauna": "Fauna",
+    "faunadb": "FaunaDB",
+    "@clickhouse/client": "ClickHouse",
+    "influx": "InfluxDB",
+    "slonik": "Slonik",
+    "massive": "Massive.js"
+  },
+  testing: {
+    "vitest": "Vitest",
+    "jest": "Jest",
+    "mocha": "Mocha",
+    "@playwright/test": "Playwright",
+    "cypress": "Cypress",
+    "@testing-library/react": "Testing Library (React)",
+    "@testing-library/vue": "Testing Library (Vue)",
+    "@testing-library/svelte": "Testing Library (Svelte)",
+    "@testing-library/jest-dom": "Testing Library DOM",
+    "@testing-library/user-event": "Testing Library User Event",
+    "chai": "Chai",
+    "ava": "AVA",
+    "tap": "node-tap",
+    "supertest": "Supertest",
+    "storybook": "Storybook",
+    "@storybook/react": "Storybook (React)",
+    "@storybook/vue3": "Storybook (Vue)",
+    "msw": "Mock Service Worker",
+    "nock": "Nock",
+    "sinon": "Sinon",
+    "faker": "Faker",
+    "@faker-js/faker": "Faker.js",
+    "testcontainers": "Testcontainers",
+    "pact": "Pact",
+    "@pact-foundation/pact": "Pact",
+    "k6": "k6",
+    "artillery": "Artillery",
+    "autocannon": "Autocannon",
+    "puppeteer": "Puppeteer",
+    "webdriverio": "WebdriverIO",
+    "nightwatch": "Nightwatch",
+    "detox": "Detox (Mobile)",
+    "jest-image-snapshot": "Image Snapshot",
+    "happy-dom": "happy-dom",
+    "jsdom": "jsdom",
+    "c8": "c8 (coverage)",
+    "nyc": "nyc (coverage)",
+    "@vitest/coverage-v8": "Vitest Coverage"
+  },
+  lintFormat: {
+    "eslint": "ESLint",
+    "prettier": "Prettier",
+    "stylelint": "Stylelint",
+    "@biomejs/biome": "Biome",
+    "oxlint": "oxlint",
+    "tslint": "TSLint",
+    "@typescript-eslint/parser": "typescript-eslint",
+    "eslint-config-next": "ESLint Next.js",
+    "eslint-config-prettier": "ESLint Prettier",
+    "eslint-plugin-react": "ESLint React",
+    "eslint-plugin-vue": "ESLint Vue",
+    "husky": "Husky",
+    "lint-staged": "lint-staged",
+    "commitlint": "commitlint",
+    "@commitlint/cli": "commitlint",
+    "lefthook": "Lefthook",
+    "cspell": "CSpell",
+    "markdownlint": "markdownlint",
+    "depcheck": "depcheck",
+    "knip": "Knip",
+    "madge": "Madge",
+    "publint": "publint",
+    "arethetypeswrong": "Are the Types Wrong",
+    "sort-package-json": "sort-package-json"
+  },
+  apiMessaging: {
+    "graphql": "GraphQL",
+    "@grpc/grpc-js": "gRPC",
+    "@trpc/server": "tRPC",
+    "@connectrpc/connect": "Connect",
+    "socket.io": "Socket.IO",
+    "ws": "WebSocket (ws)",
+    "@apollo/server": "Apollo Server",
+    "@apollo/client": "Apollo Client",
+    "urql": "URQL",
+    "graphql-yoga": "GraphQL Yoga",
+    "mercurius": "Mercurius",
+    "type-graphql": "TypeGraphQL",
+    "nexus": "Nexus",
+    "pothos": "Pothos",
+    "@graphql-codegen/cli": "GraphQL Codegen",
+    "kafkajs": "Kafka.js",
+    "amqplib": "AMQP (RabbitMQ)",
+    "bullmq": "BullMQ",
+    "bull": "Bull",
+    "bee-queue": "Bee Queue",
+    "agenda": "Agenda",
+    "pg-boss": "pg-boss",
+    "@temporalio/client": "Temporal",
+    "inngest": "Inngest",
+    "trigger.dev": "Trigger.dev",
+    "nats": "NATS",
+    "mqtt": "MQTT",
+    "zeromq": "ZeroMQ",
+    "sse-channel": "SSE Channel"
+  },
+  observability: {
+    "@sentry/node": "Sentry (Node)",
+    "@sentry/browser": "Sentry (Browser)",
+    "@sentry/react": "Sentry (React)",
+    "@sentry/nextjs": "Sentry (Next.js)",
+    "@opentelemetry/api": "OpenTelemetry API",
+    "@opentelemetry/sdk-node": "OpenTelemetry SDK",
+    "@opentelemetry/auto-instrumentations-node": "OpenTelemetry Auto",
+    "applicationinsights": "Application Insights",
+    "pino": "Pino",
+    "winston": "Winston",
+    "dd-trace": "Datadog",
+    "newrelic": "New Relic",
+    "bunyan": "Bunyan",
+    "@axiomhq/pino": "Axiom (Pino)",
+    "loglevel": "loglevel",
+    "consola": "consola",
+    "@logtail/node": "Logtail",
+    "elastic-apm-node": "Elastic APM",
+    "prom-client": "Prometheus Client",
+    "@google-cloud/trace-agent": "GCP Trace",
+    "@google-cloud/logging": "GCP Logging",
+    "lightstep-tracer": "Lightstep",
+    "roarr": "Roarr",
+    "cls-hooked": "CLS Hooked",
+    "@baselime/node-opentelemetry": "Baselime",
+    "highlight.run": "Highlight",
+    "posthog-node": "PostHog",
+    "@amplitude/node": "Amplitude",
+    "mixpanel": "Mixpanel",
+    "@segment/analytics-node": "Segment"
+  }
+};
+function scanToolingInventory(projects) {
+  const result = {
+    frontend: [],
+    metaFrameworks: [],
+    bundlers: [],
+    css: [],
+    backend: [],
+    orm: [],
+    testing: [],
+    lintFormat: [],
+    apiMessaging: [],
+    observability: []
+  };
+  const packageVersions = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    for (const dep of project.dependencies) {
+      if (!packageVersions.has(dep.package)) {
+        packageVersions.set(dep.package, dep.resolvedVersion);
+      }
+    }
+  }
+  for (const [category, packages] of Object.entries(CATEGORIES)) {
+    const items = [];
+    for (const [pkg, displayName] of Object.entries(packages)) {
+      if (packageVersions.has(pkg)) {
+        items.push({
+          name: displayName,
+          package: pkg,
+          version: packageVersions.get(pkg) ?? null
+        });
+      }
+    }
+    items.sort((a, b) => a.name.localeCompare(b.name));
+    result[category] = items;
+  }
+  return result;
+}
+var CI_FILES = {
+  ".github/workflows": "github-actions",
+  ".gitlab-ci.yml": "gitlab-ci",
+  "azure-pipelines.yml": "azure-devops",
+  "bitbucket-pipelines.yml": "bitbucket-pipelines",
+  "Jenkinsfile": "jenkins",
+  ".circleci/config.yml": "circleci",
+  ".travis.yml": "travis-ci"
+};
+var RELEASE_PACKAGES = /* @__PURE__ */ new Set([
+  "semantic-release",
+  "@changesets/cli",
+  "standard-version",
+  "release-it",
+  "auto",
+  "lerna"
+]);
+var RELEASE_FILES = {
+  ".changeset": "changesets",
+  ".releaserc": "semantic-release",
+  ".releaserc.json": "semantic-release",
+  ".releaserc.yml": "semantic-release",
+  "release.config.js": "semantic-release",
+  "release.config.cjs": "semantic-release",
+  "GitVersion.yml": "gitversion"
+};
+var MONOREPO_FILES = {
+  "pnpm-workspace.yaml": "pnpm-workspaces",
+  "lerna.json": "lerna",
+  "nx.json": "nx",
+  "turbo.json": "turbo",
+  "rush.json": "rush"
+};
+var IAC_EXTENSIONS = {
+  ".tf": "terraform",
+  ".bicep": "bicep"
+};
+async function scanBuildDeploy(rootDir, cache) {
+  const result = {
+    ci: [],
+    ciWorkflowCount: 0,
+    docker: { dockerfileCount: 0, baseImages: [] },
+    iac: [],
+    releaseTooling: [],
+    packageManagers: [],
+    monorepoTools: []
+  };
+  const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
+  const _findFiles = cache ? (dir, pred) => cache.findFiles(dir, pred) : findFiles;
+  const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
+  const ciSystems = /* @__PURE__ */ new Set();
+  for (const [file, system] of Object.entries(CI_FILES)) {
+    const fullPath = path3.join(rootDir, file);
+    if (await _pathExists(fullPath)) {
+      ciSystems.add(system);
+    }
+  }
+  const ghWorkflowDir = path3.join(rootDir, ".github", "workflows");
+  if (await _pathExists(ghWorkflowDir)) {
+    try {
+      if (cache) {
+        const entries = await cache.walkDir(rootDir);
+        const ghPrefix = path3.relative(rootDir, ghWorkflowDir) + path3.sep;
+        result.ciWorkflowCount = entries.filter(
+          (e) => e.isFile && e.relPath.startsWith(ghPrefix) && (e.name.endsWith(".yml") || e.name.endsWith(".yaml"))
+        ).length;
+      } else {
+        const files = await _findFiles(
+          ghWorkflowDir,
+          (name) => name.endsWith(".yml") || name.endsWith(".yaml")
+        );
+        result.ciWorkflowCount = files.length;
+      }
+    } catch {
+    }
+  }
+  result.ci = [...ciSystems].sort();
+  const dockerfiles = await _findFiles(
+    rootDir,
+    (name) => name === "Dockerfile" || name.startsWith("Dockerfile.")
+  );
+  result.docker.dockerfileCount = dockerfiles.length;
+  const baseImages = /* @__PURE__ */ new Set();
+  for (const df of dockerfiles) {
+    try {
+      const content = await _readTextFile(df);
+      for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (/^FROM\s+/i.test(trimmed)) {
+          const parts = trimmed.split(/\s+/);
+          let imageIdx = 1;
+          if (parts[1]?.startsWith("--")) {
+            imageIdx = parts[1].includes("=") ? 2 : 3;
+          }
+          if (parts[imageIdx]) {
+            baseImages.add(parts[imageIdx]);
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  result.docker.baseImages = [...baseImages].sort();
+  const iacSystems = /* @__PURE__ */ new Set();
+  for (const [ext, system] of Object.entries(IAC_EXTENSIONS)) {
+    const files = await _findFiles(rootDir, (name) => name.endsWith(ext));
+    if (files.length > 0) iacSystems.add(system);
+  }
+  const cfnFiles = await _findFiles(
+    rootDir,
+    (name) => name.endsWith(".cfn.json") || name.endsWith(".cfn.yaml")
+  );
+  if (cfnFiles.length > 0) iacSystems.add("cloudformation");
+  if (await _pathExists(path3.join(rootDir, "Pulumi.yaml"))) iacSystems.add("pulumi");
+  result.iac = [...iacSystems].sort();
+  const releaseTools = /* @__PURE__ */ new Set();
+  for (const [file, tool] of Object.entries(RELEASE_FILES)) {
+    if (await _pathExists(path3.join(rootDir, file))) releaseTools.add(tool);
+  }
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
+  for (const pjPath of pkgFiles) {
+    try {
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
+      for (const section of ["dependencies", "devDependencies"]) {
+        const deps = pj[section];
+        if (!deps) continue;
+        for (const name of Object.keys(deps)) {
+          if (RELEASE_PACKAGES.has(name)) releaseTools.add(name);
+        }
+      }
+    } catch {
+    }
+  }
+  result.releaseTooling = [...releaseTools].sort();
+  const lockfileMap = {
+    "pnpm-lock.yaml": "pnpm",
+    "package-lock.json": "npm",
+    "yarn.lock": "yarn",
+    "bun.lockb": "bun"
+  };
+  const managers = /* @__PURE__ */ new Set();
+  for (const [file, manager] of Object.entries(lockfileMap)) {
+    if (await _pathExists(path3.join(rootDir, file))) managers.add(manager);
+  }
+  let rootPkg = null;
+  const rootPkgPath = path3.join(rootDir, "package.json");
+  if (await _pathExists(rootPkgPath)) {
+    try {
+      rootPkg = cache ? await cache.readJsonFile(rootPkgPath) : await readJsonFile(rootPkgPath);
+    } catch {
+    }
+  }
+  if (rootPkg?.packageManager) {
+    const pm = rootPkg.packageManager.split("@")[0]?.toLowerCase();
+    if (pm && ["pnpm", "yarn", "npm", "bun"].includes(pm)) {
+      managers.add(pm);
+    }
+  }
+  result.packageManagers = [...managers].sort();
+  const monoTools = /* @__PURE__ */ new Set();
+  for (const [file, tool] of Object.entries(MONOREPO_FILES)) {
+    if (await _pathExists(path3.join(rootDir, file))) monoTools.add(tool);
+  }
+  if (rootPkg?.workspaces) {
+    monoTools.add(managers.has("yarn") ? "yarn-workspaces" : "npm-workspaces");
+  }
+  result.monorepoTools = [...monoTools].sort();
+  return result;
+}
+async function scanTsModernity(rootDir, cache) {
+  const result = {
+    typescriptVersion: null,
+    strict: null,
+    noImplicitAny: null,
+    strictNullChecks: null,
+    module: null,
+    moduleResolution: null,
+    target: null,
+    moduleType: null,
+    exportsField: false
+  };
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
+  let hasEsm = false;
+  let hasCjs = false;
+  for (const pjPath of pkgFiles) {
+    try {
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
+      if (!result.typescriptVersion) {
+        const tsVer = pj.devDependencies?.["typescript"] ?? pj.dependencies?.["typescript"];
+        if (tsVer) {
+          result.typescriptVersion = tsVer.replace(/^[\^~>=<\s]+/, "");
+        }
+      }
+      const typeField = pj.type;
+      if (typeField === "module") hasEsm = true;
+      else if (typeField === "commonjs") hasCjs = true;
+      else if (!typeField) hasCjs = true;
+      if (pj.exports) {
+        result.exportsField = true;
+      }
+    } catch {
+    }
+  }
+  if (hasEsm && hasCjs) result.moduleType = "mixed";
+  else if (hasEsm) result.moduleType = "esm";
+  else if (hasCjs) result.moduleType = "cjs";
+  let tsConfigPath = path3.join(rootDir, "tsconfig.json");
+  const tsConfigExists = cache ? await cache.pathExists(tsConfigPath) : await pathExists(tsConfigPath);
+  if (!tsConfigExists) {
+    const tsConfigs = cache ? await cache.findFiles(rootDir, (name) => name === "tsconfig.json") : await findFiles(rootDir, (name) => name === "tsconfig.json");
+    if (tsConfigs.length > 0) {
+      tsConfigPath = tsConfigs[0];
+    } else {
+      return result;
+    }
+  }
+  try {
+    const raw = cache ? await cache.readTextFile(tsConfigPath) : await readTextFile(tsConfigPath);
+    const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,(\s*[}\]])/g, "$1");
+    const tsConfig = JSON.parse(stripped);
+    const co = tsConfig?.compilerOptions;
+    if (co) {
+      if (typeof co.strict === "boolean") result.strict = co.strict;
+      if (typeof co.noImplicitAny === "boolean") result.noImplicitAny = co.noImplicitAny;
+      if (typeof co.strictNullChecks === "boolean") result.strictNullChecks = co.strictNullChecks;
+      if (typeof co.module === "string") result.module = co.module;
+      if (typeof co.moduleResolution === "string") result.moduleResolution = co.moduleResolution;
+      if (typeof co.target === "string") result.target = co.target;
+    }
+  } catch {
+  }
+  return result;
+}
+var DEPRECATED_PACKAGES2 = /* @__PURE__ */ new Set([
+  "request",
+  "request-promise",
+  "request-promise-native",
+  "moment",
+  "node-sass",
+  "tslint",
+  "aws-sdk",
+  "babel-core",
+  "babel-preset-env",
+  "babel-preset-react",
+  "babel-loader",
+  "core-js",
+  "istanbul",
+  "istanbul-instrumenter-loader",
+  "left-pad",
+  "popper.js",
+  "create-react-class",
+  "react-addons-css-transition-group",
+  "react-addons-test-utils",
+  "@types/express-serve-static-core",
+  "enzyme",
+  "enzyme-adapter-react-16",
+  "enzyme-adapter-react-17",
+  "react-hot-loader",
+  "react-loadable",
+  "react-router-dom-v5-compat",
+  "redux-thunk",
+  "redux-saga",
+  "recompose",
+  "classnames",
+  "glamor",
+  "radium",
+  "material-ui",
+  "@material-ui/core",
+  "bower",
+  "grunt",
+  "gulp",
+  "browserify",
+  "coffee-script",
+  "coffeescript",
+  "jade",
+  "nomnom",
+  "optimist",
+  "minimist",
+  "colors",
+  "faker",
+  "event-stream",
+  "ua-parser-js",
+  "caniuse-db",
+  "circular-json",
+  "mkdirp",
+  "rimraf",
+  "glob",
+  "swig",
+  "dustjs-linkedin",
+  "hogan.js",
+  "passport-local-mongoose",
+  "@angular/http",
+  "rxjs-compat",
+  "protractor",
+  "karma",
+  "karma-jasmine",
+  "jasmine"
+]);
+var LEGACY_POLYFILLS = /* @__PURE__ */ new Set([
+  "node-fetch",
+  "cross-fetch",
+  "isomorphic-fetch",
+  "whatwg-fetch",
+  "abort-controller",
+  "form-data",
+  "formdata-polyfill",
+  "web-streams-polyfill",
+  "whatwg-url",
+  "url-parse",
+  "domexception",
+  "abortcontroller-polyfill",
+  "querystring",
+  "string_decoder",
+  "buffer",
+  "events",
+  "path-browserify",
+  "stream-browserify",
+  "stream-http",
+  "https-browserify",
+  "os-browserify",
+  "crypto-browserify",
+  "assert",
+  "util",
+  "process",
+  "timers-browserify",
+  "tty-browserify",
+  "vm-browserify",
+  "domain-browser",
+  "punycode",
+  "readable-stream",
+  "es6-promise",
+  "promise-polyfill",
+  "es6-symbol",
+  "es6-map",
+  "es6-set",
+  "es6-weak-map",
+  "es6-iterator",
+  "object-assign",
+  "object.assign",
+  "array.prototype.find",
+  "array.prototype.findindex",
+  "array.prototype.flat",
+  "array.prototype.flatmap",
+  "array-includes",
+  "string.prototype.startswith",
+  "string.prototype.endswith",
+  "string.prototype.includes",
+  "string.prototype.padstart",
+  "string.prototype.padend",
+  "string.prototype.matchall",
+  "string.prototype.replaceall",
+  "string.prototype.trimstart",
+  "string.prototype.trimend",
+  "string.prototype.at",
+  "object.entries",
+  "object.values",
+  "object.fromentries",
+  "globalthis",
+  "symbol-observable",
+  "setimmediate",
+  "regenerator-runtime",
+  "@babel/polyfill",
+  "whatwg-encoding",
+  "text-encoding",
+  "encoding",
+  "unorm",
+  "number.isnan",
+  "is-nan",
+  "has-symbols",
+  "has",
+  "hasown",
+  "safe-buffer",
+  "safer-buffer"
+]);
+var BREAKING_SIGNAL_PHRASES = [
+  "BREAKING",
+  "Breaking Change",
+  "Removed",
+  "Deprecated",
+  "Migration",
+  "Rename",
+  "Drop support"
+];
+var PACKAGE_PLAYBOOKS = {
+  vue: {
+    impactedFeatures: ["Options API-heavy components", "Deprecated hooks", "Template filters", "$listeners / $attrs merge behavior", "Mixin-heavy architecture"],
+    usagePatterns: [/\bexport\s+default\s*\{/, /\bmixins\s*:/, /\bfilters\s*:/, /\$listeners\b/, /beforeDestroy\b/, /destroyed\b/],
+    automation: "manual"
+  },
+  "react-router-dom": {
+    impactedFeatures: ["Switch/Route v5 patterns", "history prop mutation flows", "withRouter HOC usage"],
+    usagePatterns: [/\bSwitch\b/, /\bwithRouter\b/, /\bhistory\./, /<Route\s+component=/],
+    automation: "deterministic-recipe"
+  },
+  eslint: {
+    impactedFeatures: ["Flat config migration", ".eslintrc plugin resolution", "legacy parser/plugin options"],
+    usagePatterns: [/\.eslintrc/, /eslintConfig/, /module\.exports\s*=\s*\[/, /extends\s*:/],
+    automation: "deterministic-recipe"
+  },
+  typescript: {
+    impactedFeatures: ["Stricter type checks", "tsconfig option removals", "moduleResolution defaults changes"],
+    usagePatterns: [/tsconfig\.json/, /strictNullChecks/, /noImplicitAny/, /moduleResolution/],
+    automation: "manual"
+  },
+  "@angular/core": {
+    impactedFeatures: ["NgModule bootstrap assumptions", "Standalone component migration", "Deprecated lifecycle signatures"],
+    usagePatterns: [/@NgModule\b/, /ngOnInit\(/, /providers\s*:/],
+    automation: "codemod-available",
+    codemod: "ng update"
+  }
+};
+function detectDecision(majorItems, manualHotspots, codemodItems) {
+  if (majorItems === 0) return "do-nothing";
+  if (codemodItems > 0 && manualHotspots === 0) return "codemod-available";
+  if (manualHotspots > 0) return "manual-hotspots";
+  if (majorItems <= 2) return "upgrade-safely-now";
+  return "plan-major-upgrade";
+}
+function normalizeMajor(version) {
+  if (!version) return null;
+  const parsed = semver.coerce(version);
+  return parsed?.major ?? null;
+}
+function resolveCurrentVersion(dep) {
+  if (dep.resolvedVersion && semver.valid(semver.coerce(dep.resolvedVersion))) return semver.coerce(dep.resolvedVersion)?.version ?? null;
+  const min = semver.minVersion(dep.currentSpec);
+  return min?.version ?? null;
+}
+function listInterimMajorTargets(current, target) {
+  if (target <= current + 1) return [];
+  const out = [];
+  for (let m = current + 1; m < target; m++) out.push(`${m}.x`);
+  return out;
+}
+async function buildProjectUsageIndex(project, rootDir, fileCache, candidatePackages) {
+  const index = /* @__PURE__ */ new Map();
+  for (const pkg of candidatePackages) index.set(pkg, { importSites: 0, filesTouched: 0, patternHits: 0 });
+  const entries = await fileCache.walkDir(rootDir);
+  const projectPrefix = project.path.replace(/\\/g, "/").replace(/^\.\//, "");
+  const projectEntries = entries.filter((e) => e.isFile && e.relPath.replace(/\\/g, "/").startsWith(projectPrefix));
+  const codeEntries = projectEntries.filter((e) => /\.(ts|tsx|js|jsx|vue|mjs|cjs|json)$/.test(e.name));
+  for (const file of codeEntries) {
+    let content = "";
+    try {
+      content = await fileCache.readTextFile(path3.join(rootDir, file.relPath));
+    } catch {
+      continue;
+    }
+    for (const pkg of candidatePackages) {
+      const current = index.get(pkg);
+      if (!current) continue;
+      const escaped = pkg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const importRegex = new RegExp(`(?:from\\s+['"]${escaped}['"]|require\\(\\s*['"]${escaped}['"]\\s*\\)|import\\(\\s*['"]${escaped}['"]\\s*\\))`, "g");
+      const importMatches = content.match(importRegex) ?? [];
+      if (importMatches.length > 0) {
+        current.importSites += importMatches.length;
+        current.filesTouched += 1;
+      }
+      const playbook = PACKAGE_PLAYBOOKS[pkg];
+      if (playbook) {
+        for (const pattern of playbook.usagePatterns) {
+          const matches = content.match(new RegExp(pattern.source, "g"));
+          if (matches) current.patternHits += matches.length;
+        }
+      }
+    }
+  }
+  return index;
+}
+async function scanBreakingChangeExposure(projects, rootDir, fileCache) {
+  const deprecated = /* @__PURE__ */ new Set();
+  const legacyPolyfills = /* @__PURE__ */ new Set();
+  let peerConflictsDetected = false;
+  for (const project of projects) {
+    for (const dep of project.dependencies) {
+      if (DEPRECATED_PACKAGES2.has(dep.package)) deprecated.add(dep.package);
+      if (LEGACY_POLYFILLS.has(dep.package)) legacyPolyfills.add(dep.package);
+      if (dep.section === "peerDependencies" && dep.majorsBehind !== null && dep.majorsBehind >= 2) peerConflictsDetected = true;
+    }
+  }
+  let score = 0;
+  score += Math.min(deprecated.size * 10, 40);
+  score += Math.min(legacyPolyfills.size * 5, 30);
+  score += peerConflictsDetected ? 20 : 0;
+  score = Math.min(score, 100);
+  const projectIntelligence = [];
+  const solutionRollup = /* @__PURE__ */ new Map();
+  let majorPackageCount = 0;
+  let manualHotspots = 0;
+  let codemodCandidates = 0;
+  for (const project of projects) {
+    const majorDeps = project.dependencies.filter((d) => (d.majorsBehind ?? 0) >= 1 && d.latestStable);
+    if (majorDeps.length === 0) {
+      projectIntelligence.push({
+        project: project.name,
+        projectPath: project.path,
+        packages: [],
+        recommendation: "do-nothing"
+      });
+      continue;
+    }
+    const usageIndex = await buildProjectUsageIndex(project, rootDir, fileCache, majorDeps.map((d) => d.package));
+    const packages = majorDeps.map((dep) => {
+      const currentVersion = resolveCurrentVersion(dep);
+      const targetVersion = dep.latestStable;
+      const currentMajor = normalizeMajor(currentVersion);
+      const targetMajor = normalizeMajor(targetVersion);
+      const interimMajors = currentMajor !== null && targetMajor !== null ? listInterimMajorTargets(currentMajor, targetMajor) : [];
+      const usage = usageIndex.get(dep.package) ?? { importSites: 0, filesTouched: 0, patternHits: 0 };
+      const fileCount = Math.max(1, project.fileCount ?? 1);
+      const touchedPercent = Math.min(100, Math.round((usage.filesTouched + usage.patternHits) / fileCount * 100));
+      const playbook = PACKAGE_PLAYBOOKS[dep.package];
+      const impactedFeatures = playbook?.impactedFeatures ?? ["Public API usage patterns", "Configuration surface", "Runtime compatibility expectations"];
+      const automatable = playbook?.automation ?? (usage.patternHits > 0 ? "manual" : "deterministic-recipe");
+      majorPackageCount++;
+      if (automatable === "manual") manualHotspots++;
+      if (automatable === "codemod-available") codemodCandidates++;
+      return {
+        package: dep.package,
+        currentVersion,
+        targetVersion,
+        majorJumpCount: dep.majorsBehind ?? 0,
+        interimMajors,
+        releaseNoteSources: ["GitHub Releases", "Repository tags", "CHANGELOG.md"],
+        parsedSignals: [...BREAKING_SIGNAL_PHRASES],
+        impactedFeatures,
+        usage: {
+          importSites: usage.importSites,
+          filesTouchedEstimate: usage.filesTouched,
+          functionsTouchedEstimate: usage.patternHits,
+          touchedPercent
+        },
+        automatable,
+        codemod: playbook?.codemod
+      };
+    });
+    const rec = detectDecision(packages.length, packages.filter((p) => p.automatable === "manual").length, packages.filter((p) => p.automatable === "codemod-available").length);
+    projectIntelligence.push({
+      project: project.name,
+      projectPath: project.path,
+      packages,
+      recommendation: rec
+    });
+    if (project.solutionId) {
+      const key = project.solutionId;
+      const existing = solutionRollup.get(key) ?? {
+        solutionId: key,
+        solutionName: project.solutionName ?? key,
+        projectCount: 0,
+        majorPackages: 0,
+        recommendation: "do-nothing"
+      };
+      existing.projectCount += 1;
+      existing.majorPackages += packages.length;
+      existing.recommendation = detectDecision(existing.majorPackages, manualHotspots, codemodCandidates);
+      solutionRollup.set(key, existing);
+    }
+  }
+  const overallRecommendation = detectDecision(majorPackageCount, manualHotspots, codemodCandidates);
+  return {
+    deprecatedPackages: [...deprecated].sort(),
+    legacyPolyfills: [...legacyPolyfills].sort(),
+    peerConflictsDetected,
+    exposureScore: score,
+    projectIntelligence,
+    solutionIntelligence: [...solutionRollup.values()],
+    overallRecommendation
+  };
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".wrangler",
+  ".next",
+  "dist",
+  "build",
+  "out",
+  ".turbo",
+  ".cache",
+  "coverage",
+  "bin",
+  "obj",
+  ".vs",
+  "TestResults",
+  ".nuxt",
+  ".output",
+  ".svelte-kit"
+]);
+var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".map",
+  ".lock",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".ico",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp4",
+  ".webm"
+]);
+async function scanFileHotspots(rootDir, cache) {
+  const extensionCounts = {};
+  const allFiles = [];
+  let maxDepth = 0;
+  if (cache) {
+    const entries = await cache.walkDir(rootDir);
+    for (const entry of entries) {
+      if (!entry.isFile) continue;
+      const ext = path3.extname(entry.name).toLowerCase();
+      if (SKIP_EXTENSIONS.has(ext)) continue;
+      const depth = entry.relPath.split(path3.sep).length - 1;
+      if (depth > maxDepth) maxDepth = depth;
+      extensionCounts[ext] = (extensionCounts[ext] ?? 0) + 1;
+      try {
+        const stat2 = await fs.stat(entry.absPath);
+        allFiles.push({
+          path: entry.relPath,
+          bytes: stat2.size
+        });
+      } catch {
+      }
+    }
+  } else {
+    async function walk(dir, depth) {
+      if (depth > maxDepth) maxDepth = depth;
+      let entries;
+      try {
+        const dirents = await fs.readdir(dir, { withFileTypes: true });
+        entries = dirents.map((d) => ({
+          name: d.name,
+          isDirectory: d.isDirectory(),
+          isFile: d.isFile()
+        }));
+      } catch {
+        return;
+      }
+      for (const e of entries) {
+        if (e.isDirectory) {
+          if (SKIP_DIRS.has(e.name)) continue;
+          await walk(path3.join(dir, e.name), depth + 1);
+        } else if (e.isFile) {
+          const ext = path3.extname(e.name).toLowerCase();
+          if (SKIP_EXTENSIONS.has(ext)) continue;
+          extensionCounts[ext] = (extensionCounts[ext] ?? 0) + 1;
+          try {
+            const stat2 = await fs.stat(path3.join(dir, e.name));
+            allFiles.push({
+              path: path3.relative(rootDir, path3.join(dir, e.name)),
+              bytes: stat2.size
+            });
+          } catch {
+          }
+        }
+      }
+    }
+    await walk(rootDir, 0);
+  }
+  allFiles.sort((a, b) => b.bytes - a.bytes);
+  const largestFiles = allFiles.slice(0, 20);
+  return {
+    fileCountByExtension: extensionCounts,
+    largestFiles,
+    totalFiles: allFiles.length,
+    maxDirectoryDepth: maxDepth,
+    mostUsedPackages: []
+    // Filled in by caller with project data
+  };
+}
+var LOCKFILES = {
+  "pnpm-lock.yaml": "pnpm",
+  "package-lock.json": "npm",
+  "yarn.lock": "yarn",
+  "bun.lockb": "bun",
+  "packages.lock.json": "nuget"
+};
+async function scanSecurityPosture(rootDir, cache) {
+  const result = {
+    lockfilePresent: false,
+    multipleLockfileTypes: false,
+    gitignoreCoversEnv: false,
+    gitignoreCoversNodeModules: false,
+    envFilesTracked: false,
+    lockfileTypes: []
+  };
+  const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
+  const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
+  const foundLockfiles = [];
+  for (const [file, type] of Object.entries(LOCKFILES)) {
+    if (await _pathExists(path3.join(rootDir, file))) {
+      foundLockfiles.push(type);
+    }
+  }
+  result.lockfilePresent = foundLockfiles.length > 0;
+  result.multipleLockfileTypes = foundLockfiles.length > 1;
+  result.lockfileTypes = foundLockfiles.sort();
+  const gitignorePath = path3.join(rootDir, ".gitignore");
+  if (await _pathExists(gitignorePath)) {
+    try {
+      const content = await _readTextFile(gitignorePath);
+      const lines = content.split("\n").map((l) => l.trim());
+      result.gitignoreCoversEnv = lines.some(
+        (line) => line === ".env" || line === ".env*" || line === ".env.*" || line === ".env.local" || line === "*.env"
+      );
+      result.gitignoreCoversNodeModules = lines.some(
+        (line) => line === "node_modules" || line === "node_modules/" || line === "/node_modules"
+      );
+    } catch {
+    }
+  }
+  for (const envFile of [".env", ".env.local", ".env.development", ".env.production"]) {
+    if (await _pathExists(path3.join(rootDir, envFile))) {
+      if (!result.gitignoreCoversEnv) {
+        result.envFilesTracked = true;
+        break;
+      }
+    }
+  }
+  return result;
+}
+
+// src/reporting/scanners/service-dependencies.ts
+var SERVICE_CATEGORIES = {
+  payment: {
+    "stripe": "Stripe",
+    "@stripe/stripe-js": "Stripe.js",
+    "@stripe/react-stripe-js": "Stripe React",
+    "braintree": "Braintree",
+    "braintree-web": "Braintree Web",
+    "@paypal/checkout-server-sdk": "PayPal",
+    "@paypal/react-paypal-js": "PayPal React",
+    "@paypal/paypal-js": "PayPal.js",
+    "square": "Square",
+    "razorpay": "Razorpay",
+    "adyen-api-library": "Adyen",
+    "@adyen/api-library": "Adyen",
+    "@adyen/adyen-web": "Adyen Web",
+    "mollie-api-node": "Mollie",
+    "@lemonsqueezy/lemonsqueezy.js": "Lemon Squeezy",
+    "paddle-sdk": "Paddle",
+    "@paddle/paddle-node-sdk": "Paddle",
+    "coinbase-commerce-node": "Coinbase Commerce",
+    "gocardless-nodejs": "GoCardless",
+    "klarna-checkout": "Klarna",
+    "@recurly/recurly-js": "Recurly",
+    "chargebee": "Chargebee"
+  },
+  auth: {
+    "@auth0/auth0-spa-js": "Auth0 SPA",
+    "@auth0/auth0-react": "Auth0 React",
+    "@auth0/nextjs-auth0": "Auth0 Next.js",
+    "auth0": "Auth0",
+    "@clerk/clerk-js": "Clerk.js",
+    "@clerk/clerk-sdk-node": "Clerk (Node)",
+    "@clerk/nextjs": "Clerk (Next.js)",
+    "@clerk/react-router": "Clerk (React Router)",
+    "@clerk/tanstack-react-start": "Clerk (TanStack Start)",
+    "@clerk/expo": "Clerk (Expo)",
+    "@clerk/astro": "Clerk (Astro)",
+    "@clerk/chrome-extension": "Clerk (Chrome Extension)",
+    "@clerk/express": "Clerk (Express)",
+    "@clerk/fastify": "Clerk (Fastify)",
+    "@clerk/hono": "Clerk (Hono)",
+    "@clerk/nuxt": "Clerk (Nuxt)",
+    "@clerk/react": "Clerk (React)",
+    "@clerk/vue": "Clerk (Vue)",
+    "@clerk/clerk-react": "Clerk (React)",
+    "firebase-admin": "Firebase Admin",
+    "firebase": "Firebase",
+    "@firebase/auth": "Firebase Auth",
+    "passport": "Passport.js",
+    "passport-local": "Passport Local",
+    "passport-google-oauth20": "Passport Google",
+    "passport-github2": "Passport GitHub",
+    "next-auth": "NextAuth",
+    "@auth/core": "Auth.js",
+    "@supabase/supabase-js": "Supabase",
+    "@supabase/auth-helpers-nextjs": "Supabase Auth (Next.js)",
+    "@supabase/ssr": "Supabase SSR",
+    "jsonwebtoken": "JWT",
+    "jose": "JOSE",
+    "@okta/okta-auth-js": "Okta",
+    "@okta/okta-react": "Okta React",
+    "oidc-client-ts": "OIDC Client",
+    "@casl/ability": "CASL",
+    "casbin": "Casbin",
+    "keycloak-js": "Keycloak",
+    "@keycloak/keycloak-admin-client": "Keycloak Admin",
+    "lucia": "Lucia Auth",
+    "@lucia-auth/adapter-prisma": "Lucia (Prisma)",
+    "arctic": "Arctic (OAuth)",
+    "better-auth": "Better Auth",
+    "grant": "Grant (OAuth)",
+    "@workos-inc/node": "WorkOS",
+    "stytch": "Stytch",
+    "frontegg": "Frontegg",
+    "@descope/node-sdk": "Descope",
+    "kinde-auth-nextjs": "Kinde"
+  },
+  email: {
+    "@sendgrid/mail": "SendGrid",
+    "@sendgrid/client": "SendGrid Client",
+    "nodemailer": "Nodemailer",
+    "twilio": "Twilio",
+    "@aws-sdk/client-ses": "AWS SES",
+    "@aws-sdk/client-sesv2": "AWS SES v2",
+    "postmark": "Postmark",
+    "mailgun.js": "Mailgun",
+    "resend": "Resend",
+    "@react-email/components": "React Email",
+    "react-email": "React Email",
+    "mjml": "MJML",
+    "email-templates": "Email Templates",
+    "@mailchimp/mailchimp_marketing": "Mailchimp",
+    "@mailchimp/mailchimp_transactional": "Mailchimp Transactional",
+    "plunk-node": "Plunk",
+    "brevo": "Brevo (Sendinblue)",
+    "sib-api-v3-sdk": "Brevo v3",
+    "@customer.io/node": "Customer.io",
+    "sparkpost": "SparkPost",
+    "mandrill-api": "Mandrill",
+    "mail-listener5": "Mail Listener",
+    "@azure/communication-email": "Azure Email"
+  },
+  cloud: {
+    // AWS
+    "aws-sdk": "AWS SDK v2",
+    "@aws-sdk/client-s3": "AWS S3",
+    "@aws-sdk/client-lambda": "AWS Lambda",
+    "@aws-sdk/client-dynamodb": "AWS DynamoDB",
+    "@aws-sdk/client-ec2": "AWS EC2",
+    "@aws-sdk/client-ecs": "AWS ECS",
+    "@aws-sdk/client-ecr": "AWS ECR",
+    "@aws-sdk/client-cloudformation": "AWS CloudFormation",
+    "@aws-sdk/client-cloudwatch": "AWS CloudWatch",
+    "@aws-sdk/client-cloudfront": "AWS CloudFront",
+    "@aws-sdk/client-iam": "AWS IAM",
+    "@aws-sdk/client-secrets-manager": "AWS Secrets Manager",
+    "@aws-sdk/client-ssm": "AWS SSM",
+    "@aws-sdk/client-sts": "AWS STS",
+    "@aws-sdk/client-cognito-identity-provider": "AWS Cognito",
+    "@aws-sdk/client-route-53": "AWS Route 53",
+    "@aws-sdk/client-step-functions": "AWS Step Functions",
+    "@aws-sdk/client-eventbridge": "AWS EventBridge",
+    "@aws-sdk/client-kinesis": "AWS Kinesis",
+    "@aws-sdk/client-kms": "AWS KMS",
+    "@aws-sdk/client-athena": "AWS Athena",
+    "@aws-sdk/client-bedrock-runtime": "AWS Bedrock",
+    "@aws-sdk/lib-dynamodb": "AWS DynamoDB Doc",
+    // Azure
+    "@azure/storage-blob": "Azure Blob",
+    "@azure/identity": "Azure Identity",
+    "@azure/cosmos": "Azure Cosmos DB",
+    "@azure/keyvault-secrets": "Azure Key Vault",
+    "@azure/service-bus": "Azure Service Bus",
+    "@azure/event-hubs": "Azure Event Hubs",
+    "@azure/functions": "Azure Functions",
+    "@azure/ai-form-recognizer": "Azure Form Recognizer",
+    "@azure/openai": "Azure OpenAI",
+    "@azure/app-configuration": "Azure App Config",
+    "@azure/monitor-opentelemetry": "Azure Monitor OTel",
+    "@azure/container-registry": "Azure Container Registry",
+    // GCP
+    "@google-cloud/storage": "GCP Storage",
+    "@google-cloud/functions-framework": "GCP Functions",
+    "@google-cloud/bigquery": "GCP BigQuery",
+    "@google-cloud/firestore": "GCP Firestore",
+    "@google-cloud/pubsub": "GCP Pub/Sub",
+    "@google-cloud/secret-manager": "GCP Secret Manager",
+    "@google-cloud/tasks": "GCP Cloud Tasks",
+    "@google-cloud/run": "GCP Cloud Run",
+    "@google-cloud/logging": "GCP Logging",
+    "@google-cloud/translate": "GCP Translate",
+    "@google-cloud/vertexai": "GCP Vertex AI",
+    // Multi-cloud / PaaS
+    "@vercel/sdk": "Vercel",
+    "@vercel/kv": "Vercel KV",
+    "@vercel/blob": "Vercel Blob",
+    "@vercel/postgres": "Vercel Postgres",
+    "@vercel/edge-config": "Vercel Edge Config",
+    "@netlify/functions": "Netlify Functions",
+    "@cloudflare/workers-types": "Cloudflare Workers",
+    "wrangler": "Wrangler",
+    "@railway/cli": "Railway",
+    "@fly/apps": "Fly.io",
+    "heroku-client": "Heroku",
+    "@pulumi/pulumi": "Pulumi",
+    "@pulumi/aws": "Pulumi AWS",
+    "cdktf": "CDK for Terraform",
+    "aws-cdk-lib": "AWS CDK",
+    "sst": "SST"
+  },
+  databases: {
+    "pg": "PostgreSQL",
+    "postgres": "Postgres.js",
+    "mysql2": "MySQL",
+    "mysql": "MySQL (legacy)",
+    "mongodb": "MongoDB",
+    "ioredis": "Redis (ioredis)",
+    "redis": "Redis",
+    "better-sqlite3": "SQLite",
+    "sql.js": "sql.js",
+    "@prisma/client": "Prisma",
+    "drizzle-orm": "Drizzle",
+    "typeorm": "TypeORM",
+    "sequelize": "Sequelize",
+    "knex": "Knex",
+    "kysely": "Kysely",
+    "objection": "Objection.js",
+    "slonik": "Slonik",
+    "massive": "Massive.js",
+    "mongoose": "Mongoose",
+    "@mikro-orm/core": "MikroORM",
+    "mssql": "SQL Server",
+    "oracledb": "Oracle",
+    "cassandra-driver": "Cassandra",
+    "neo4j-driver": "Neo4j",
+    "arangojs": "ArangoDB",
+    "@clickhouse/client": "ClickHouse",
+    "influx": "InfluxDB",
+    "@libsql/client": "libSQL (Turso)",
+    "@neondatabase/serverless": "Neon",
+    "@planetscale/database": "PlanetScale",
+    "@electric-sql/pglite": "PGlite",
+    "@upstash/redis": "Upstash Redis",
+    "@upstash/kafka": "Upstash Kafka",
+    "@upstash/qstash": "Upstash QStash",
+    "@upstash/vector": "Upstash Vector",
+    "dynamoose": "Dynamoose",
+    "fauna": "Fauna",
+    "faunadb": "FaunaDB",
+    "@supabase/postgrest-js": "Supabase PostgREST",
+    "couchbase": "Couchbase",
+    "couchdb-nano": "CouchDB",
+    "duckdb": "DuckDB",
+    "@tidbcloud/serverless": "TiDB Serverless"
+  },
+  messaging: {
+    "@aws-sdk/client-sqs": "AWS SQS",
+    "@aws-sdk/client-sns": "AWS SNS",
+    "amqplib": "RabbitMQ",
+    "kafkajs": "Kafka",
+    "bullmq": "BullMQ",
+    "bull": "Bull",
+    "@google-cloud/pubsub": "GCP Pub/Sub",
+    "bee-queue": "Bee Queue",
+    "pg-boss": "pg-boss",
+    "agenda": "Agenda",
+    "@azure/service-bus": "Azure Service Bus",
+    "@azure/event-hubs": "Azure Event Hubs",
+    "nats": "NATS",
+    "mqtt": "MQTT",
+    "zeromq": "ZeroMQ",
+    "@temporalio/client": "Temporal Client",
+    "@temporalio/worker": "Temporal Worker",
+    "inngest": "Inngest",
+    "@trigger.dev/sdk": "Trigger.dev",
+    "@defer/client": "Defer",
+    "graphile-worker": "Graphile Worker",
+    "@quirrel/quirrel": "Quirrel",
+    "rhea": "AMQP 1.0 (rhea)",
+    "stompit": "STOMP",
+    "@eventstore/db-client": "EventStoreDB",
+    "@aws-sdk/client-eventbridge": "AWS EventBridge",
+    "@aws-sdk/client-kinesis": "AWS Kinesis",
+    "@aws-sdk/client-firehose": "AWS Firehose"
+  },
+  observability: {
+    "@sentry/node": "Sentry (Node)",
+    "@sentry/browser": "Sentry (Browser)",
+    "@sentry/react": "Sentry (React)",
+    "@sentry/nextjs": "Sentry (Next.js)",
+    "@sentry/vue": "Sentry (Vue)",
+    "@sentry/angular": "Sentry (Angular)",
+    "@opentelemetry/api": "OpenTelemetry API",
+    "@opentelemetry/sdk-node": "OpenTelemetry SDK",
+    "@opentelemetry/auto-instrumentations-node": "OpenTelemetry Auto",
+    "applicationinsights": "App Insights",
+    "dd-trace": "Datadog",
+    "@datadog/browser-rum": "Datadog RUM",
+    "newrelic": "New Relic",
+    "@newrelic/browser-agent": "New Relic Browser",
+    "pino": "Pino",
+    "winston": "Winston",
+    "bunyan": "Bunyan",
+    "consola": "Consola",
+    "loglevel": "loglevel",
+    "roarr": "Roarr",
+    "prom-client": "Prometheus",
+    "elastic-apm-node": "Elastic APM",
+    "@logtail/node": "Logtail",
+    "@axiomhq/pino": "Axiom (Pino)",
+    "@axiomhq/winston": "Axiom (Winston)",
+    "@baselime/node-opentelemetry": "Baselime",
+    "highlight.run": "Highlight",
+    "@google-cloud/trace-agent": "GCP Trace",
+    "@google-cloud/logging": "GCP Logging",
+    "@azure/monitor-opentelemetry": "Azure Monitor",
+    "lightstep-tracer": "Lightstep",
+    "honeycomb-beeline": "Honeycomb",
+    "@honeycombio/opentelemetry-node": "Honeycomb OTel",
+    "posthog-node": "PostHog",
+    "@amplitude/node": "Amplitude",
+    "mixpanel": "Mixpanel",
+    "@segment/analytics-node": "Segment",
+    "analytics-node": "Segment (legacy)",
+    "@rudderstack/rudder-sdk-node": "RudderStack",
+    "heap-api": "Heap",
+    "@fullstory/browser": "FullStory",
+    "@logrocket/react": "LogRocket",
+    "logrocket": "LogRocket",
+    "hotjar-js": "Hotjar",
+    "@clarity-ai/clarity": "Microsoft Clarity"
+  },
+  crm: {
+    "xero-node": "Xero",
+    "hubspot-api-client": "HubSpot",
+    "@hubspot/api-client": "HubSpot",
+    "@slack/web-api": "Slack Web API",
+    "@slack/bolt": "Slack Bolt",
+    "@slack/events-api": "Slack Events",
+    "discord.js": "Discord",
+    "intercom-client": "Intercom",
+    "salesforce-sdk": "Salesforce",
+    "jsforce": "JSforce (Salesforce)",
+    "@zendesk/sell-client": "Zendesk",
+    "node-zendesk": "Zendesk",
+    "freshdesk-api": "Freshdesk",
+    "pipedrive": "Pipedrive",
+    "airtable": "Airtable",
+    "@notionhq/client": "Notion",
+    "@linear/sdk": "Linear",
+    "jira-client": "Jira",
+    "jira.js": "Jira.js",
+    "@octokit/rest": "GitHub (Octokit)",
+    "@octokit/core": "GitHub (Octokit Core)",
+    "gitlab": "GitLab",
+    "@gitbeaker/rest": "GitLab (Gitbeaker)",
+    "clickup.js": "ClickUp",
+    "asana": "Asana",
+    "monday-sdk-js": "Monday.com",
+    "telegram-bot-api": "Telegram",
+    "telegraf": "Telegraf (Telegram)",
+    "@microsoft/microsoft-graph-client": "Microsoft Graph",
+    "googleapis": "Google APIs",
+    "@google-cloud/aiplatform": "Google AI Platform"
+  },
+  storage: {
+    "@aws-sdk/client-s3": "AWS S3",
+    "@aws-sdk/s3-request-presigner": "AWS S3 Presigner",
+    "@azure/storage-blob": "Azure Blob",
+    "@azure/storage-queue": "Azure Storage Queue",
+    "@azure/storage-file-share": "Azure File Share",
+    "@google-cloud/storage": "GCP Storage",
+    "minio": "MinIO",
+    "@supabase/storage-js": "Supabase Storage",
+    "cloudinary": "Cloudinary",
+    "uploadthing": "UploadThing",
+    "@uploadthing/react": "UploadThing React",
+    "multer": "Multer",
+    "multer-s3": "Multer S3",
+    "formidable": "Formidable",
+    "busboy": "Busboy",
+    "@vercel/blob": "Vercel Blob",
+    "imagekit": "ImageKit",
+    "sharp": "Sharp (image)",
+    "jimp": "Jimp (image)",
+    "fluent-ffmpeg": "FFmpeg",
+    "@google-cloud/vision": "GCP Vision",
+    "@aws-sdk/client-rekognition": "AWS Rekognition",
+    "file-type": "file-type",
+    "@backblaze-b2/sdk": "Backblaze B2",
+    "wasabi-sdk": "Wasabi"
+  },
+  search: {
+    "@elastic/elasticsearch": "Elasticsearch",
+    "algoliasearch": "Algolia",
+    "@algolia/client-search": "Algolia Client",
+    "react-instantsearch": "Algolia InstantSearch",
+    "meilisearch": "Meilisearch",
+    "typesense": "Typesense",
+    "@opensearch-project/opensearch": "OpenSearch",
+    "solr-client": "Solr",
+    "lunr": "Lunr",
+    "flexsearch": "FlexSearch",
+    "fuse.js": "Fuse.js",
+    "minisearch": "MiniSearch",
+    "orama": "Orama",
+    "@orama/orama": "Orama",
+    "@trieve/trieve-ts-sdk": "Trieve",
+    "pagefind": "Pagefind",
+    // Vector / AI search
+    "@pinecone-database/pinecone": "Pinecone",
+    "chromadb": "Chroma",
+    "@qdrant/js-client-rest": "Qdrant",
+    "weaviate-ts-client": "Weaviate",
+    "@zilliz/milvus2-sdk-node": "Milvus",
+    "openai": "OpenAI",
+    "@anthropic-ai/sdk": "Anthropic",
+    "@langchain/core": "LangChain",
+    "langchain": "LangChain",
+    "@google/generative-ai": "Google Gemini",
+    "cohere-ai": "Cohere",
+    "replicate": "Replicate",
+    "@huggingface/inference": "Hugging Face",
+    "ai": "Vercel AI SDK",
+    "@ai-sdk/openai": "AI SDK (OpenAI)"
+  }
+};
+function scanServiceDependencies(projects) {
+  const packageVersions = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    for (const dep of project.dependencies) {
+      if (!packageVersions.has(dep.package)) {
+        packageVersions.set(dep.package, dep.resolvedVersion);
+      }
+    }
+  }
+  const result = {
+    payment: [],
+    auth: [],
+    email: [],
+    cloud: [],
+    databases: [],
+    messaging: [],
+    observability: [],
+    crm: [],
+    storage: [],
+    search: []
+  };
+  for (const [category, packages] of Object.entries(SERVICE_CATEGORIES)) {
+    const items = [];
+    for (const [pkg, displayName] of Object.entries(packages)) {
+      if (packageVersions.has(pkg)) {
+        items.push({
+          name: displayName,
+          package: pkg,
+          version: packageVersions.get(pkg) ?? null
+        });
+      }
+    }
+    items.sort((a, b) => a.name.localeCompare(b.name));
+    result[category] = items;
+  }
+  return result;
+}
+var ARCHETYPE_SIGNALS = [
+  // Meta-frameworks (highest priority — they imply routing patterns)
+  { packages: ["next", "@next/core"], archetype: "nextjs", weight: 10 },
+  { packages: ["@remix-run/react", "@remix-run/node", "@remix-run/dev"], archetype: "remix", weight: 10 },
+  { packages: ["@sveltejs/kit"], archetype: "sveltekit", weight: 10 },
+  { packages: ["nuxt"], archetype: "nuxt", weight: 10 },
+  // Backend frameworks
+  { packages: ["@nestjs/core", "@nestjs/common"], archetype: "nestjs", weight: 9 },
+  { packages: ["fastify"], archetype: "fastify", weight: 8 },
+  { packages: ["hono"], archetype: "hono", weight: 8 },
+  { packages: ["koa"], archetype: "koa", weight: 8 },
+  { packages: ["express"], archetype: "express", weight: 7 },
+  // Serverless
+  { packages: ["serverless", "aws-lambda", "@aws-sdk/client-lambda", "middy", "@cloudflare/workers-types"], archetype: "serverless", weight: 6 },
+  // CLI
+  { packages: ["commander", "yargs", "meow", "cac", "clipanion", "oclif"], archetype: "cli", weight: 5 }
+];
+function detectArchetype(projects) {
+  const allPackages = /* @__PURE__ */ new Set();
+  for (const p of projects) {
+    for (const d of p.dependencies) {
+      allPackages.add(d.package);
+    }
+  }
+  if (projects.length > 2) {
+    return { archetype: "monorepo", confidence: 0.8 };
+  }
+  let bestArchetype = "unknown";
+  let bestScore = 0;
+  for (const signal of ARCHETYPE_SIGNALS) {
+    const matched = signal.packages.filter((p) => allPackages.has(p)).length;
+    if (matched > 0) {
+      const score = matched * signal.weight;
+      if (score > bestScore) {
+        bestScore = score;
+        bestArchetype = signal.archetype;
+      }
+    }
+  }
+  if (bestArchetype === "unknown") {
+    bestArchetype = "library";
+    bestScore = 3;
+  }
+  const confidence = Math.min(bestScore / 15, 1);
+  return { archetype: bestArchetype, confidence: Math.round(confidence * 100) / 100 };
+}
+var PATH_RULES = [
+  // ── Testing (high precision) ──
+  { pattern: /\/__tests__\//, layer: "testing", confidence: 0.95, signal: "__tests__ directory" },
+  { pattern: /\.test\.[jt]sx?$/, layer: "testing", confidence: 0.95, signal: ".test.* file" },
+  { pattern: /\.spec\.[jt]sx?$/, layer: "testing", confidence: 0.95, signal: ".spec.* file" },
+  { pattern: /\/test\//, layer: "testing", confidence: 0.85, signal: "test/ directory" },
+  { pattern: /\/tests\//, layer: "testing", confidence: 0.85, signal: "tests/ directory" },
+  { pattern: /\/__mocks__\//, layer: "testing", confidence: 0.9, signal: "__mocks__ directory" },
+  { pattern: /\/fixtures\//, layer: "testing", confidence: 0.8, signal: "fixtures/ directory" },
+  // ── Config/Infrastructure (high precision) ──
+  { pattern: /\/config\.[jt]sx?$/, layer: "config", confidence: 0.85, signal: "config.* file" },
+  { pattern: /\/config\//, layer: "config", confidence: 0.8, signal: "config/ directory" },
+  { pattern: /\.config\.[jt]sx?$/, layer: "config", confidence: 0.9, signal: ".config.* file" },
+  { pattern: /\/env\.[jt]sx?$/, layer: "config", confidence: 0.85, signal: "env.* file" },
+  { pattern: /\/bootstrap\.[jt]sx?$/, layer: "config", confidence: 0.85, signal: "bootstrap file" },
+  { pattern: /\/setup\.[jt]sx?$/, layer: "config", confidence: 0.8, signal: "setup file" },
+  // ── Next.js (archetype-specific) ──
+  { pattern: /(^|\/)app\/.*\/route\.[jt]sx?$/, layer: "routing", confidence: 0.95, signal: "Next.js App Router route", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)pages\/api\//, layer: "routing", confidence: 0.95, signal: "Next.js Pages API route", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*page\.[jt]sx?$/, layer: "presentation", confidence: 0.9, signal: "Next.js page component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*layout\.[jt]sx?$/, layer: "presentation", confidence: 0.9, signal: "Next.js layout component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*loading\.[jt]sx?$/, layer: "presentation", confidence: 0.85, signal: "Next.js loading component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*error\.[jt]sx?$/, layer: "presentation", confidence: 0.85, signal: "Next.js error component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)middleware\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "Next.js middleware", archetypes: ["nextjs"] },
+  // ── Remix (archetype-specific) ──
+  { pattern: /\/app\/routes\//, layer: "routing", confidence: 0.95, signal: "Remix route file", archetypes: ["remix"] },
+  { pattern: /\/app\/root\.[jt]sx?$/, layer: "presentation", confidence: 0.9, signal: "Remix root", archetypes: ["remix"] },
+  // ── SvelteKit (archetype-specific) ──
+  { pattern: /\/src\/routes\/.*\+server\.[jt]s$/, layer: "routing", confidence: 0.95, signal: "SvelteKit API route", archetypes: ["sveltekit"] },
+  { pattern: /\/src\/routes\/.*\+page\.svelte$/, layer: "presentation", confidence: 0.9, signal: "SvelteKit page", archetypes: ["sveltekit"] },
+  { pattern: /\/src\/routes\/.*\+layout\.svelte$/, layer: "presentation", confidence: 0.9, signal: "SvelteKit layout", archetypes: ["sveltekit"] },
+  { pattern: /\/src\/hooks\.server\.[jt]s$/, layer: "middleware", confidence: 0.9, signal: "SvelteKit server hooks", archetypes: ["sveltekit"] },
+  // ── Nuxt (archetype-specific) ──
+  { pattern: /\/server\/api\//, layer: "routing", confidence: 0.95, signal: "Nuxt server API", archetypes: ["nuxt"] },
+  { pattern: /\/server\/routes\//, layer: "routing", confidence: 0.95, signal: "Nuxt server route", archetypes: ["nuxt"] },
+  { pattern: /\/server\/middleware\//, layer: "middleware", confidence: 0.95, signal: "Nuxt server middleware", archetypes: ["nuxt"] },
+  { pattern: /\/pages\//, layer: "presentation", confidence: 0.85, signal: "Nuxt pages directory", archetypes: ["nuxt"] },
+  // ── NestJS (archetype-specific) ──
+  { pattern: /\.controller\.[jt]sx?$/, layer: "routing", confidence: 0.95, signal: "NestJS controller", archetypes: ["nestjs"] },
+  { pattern: /\.service\.[jt]sx?$/, layer: "services", confidence: 0.95, signal: "NestJS service", archetypes: ["nestjs"] },
+  { pattern: /\.module\.[jt]sx?$/, layer: "config", confidence: 0.9, signal: "NestJS module", archetypes: ["nestjs"] },
+  { pattern: /\.guard\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "NestJS guard", archetypes: ["nestjs"] },
+  { pattern: /\.interceptor\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "NestJS interceptor", archetypes: ["nestjs"] },
+  { pattern: /\.pipe\.[jt]sx?$/, layer: "middleware", confidence: 0.85, signal: "NestJS pipe", archetypes: ["nestjs"] },
+  { pattern: /\.middleware\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "NestJS middleware", archetypes: ["nestjs"] },
+  { pattern: /\.entity\.[jt]sx?$/, layer: "domain", confidence: 0.9, signal: "NestJS entity", archetypes: ["nestjs"] },
+  { pattern: /\.dto\.[jt]sx?$/, layer: "domain", confidence: 0.85, signal: "NestJS DTO", archetypes: ["nestjs"] },
+  { pattern: /\.repository\.[jt]sx?$/, layer: "data-access", confidence: 0.9, signal: "NestJS repository", archetypes: ["nestjs"] },
+  // ── Generic routing patterns ──
+  { pattern: /\/routes\//, layer: "routing", confidence: 0.8, signal: "routes/ directory" },
+  { pattern: /\/router\//, layer: "routing", confidence: 0.8, signal: "router/ directory" },
+  { pattern: /\/controllers\//, layer: "routing", confidence: 0.8, signal: "controllers/ directory" },
+  { pattern: /\/handlers\//, layer: "routing", confidence: 0.75, signal: "handlers/ directory" },
+  { pattern: /\/api\//, layer: "routing", confidence: 0.7, signal: "api/ directory" },
+  { pattern: /\/endpoints\//, layer: "routing", confidence: 0.8, signal: "endpoints/ directory" },
+  // ── Middleware ──
+  { pattern: /\/middleware\//, layer: "middleware", confidence: 0.85, signal: "middleware/ directory" },
+  { pattern: /\/middlewares\//, layer: "middleware", confidence: 0.85, signal: "middlewares/ directory" },
+  { pattern: /\/hooks\//, layer: "middleware", confidence: 0.6, signal: "hooks/ directory" },
+  { pattern: /\/plugins\//, layer: "middleware", confidence: 0.6, signal: "plugins/ directory" },
+  { pattern: /\/guards\//, layer: "middleware", confidence: 0.85, signal: "guards/ directory" },
+  { pattern: /\/interceptors\//, layer: "middleware", confidence: 0.85, signal: "interceptors/ directory" },
+  // ── Services / application layer ──
+  { pattern: /\/services\//, layer: "services", confidence: 0.85, signal: "services/ directory" },
+  { pattern: /\/service\//, layer: "services", confidence: 0.8, signal: "service/ directory" },
+  { pattern: /\/usecases\//, layer: "services", confidence: 0.85, signal: "usecases/ directory" },
+  { pattern: /\/use-cases\//, layer: "services", confidence: 0.85, signal: "use-cases/ directory" },
+  { pattern: /\/application\//, layer: "services", confidence: 0.7, signal: "application/ directory" },
+  { pattern: /\/actions\//, layer: "services", confidence: 0.65, signal: "actions/ directory" },
+  // ── Domain / models ──
+  { pattern: /\/domain\//, layer: "domain", confidence: 0.85, signal: "domain/ directory" },
+  { pattern: /\/models\//, layer: "domain", confidence: 0.8, signal: "models/ directory" },
+  { pattern: /\/entities\//, layer: "domain", confidence: 0.85, signal: "entities/ directory" },
+  { pattern: /\/types\//, layer: "domain", confidence: 0.7, signal: "types/ directory" },
+  { pattern: /\/schemas\//, layer: "domain", confidence: 0.7, signal: "schemas/ directory" },
+  { pattern: /\/validators\//, layer: "domain", confidence: 0.7, signal: "validators/ directory" },
+  // ── Data access ──
+  { pattern: /\/repositories\//, layer: "data-access", confidence: 0.9, signal: "repositories/ directory" },
+  { pattern: /\/repository\//, layer: "data-access", confidence: 0.85, signal: "repository/ directory" },
+  { pattern: /\/dao\//, layer: "data-access", confidence: 0.9, signal: "dao/ directory" },
+  { pattern: /\/db\//, layer: "data-access", confidence: 0.8, signal: "db/ directory" },
+  { pattern: /\/database\//, layer: "data-access", confidence: 0.8, signal: "database/ directory" },
+  { pattern: /\/persistence\//, layer: "data-access", confidence: 0.85, signal: "persistence/ directory" },
+  { pattern: /\/migrations\//, layer: "data-access", confidence: 0.9, signal: "migrations/ directory" },
+  { pattern: /\/seeds\//, layer: "data-access", confidence: 0.85, signal: "seeds/ directory" },
+  { pattern: /\/prisma\//, layer: "data-access", confidence: 0.85, signal: "prisma/ directory" },
+  { pattern: /\/drizzle\//, layer: "data-access", confidence: 0.85, signal: "drizzle/ directory" },
+  // ── Infrastructure ──
+  { pattern: /\/infra\//, layer: "infrastructure", confidence: 0.85, signal: "infra/ directory" },
+  { pattern: /\/infrastructure\//, layer: "infrastructure", confidence: 0.85, signal: "infrastructure/ directory" },
+  { pattern: /\/adapters\//, layer: "infrastructure", confidence: 0.8, signal: "adapters/ directory" },
+  { pattern: /\/clients\//, layer: "infrastructure", confidence: 0.75, signal: "clients/ directory" },
+  { pattern: /\/integrations\//, layer: "infrastructure", confidence: 0.8, signal: "integrations/ directory" },
+  { pattern: /\/external\//, layer: "infrastructure", confidence: 0.75, signal: "external/ directory" },
+  { pattern: /\/queue\//, layer: "infrastructure", confidence: 0.8, signal: "queue/ directory" },
+  { pattern: /\/jobs\//, layer: "infrastructure", confidence: 0.75, signal: "jobs/ directory" },
+  { pattern: /\/workers\//, layer: "infrastructure", confidence: 0.75, signal: "workers/ directory" },
+  { pattern: /\/cron\//, layer: "infrastructure", confidence: 0.8, signal: "cron/ directory" },
+  // ── Presentation (UI layer) ──
+  { pattern: /\/components\//, layer: "presentation", confidence: 0.85, signal: "components/ directory" },
+  { pattern: /\/views\//, layer: "presentation", confidence: 0.85, signal: "views/ directory" },
+  { pattern: /\/pages\//, layer: "presentation", confidence: 0.8, signal: "pages/ directory" },
+  { pattern: /\/layouts\//, layer: "presentation", confidence: 0.85, signal: "layouts/ directory" },
+  { pattern: /\/templates\//, layer: "presentation", confidence: 0.8, signal: "templates/ directory" },
+  { pattern: /\/widgets\//, layer: "presentation", confidence: 0.8, signal: "widgets/ directory" },
+  { pattern: /\/ui\//, layer: "presentation", confidence: 0.75, signal: "ui/ directory" },
+  // ── Shared / utils ──
+  { pattern: /\/utils\//, layer: "shared", confidence: 0.7, signal: "utils/ directory" },
+  { pattern: /\/helpers\//, layer: "shared", confidence: 0.7, signal: "helpers/ directory" },
+  { pattern: /\/lib\//, layer: "shared", confidence: 0.6, signal: "lib/ directory" },
+  { pattern: /\/common\//, layer: "shared", confidence: 0.65, signal: "common/ directory" },
+  { pattern: /\/shared\//, layer: "shared", confidence: 0.75, signal: "shared/ directory" },
+  { pattern: /\/constants\//, layer: "shared", confidence: 0.7, signal: "constants/ directory" },
+  // ── CLI-specific (command layer → routing) ──
+  { pattern: /\/commands\//, layer: "routing", confidence: 0.8, signal: "commands/ directory", archetypes: ["cli"] },
+  { pattern: /\/formatters\//, layer: "presentation", confidence: 0.8, signal: "formatters/ directory", archetypes: ["cli"] },
+  { pattern: /\/scanners\//, layer: "services", confidence: 0.8, signal: "scanners/ directory", archetypes: ["cli"] },
+  { pattern: /\/scoring\//, layer: "domain", confidence: 0.8, signal: "scoring/ directory", archetypes: ["cli"] },
+  // ── Serverless-specific ──
+  { pattern: /\/functions\//, layer: "routing", confidence: 0.8, signal: "functions/ directory", archetypes: ["serverless"] },
+  { pattern: /\/lambdas\//, layer: "routing", confidence: 0.85, signal: "lambdas/ directory", archetypes: ["serverless"] },
+  { pattern: /\/layers\//, layer: "shared", confidence: 0.7, signal: "Lambda layers/ directory", archetypes: ["serverless"] }
+];
+var SUFFIX_RULES = [
+  { suffix: ".controller", layer: "routing", confidence: 0.85, signal: "controller suffix" },
+  { suffix: ".route", layer: "routing", confidence: 0.85, signal: "route suffix" },
+  { suffix: ".router", layer: "routing", confidence: 0.85, signal: "router suffix" },
+  { suffix: ".handler", layer: "routing", confidence: 0.8, signal: "handler suffix" },
+  { suffix: ".middleware", layer: "middleware", confidence: 0.85, signal: "middleware suffix" },
+  { suffix: ".guard", layer: "middleware", confidence: 0.85, signal: "guard suffix" },
+  { suffix: ".interceptor", layer: "middleware", confidence: 0.85, signal: "interceptor suffix" },
+  { suffix: ".service", layer: "services", confidence: 0.85, signal: "service suffix" },
+  { suffix: ".usecase", layer: "services", confidence: 0.85, signal: "usecase suffix" },
+  { suffix: ".model", layer: "domain", confidence: 0.8, signal: "model suffix" },
+  { suffix: ".entity", layer: "domain", confidence: 0.85, signal: "entity suffix" },
+  { suffix: ".dto", layer: "domain", confidence: 0.8, signal: "DTO suffix" },
+  { suffix: ".schema", layer: "domain", confidence: 0.75, signal: "schema suffix" },
+  { suffix: ".validator", layer: "domain", confidence: 0.75, signal: "validator suffix" },
+  { suffix: ".repository", layer: "data-access", confidence: 0.9, signal: "repository suffix" },
+  { suffix: ".repo", layer: "data-access", confidence: 0.85, signal: "repo suffix" },
+  { suffix: ".dao", layer: "data-access", confidence: 0.9, signal: "dao suffix" },
+  { suffix: ".migration", layer: "data-access", confidence: 0.85, signal: "migration suffix" },
+  { suffix: ".adapter", layer: "infrastructure", confidence: 0.8, signal: "adapter suffix" },
+  { suffix: ".client", layer: "infrastructure", confidence: 0.75, signal: "client suffix" },
+  { suffix: ".provider", layer: "infrastructure", confidence: 0.7, signal: "provider suffix" },
+  { suffix: ".config", layer: "config", confidence: 0.8, signal: "config suffix" },
+  { suffix: ".component", layer: "presentation", confidence: 0.8, signal: "component suffix" },
+  { suffix: ".page", layer: "presentation", confidence: 0.85, signal: "page suffix" },
+  { suffix: ".view", layer: "presentation", confidence: 0.8, signal: "view suffix" },
+  { suffix: ".layout", layer: "presentation", confidence: 0.85, signal: "layout suffix" },
+  { suffix: ".util", layer: "shared", confidence: 0.7, signal: "util suffix" },
+  { suffix: ".helper", layer: "shared", confidence: 0.7, signal: "helper suffix" },
+  { suffix: ".constant", layer: "shared", confidence: 0.7, signal: "constant suffix" }
+];
+var PACKAGE_LAYER_MAP = {
+  // Routing/controllers
+  "express": "routing",
+  "fastify": "routing",
+  "@nestjs/core": "routing",
+  "hono": "routing",
+  "koa": "routing",
+  "koa-router": "routing",
+  "@hapi/hapi": "routing",
+  "h3": "routing",
+  // Middleware
+  "cors": "middleware",
+  "helmet": "middleware",
+  "passport": "middleware",
+  "express-rate-limit": "middleware",
+  "cookie-parser": "middleware",
+  "body-parser": "middleware",
+  "multer": "middleware",
+  "morgan": "middleware",
+  "compression": "middleware",
+  "express-session": "middleware",
+  // Services / application
+  "bullmq": "services",
+  "bull": "services",
+  "agenda": "services",
+  "pg-boss": "services",
+  "inngest": "services",
+  // Domain / validation
+  "zod": "domain",
+  "joi": "domain",
+  "yup": "domain",
+  "class-validator": "domain",
+  "class-transformer": "domain",
+  "superstruct": "domain",
+  "valibot": "domain",
+  // Data access / ORM
+  "prisma": "data-access",
+  "@prisma/client": "data-access",
+  "drizzle-orm": "data-access",
+  "typeorm": "data-access",
+  "sequelize": "data-access",
+  "knex": "data-access",
+  "pg": "data-access",
+  "mysql2": "data-access",
+  "mongodb": "data-access",
+  "mongoose": "data-access",
+  "ioredis": "data-access",
+  "redis": "data-access",
+  "better-sqlite3": "data-access",
+  "kysely": "data-access",
+  "@mikro-orm/core": "data-access",
+  // Infrastructure
+  "@aws-sdk/client-s3": "infrastructure",
+  "@aws-sdk/client-sqs": "infrastructure",
+  "@aws-sdk/client-sns": "infrastructure",
+  "@aws-sdk/client-ses": "infrastructure",
+  "@aws-sdk/client-lambda": "infrastructure",
+  "@google-cloud/storage": "infrastructure",
+  "@azure/storage-blob": "infrastructure",
+  "nodemailer": "infrastructure",
+  "@sendgrid/mail": "infrastructure",
+  "stripe": "infrastructure",
+  "kafkajs": "infrastructure",
+  "amqplib": "infrastructure",
+  // Presentation
+  "react": "presentation",
+  "react-dom": "presentation",
+  "vue": "presentation",
+  "@angular/core": "presentation",
+  "svelte": "presentation",
+  // Shared
+  "lodash": "shared",
+  "dayjs": "shared",
+  "date-fns": "shared",
+  "uuid": "shared",
+  "nanoid": "shared",
+  // Testing
+  "vitest": "testing",
+  "jest": "testing",
+  "mocha": "testing",
+  "@playwright/test": "testing",
+  "cypress": "testing",
+  "supertest": "testing",
+  // Observability → infrastructure
+  "@sentry/node": "infrastructure",
+  "@opentelemetry/api": "infrastructure",
+  "pino": "infrastructure",
+  "winston": "infrastructure",
+  "dd-trace": "infrastructure"
+};
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs", ".svelte", ".vue"]);
+var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".wrangler", "dist", "build", ".next", ".nuxt", ".output", ".svelte-kit", "coverage", ".vibgrate"]);
+async function walkSourceFiles(rootDir, cache) {
+  if (cache) {
+    const entries = await cache.walkDir(rootDir);
+    return entries.filter((e) => {
+      if (!e.isFile) return false;
+      const name = path3.basename(e.absPath);
+      if (name.startsWith(".") && name !== ".") return false;
+      const ext = path3.extname(name);
+      return SOURCE_EXTENSIONS.has(ext);
+    }).map((e) => e.relPath);
+  }
+  const files = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".") continue;
+      const fullPath = path3.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!IGNORE_DIRS.has(entry.name)) {
+          await walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        const ext = path3.extname(entry.name);
+        if (SOURCE_EXTENSIONS.has(ext)) {
+          files.push(path3.relative(rootDir, fullPath));
+        }
+      }
+    }
+  }
+  await walk(rootDir);
+  return files;
+}
+function classifyFile(filePath, archetype) {
+  const normalised = filePath.replace(/\\/g, "/");
+  let bestMatch = null;
+  for (const rule of PATH_RULES) {
+    if (rule.archetypes && rule.archetypes.length > 0 && !rule.archetypes.includes(archetype)) {
+      continue;
+    }
+    if (rule.pattern.test(normalised)) {
+      const boost = rule.archetypes ? 0.05 : 0;
+      const adjustedConfidence = Math.min(rule.confidence + boost, 1);
+      if (!bestMatch || adjustedConfidence > bestMatch.confidence) {
+        bestMatch = { layer: rule.layer, confidence: adjustedConfidence, signal: rule.signal };
+      }
+    }
+  }
+  if (!bestMatch || bestMatch.confidence < 0.7) {
+    const baseName = path3.basename(filePath, path3.extname(filePath));
+    const cleanBase = baseName.replace(/\.(test|spec)$/, "");
+    for (const rule of SUFFIX_RULES) {
+      if (cleanBase.endsWith(rule.suffix)) {
+        if (!bestMatch || rule.confidence > bestMatch.confidence) {
+          bestMatch = { layer: rule.layer, confidence: rule.confidence, signal: rule.signal };
+        }
+      }
+    }
+  }
+  if (bestMatch) {
+    return {
+      filePath,
+      layer: bestMatch.layer,
+      confidence: bestMatch.confidence,
+      signals: [bestMatch.signal]
+    };
+  }
+  return null;
+}
+function computeLayerDrift(packages) {
+  if (packages.length === 0) {
+    return { score: 0, riskLevel: "none" };
+  }
+  let current = 0;
+  let oneBehind = 0;
+  let twoPlusBehind = 0;
+  for (const pkg of packages) {
+    if (pkg.majorsBehind === null) ; else if (pkg.majorsBehind === 0) {
+      current++;
+    } else if (pkg.majorsBehind === 1) {
+      oneBehind++;
+    } else {
+      twoPlusBehind++;
+    }
+  }
+  const known = current + oneBehind + twoPlusBehind;
+  if (known === 0) return { score: 0, riskLevel: "none" };
+  const currentPct = current / known;
+  const onePct = oneBehind / known;
+  const twoPct = twoPlusBehind / known;
+  const health = Math.round(Math.max(0, Math.min(100, currentPct * 100 - onePct * 10 - twoPct * 40)));
+  const score = 100 - health;
+  const riskLevel = score <= 30 ? "low" : score <= 60 ? "moderate" : "high";
+  return { score, riskLevel };
+}
+function mapToolingToLayers(tooling, services, depsByLayer) {
+  const layerTooling = /* @__PURE__ */ new Map();
+  const layerServices = /* @__PURE__ */ new Map();
+  const pkgLayerLookup = /* @__PURE__ */ new Map();
+  for (const [layer, packages] of depsByLayer) {
+    for (const pkg of packages) {
+      pkgLayerLookup.set(pkg, layer);
+    }
+  }
+  if (tooling) {
+    for (const [, items] of Object.entries(tooling)) {
+      for (const item of items) {
+        const layer = pkgLayerLookup.get(item.package) ?? PACKAGE_LAYER_MAP[item.package] ?? "shared";
+        if (!layerTooling.has(layer)) layerTooling.set(layer, []);
+        const existing = layerTooling.get(layer);
+        if (!existing.some((t) => t.package === item.package)) {
+          existing.push(item);
+        }
+      }
+    }
+  }
+  if (services) {
+    for (const [, items] of Object.entries(services)) {
+      for (const item of items) {
+        const layer = pkgLayerLookup.get(item.package) ?? PACKAGE_LAYER_MAP[item.package] ?? "infrastructure";
+        if (!layerServices.has(layer)) layerServices.set(layer, []);
+        const existing = layerServices.get(layer);
+        if (!existing.some((s) => s.package === item.package)) {
+          existing.push(item);
+        }
+      }
+    }
+  }
+  return { layerTooling, layerServices };
+}
+function generateLayerFlowMermaid(layers) {
+  const labels = {
+    presentation: "Presentation",
+    routing: "Routing",
+    middleware: "Middleware",
+    services: "Services",
+    domain: "Domain",
+    "data-access": "Data Access",
+    infrastructure: "Infrastructure",
+    config: "Config",
+    shared: "Shared",
+    testing: "Testing"
+  };
+  if (layers.length === 0) {
+    return 'flowchart TD\n  APP["Project"]';
+  }
+  const ordered = [...layers];
+  const lines = ["flowchart TD"];
+  for (let i = 0; i < ordered.length; i++) {
+    const layer = ordered[i];
+    lines.push(`  L${i}["${labels[layer]}"]`);
+    if (i > 0) lines.push(`  L${i - 1} --> L${i}`);
+  }
+  return lines.join("\n");
+}
+async function buildProjectArchitectureMermaid(rootDir, project, archetype, cache) {
+  const projectRoot = path3.resolve(rootDir, project.path || ".");
+  const allFiles = await walkSourceFiles(projectRoot, cache);
+  const layerSet = /* @__PURE__ */ new Set();
+  for (const rel of allFiles) {
+    const classification = classifyFile(rel, archetype);
+    if (classification) {
+      layerSet.add(classification.layer);
+    }
+  }
+  const layerOrder = [
+    "presentation",
+    "routing",
+    "middleware",
+    "services",
+    "domain",
+    "data-access",
+    "infrastructure",
+    "config",
+    "shared",
+    "testing"
+  ];
+  const orderedLayers = layerOrder.filter((l) => layerSet.has(l));
+  return generateLayerFlowMermaid(orderedLayers);
+}
+async function scanProjectArchitecture(rootDir, project, cache) {
+  const projectRoot = path3.resolve(rootDir, project.path || ".");
+  return scanArchitecture(projectRoot, [project], void 0, void 0, cache);
+}
+function aggregateSolutionArchitecture(projectResults) {
+  if (projectResults.length === 0) {
+    return { archetype: "unknown", archetypeConfidence: 0, layers: [], totalClassified: 0, unclassified: 0 };
+  }
+  if (projectResults.length === 1) {
+    return projectResults[0];
+  }
+  let bestArchetype = "unknown";
+  let bestConfidence = 0;
+  for (const r of projectResults) {
+    if (r.archetypeConfidence > bestConfidence || r.archetypeConfidence === bestConfidence && r.archetype !== "monorepo") {
+      bestArchetype = r.archetype;
+      bestConfidence = r.archetypeConfidence;
+    }
+  }
+  const layerMap = /* @__PURE__ */ new Map();
+  for (const r of projectResults) {
+    for (const ls of r.layers) {
+      const existing = layerMap.get(ls.layer);
+      if (!existing) {
+        layerMap.set(ls.layer, { ...ls, packages: [...ls.packages], techStack: [...ls.techStack], services: [...ls.services] });
+      } else {
+        existing.fileCount += ls.fileCount;
+        const pkgNames = new Set(existing.packages.map((p) => p.name));
+        for (const pkg of ls.packages) {
+          if (!pkgNames.has(pkg.name)) {
+            existing.packages.push(pkg);
+            pkgNames.add(pkg.name);
+          }
+        }
+        const techPkgs = new Set(existing.techStack.map((t) => t.package));
+        for (const t of ls.techStack) {
+          if (!techPkgs.has(t.package)) {
+            existing.techStack.push(t);
+            techPkgs.add(t.package);
+          }
+        }
+        const svcPkgs = new Set(existing.services.map((s) => s.package));
+        for (const s of ls.services) {
+          if (!svcPkgs.has(s.package)) {
+            existing.services.push(s);
+            svcPkgs.add(s.package);
+          }
+        }
+        const { score, riskLevel } = computeLayerDrift(existing.packages);
+        existing.driftScore = score;
+        existing.riskLevel = riskLevel;
+      }
+    }
+  }
+  const LAYER_ORDER = {
+    "presentation": 0,
+    "routing": 1,
+    "middleware": 2,
+    "services": 3,
+    "domain": 4,
+    "data-access": 5,
+    "infrastructure": 6,
+    "config": 7,
+    "shared": 8,
+    "testing": 9
+  };
+  const layers = [...layerMap.values()].sort((a, b) => (LAYER_ORDER[a.layer] ?? 99) - (LAYER_ORDER[b.layer] ?? 99));
+  const totalClassified = projectResults.reduce((s, r) => s + r.totalClassified, 0);
+  const unclassified = projectResults.reduce((s, r) => s + r.unclassified, 0);
+  return { archetype: bestArchetype, archetypeConfidence: bestConfidence, layers, totalClassified, unclassified };
+}
+async function scanArchitecture(rootDir, projects, tooling, services, cache) {
+  const { archetype, confidence: archetypeConfidence } = detectArchetype(projects);
+  const sourceFiles = await walkSourceFiles(rootDir, cache);
+  const classifications = [];
+  let unclassified = 0;
+  for (const file of sourceFiles) {
+    const classification = classifyFile(file, archetype);
+    if (classification) {
+      classifications.push(classification);
+    } else {
+      unclassified++;
+    }
+  }
+  const allDeps = /* @__PURE__ */ new Map();
+  for (const p of projects) {
+    for (const d of p.dependencies) {
+      if (!allDeps.has(d.package)) {
+        allDeps.set(d.package, d);
+      }
+    }
+  }
+  const depsByLayer = /* @__PURE__ */ new Map();
+  for (const [pkg] of allDeps) {
+    const layer = PACKAGE_LAYER_MAP[pkg];
+    if (layer) {
+      if (!depsByLayer.has(layer)) depsByLayer.set(layer, /* @__PURE__ */ new Set());
+      depsByLayer.get(layer).add(pkg);
+    }
+  }
+  const { layerTooling, layerServices } = mapToolingToLayers(tooling, services, depsByLayer);
+  const ALL_LAYERS = [
+    "routing",
+    "middleware",
+    "services",
+    "domain",
+    "data-access",
+    "infrastructure",
+    "presentation",
+    "config",
+    "testing",
+    "shared"
+  ];
+  const layerFileCounts = /* @__PURE__ */ new Map();
+  for (const c of classifications) {
+    layerFileCounts.set(c.layer, (layerFileCounts.get(c.layer) ?? 0) + 1);
+  }
+  const layers = [];
+  for (const layer of ALL_LAYERS) {
+    const fileCount = layerFileCounts.get(layer) ?? 0;
+    const layerPkgs = depsByLayer.get(layer) ?? /* @__PURE__ */ new Set();
+    const tech = layerTooling.get(layer) ?? [];
+    const svc = layerServices.get(layer) ?? [];
+    if (fileCount === 0 && layerPkgs.size === 0 && tech.length === 0 && svc.length === 0) {
+      continue;
+    }
+    const packages = [];
+    for (const pkg of layerPkgs) {
+      const dep = allDeps.get(pkg);
+      if (dep) {
+        packages.push({
+          name: dep.package,
+          version: dep.resolvedVersion,
+          latestStable: dep.latestStable,
+          majorsBehind: dep.majorsBehind,
+          drift: dep.drift
+        });
+      }
+    }
+    const { score, riskLevel } = computeLayerDrift(packages);
+    layers.push({
+      layer,
+      fileCount,
+      driftScore: score,
+      riskLevel,
+      techStack: tech,
+      services: svc,
+      packages
+    });
+  }
+  const LAYER_ORDER = {
+    "presentation": 0,
+    "routing": 1,
+    "middleware": 2,
+    "services": 3,
+    "domain": 4,
+    "data-access": 5,
+    "infrastructure": 6,
+    "config": 7,
+    "shared": 8,
+    "testing": 9
+  };
+  layers.sort((a, b) => (LAYER_ORDER[a.layer] ?? 99) - (LAYER_ORDER[b.layer] ?? 99));
+  return {
+    archetype,
+    archetypeConfidence,
+    layers,
+    totalClassified: classifications.length,
+    unclassified
+  };
+}
+var ts;
+var tsLoading = null;
+async function ensureTypeScript() {
+  if (ts) return;
+  tsLoading ??= import('typescript').then((m) => {
+    const mod = m;
+    ts = mod.default ?? m;
+  });
+  await tsLoading;
+}
+var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var DEFAULT_RESULT = {
+  filesAnalyzed: 0,
+  functionsAnalyzed: 0,
+  avgCyclomaticComplexity: 0,
+  avgFunctionLength: 0,
+  maxNestingDepth: 0,
+  godFiles: [],
+  circularDependencies: 0,
+  deadCodePercent: 0
+};
+async function scanCodeQuality(rootDir, cache) {
+  const filePaths = await findSourceFiles(rootDir, cache);
+  if (filePaths.length === 0) return { ...DEFAULT_RESULT };
+  await ensureTypeScript();
+  let totalFunctions = 0;
+  let totalComplexity = 0;
+  let totalFunctionLength = 0;
+  let maxNestingDepth = 0;
+  let deadFunctions = 0;
+  const godFiles = [];
+  const depGraph = /* @__PURE__ */ new Map();
+  for (const filePath of filePaths) {
+    let raw = "";
+    try {
+      raw = cache ? await cache.readTextFile(filePath) : await readTextFile(filePath);
+    } catch {
+      continue;
+    }
+    if (!raw.trim()) continue;
+    const rel = normalizeModuleId(path3.relative(rootDir, filePath));
+    const source = ts.createSourceFile(filePath, raw, ts.ScriptTarget.Latest, true);
+    const imports = collectLocalImports(source, path3.dirname(filePath), rootDir);
+    depGraph.set(rel, imports);
+    const fileMetrics = computeFileMetrics(source, raw);
+    totalFunctions += fileMetrics.functionsAnalyzed;
+    totalComplexity += fileMetrics.totalComplexity;
+    totalFunctionLength += fileMetrics.totalFunctionLength;
+    maxNestingDepth = Math.max(maxNestingDepth, fileMetrics.maxNestingDepth);
+    deadFunctions += fileMetrics.deadFunctionCount;
+    const fileAvgComplexity = fileMetrics.functionsAnalyzed > 0 ? fileMetrics.totalComplexity / fileMetrics.functionsAnalyzed : 0;
+    if (fileMetrics.lines >= 450 || fileMetrics.functionsAnalyzed >= 25 || fileMetrics.functionsAnalyzed >= 10 && fileAvgComplexity >= 8) {
+      godFiles.push({
+        path: rel,
+        lines: fileMetrics.lines,
+        functionCount: fileMetrics.functionsAnalyzed,
+        averageComplexity: round2(fileAvgComplexity)
+      });
+    }
+  }
+  const circularDependencies = countCircularDependencyChains(depGraph);
+  const deadCodePercent = totalFunctions > 0 ? deadFunctions / totalFunctions * 100 : 0;
+  return {
+    filesAnalyzed: depGraph.size,
+    functionsAnalyzed: totalFunctions,
+    avgCyclomaticComplexity: totalFunctions > 0 ? round2(totalComplexity / totalFunctions) : 0,
+    avgFunctionLength: totalFunctions > 0 ? round2(totalFunctionLength / totalFunctions) : 0,
+    maxNestingDepth,
+    godFiles: godFiles.sort((a, b) => b.lines - a.lines || b.functionCount - a.functionCount).slice(0, 10),
+    circularDependencies,
+    deadCodePercent: round2(deadCodePercent)
+  };
+}
+async function findSourceFiles(rootDir, cache) {
+  if (cache) {
+    const entries = await cache.walkDir(rootDir);
+    return entries.filter((entry) => entry.isFile && SOURCE_EXTENSIONS2.has(path3.extname(entry.name).toLowerCase())).map((entry) => entry.absPath);
+  }
+  const files = await findFiles(rootDir, (name) => SOURCE_EXTENSIONS2.has(path3.extname(name).toLowerCase()));
+  return files;
+}
+function collectLocalImports(source, fileDir, rootDir) {
+  const deps = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+      const target = resolveLocalImport(node.moduleSpecifier.text, fileDir, rootDir);
+      if (target) deps.add(target);
+    }
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments[0] && ts.isStringLiteral(node.arguments[0])) {
+      const target = resolveLocalImport(node.arguments[0].text, fileDir, rootDir);
+      if (target) deps.add(target);
+    }
+    visitEach(node, visit);
+  };
+  visit(source);
+  return [...deps];
+}
+function resolveLocalImport(specifier, fileDir, rootDir) {
+  if (!specifier.startsWith(".")) return null;
+  const rawTarget = path3.resolve(fileDir, specifier);
+  const normalized = path3.relative(rootDir, rawTarget).replace(/\\/g, "/");
+  if (!normalized || normalized.startsWith("..")) return null;
+  return normalizeModuleId(normalized);
+}
+function normalizeModuleId(relPath) {
+  return relPath.replace(/\\/g, "/").replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/, "").replace(/\/index$/, "");
+}
+function computeFileMetrics(source, raw) {
+  let functionsAnalyzed = 0;
+  let totalComplexity = 0;
+  let totalFunctionLength = 0;
+  let maxNestingDepth = 0;
+  let deadFunctionCount = 0;
+  const functionDecls = [];
+  const visit = (node) => {
+    if (isFunctionLike(node)) {
+      const complexity = computeCyclomatic(node);
+      const lineLength = computeNodeLineLength(source, node);
+      const nestingDepth = computeMaxNestingDepth(node);
+      functionsAnalyzed++;
+      totalComplexity += complexity;
+      totalFunctionLength += lineLength;
+      maxNestingDepth = Math.max(maxNestingDepth, nestingDepth);
+    }
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      functionDecls.push(node);
+    }
+    visitEach(node, visit);
+  };
+  visit(source);
+  const functionBodies = raw;
+  for (const fn of functionDecls) {
+    if (isExported(fn)) continue;
+    const name = fn.name?.text;
+    if (!name) continue;
+    const refs = countWholeWord(functionBodies, name);
+    if (refs <= 1) deadFunctionCount++;
+  }
+  return {
+    lines: raw.split(/\r?\n/).length,
+    functionsAnalyzed,
+    totalComplexity,
+    totalFunctionLength,
+    maxNestingDepth,
+    deadFunctionCount
+  };
+}
+function computeCyclomatic(fn) {
+  let complexity = 1;
+  const visit = (node) => {
+    switch (node.kind) {
+      case ts.SyntaxKind.IfStatement:
+      case ts.SyntaxKind.ForStatement:
+      case ts.SyntaxKind.ForOfStatement:
+      case ts.SyntaxKind.ForInStatement:
+      case ts.SyntaxKind.WhileStatement:
+      case ts.SyntaxKind.DoStatement:
+      case ts.SyntaxKind.CaseClause:
+      case ts.SyntaxKind.CatchClause:
+      case ts.SyntaxKind.ConditionalExpression:
+        complexity++;
+        break;
+      case ts.SyntaxKind.BinaryExpression: {
+        const be = node;
+        if (be.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken || be.operatorToken.kind === ts.SyntaxKind.BarBarToken || be.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+          complexity++;
+        }
+        break;
+      }
+    }
+    visitEach(node, visit);
+  };
+  visit(fn);
+  return complexity;
+}
+function computeMaxNestingDepth(node) {
+  let maxDepth = 0;
+  const walk = (current, depth) => {
+    const nextDepth = isNestingNode(current) ? depth + 1 : depth;
+    maxDepth = Math.max(maxDepth, nextDepth);
+    visitEach(current, (child) => walk(child, nextDepth));
+  };
+  walk(node, 0);
+  return Math.max(0, maxDepth - 1);
+}
+function countCircularDependencyChains(graph) {
+  let cycles = 0;
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const dfs = (node) => {
+    visited.add(node);
+    inStack.add(node);
+    const deps = graph.get(node) ?? [];
+    for (const dep of deps) {
+      if (!graph.has(dep)) continue;
+      if (!visited.has(dep)) {
+        dfs(dep);
+      } else if (inStack.has(dep)) {
+        cycles++;
+      }
+    }
+    inStack.delete(node);
+  };
+  for (const node of graph.keys()) {
+    if (!visited.has(node)) dfs(node);
+  }
+  return cycles;
+}
+function computeNodeLineLength(source, node) {
+  const start = source.getLineAndCharacterOfPosition(node.getStart(source)).line;
+  const end = source.getLineAndCharacterOfPosition(node.getEnd()).line;
+  return end - start + 1;
+}
+function isFunctionLike(node) {
+  return ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isConstructorDeclaration(node);
+}
+function isNestingNode(node) {
+  return node.kind === ts.SyntaxKind.IfStatement || node.kind === ts.SyntaxKind.ForStatement || node.kind === ts.SyntaxKind.ForOfStatement || node.kind === ts.SyntaxKind.ForInStatement || node.kind === ts.SyntaxKind.WhileStatement || node.kind === ts.SyntaxKind.DoStatement || node.kind === ts.SyntaxKind.SwitchStatement || node.kind === ts.SyntaxKind.TryStatement || node.kind === ts.SyntaxKind.CatchClause;
+}
+function isExported(node) {
+  if (!ts.canHaveModifiers(node)) return false;
+  const modifiers = ts.getModifiers(node);
+  return !!modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+}
+function countWholeWord(input, word) {
+  const re = new RegExp(`\\b${escapeRegExp(word)}\\b`, "g");
+  return input.match(re)?.length ?? 0;
+}
+function escapeRegExp(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+function visitEach(node, cb) {
+  node.forEachChild(cb);
+}
+
+// src/reporting/scanners/ui-purpose.ts
+var UI_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".tsx",
+  ".jsx",
+  ".ts",
+  ".js",
+  ".vue",
+  ".svelte",
+  ".html",
+  ".mdx",
+  ".json",
+  ".yml",
+  ".yaml"
+]);
+var HIGH_SIGNAL_DEPENDENCIES = /* @__PURE__ */ new Set([
+  "stripe",
+  "posthog-js",
+  "posthog-node",
+  "@sentry/node",
+  "@sentry/browser",
+  "@sentry/react",
+  "next-auth",
+  "firebase",
+  "auth0",
+  "@auth0/auth0-react",
+  "@supabase/supabase-js",
+  "supabase",
+  "clerk",
+  "@clerk/clerk-js",
+  "@clerk/react"
+]);
+var GENERIC_LOW_SIGNAL = /* @__PURE__ */ new Set(["welcome", "home", "click here", "learn more", "submit", "cancel"]);
+async function scanUiPurpose(rootDir, fileCache, maxItems = 300) {
+  const entries = await fileCache.walkDir(rootDir);
+  const files = entries.filter((e) => e.isFile);
+  const packageJsonEntries = files.filter(
+    (e) => e.relPath.endsWith("package.json") && !e.relPath.includes("node_modules")
+  );
+  const allPkgJsons = [];
+  for (const entry of packageJsonEntries) {
+    try {
+      allPkgJsons.push(JSON.parse(await fileCache.readTextFile(entry.absPath)));
+    } catch {
+    }
+  }
+  const frameworks = detectFrameworksFromAll(allPkgJsons);
+  const items = [];
+  for (const entry of files) {
+    const ext = extension(entry.relPath);
+    if (!UI_EXTENSIONS.has(ext)) continue;
+    if (!isLikelyUiPath(entry.relPath)) {
+      const routeHints2 = extractRouteHints(entry.relPath, frameworks);
+      if (routeHints2.length > 0) {
+        items.push(...routeHints2.map((r) => ({ ...r, file: entry.relPath })));
+      }
+      continue;
+    }
+    const routeHints = extractRouteHints(entry.relPath, frameworks);
+    if (routeHints.length > 0) {
+      items.push(...routeHints.map((r) => ({ ...r, file: entry.relPath })));
+    }
+    const src = await fileCache.readTextFile(entry.absPath);
+    if (!src || src.length > 512e3) continue;
+    const strings = extractUiStrings(src);
+    for (const text of strings) {
+      const kind = classifyString(text);
+      const weight = scoreString(kind, text);
+      items.push({ kind, value: text, file: entry.relPath, weight });
+    }
+    if (/(featureFlag|FEATURE_FLAG|launchDarkly|isFeatureEnabled|flags\.)/.test(src)) {
+      items.push({ kind: "feature_flag", value: `flags in ${entry.relPath}`, file: entry.relPath, weight: 2 });
+    }
+  }
+  for (const pkg of allPkgJsons) {
+    const deps = getDependencies(pkg);
+    for (const [name, version] of deps) {
+      if (HIGH_SIGNAL_DEPENDENCIES.has(name)) {
+        items.push({ kind: "dependency", value: `${name}@${version}`, file: "package.json", weight: 4 });
+      }
+    }
+  }
+  const deduped = dedupeByKindValue(items).sort((a, b) => b.weight - a.weight || a.value.localeCompare(b.value));
+  const cappedItems = deduped.slice(0, maxItems);
+  const unknownSignals = buildUnknowns(cappedItems);
+  return {
+    enabled: true,
+    detectedFrameworks: frameworks,
+    evidenceCount: deduped.length,
+    capped: deduped.length > cappedItems.length,
+    topEvidence: cappedItems,
+    unknownSignals
+  };
+}
+function extension(relPath) {
+  const i = relPath.lastIndexOf(".");
+  return i === -1 ? "" : relPath.slice(i).toLowerCase();
+}
+function isLikelyUiPath(relPath) {
+  const lower = relPath.toLowerCase();
+  return lower.startsWith("pages/") || lower.includes("/pages/") || lower.startsWith("app/") || lower.includes("/app/") || lower.startsWith("components/") || lower.includes("/components/") || lower.startsWith("ui/") || lower.includes("/ui/") || lower.startsWith("views/") || lower.includes("/views/") || lower.includes("/routes") || lower.startsWith("routes") || lower.includes("/router") || lower.startsWith("router") || lower.startsWith("locales/") || lower.includes("/locales/") || lower.startsWith("i18n/") || lower.includes("/i18n/") || lower.endsWith(".html") || lower.endsWith(".mdx");
+}
+function detectFrameworksFromAll(pkgJsons) {
+  const hits = /* @__PURE__ */ new Set();
+  for (const pkgJson of pkgJsons) {
+    const deps = {
+      ...asRecord(pkgJson.dependencies),
+      ...asRecord(pkgJson.devDependencies)
+    };
+    if (deps.next) hits.add("nextjs");
+    if (deps.nuxt || deps.nuxt3) hits.add("nuxt");
+    if (deps.react) hits.add("react");
+    if (deps.vue) hits.add("vue");
+    if (deps.svelte) hits.add("svelte");
+    if (deps["@angular/core"]) hits.add("angular");
+  }
+  return Array.from(hits);
+}
+function extractRouteHints(relPath, frameworks) {
+  const items = [];
+  if (frameworks.includes("nextjs")) {
+    const m = relPath.match(/^(?:src\/)?(pages|app)\/(.+)\.(tsx|jsx|ts|js)$/);
+    if (m) {
+      let route = "/" + m[2].replace(/(^|\/)page$/i, "").replace(/(^|\/)route$/i, "").replace(/index$/i, "").replace(/\[(?:\.\.\.)?(.+?)\]/g, ":$1").replace(/\/+/g, "/");
+      if (route !== "/" && route.endsWith("/")) route = route.slice(0, -1);
+      items.push({ kind: "route", value: route || "/", weight: 5 });
+    }
+  }
+  if (/(^|\/)(routes?|router)\.(ts|js|json)$/.test(relPath) || relPath.includes("/router/")) {
+    items.push({ kind: "route", value: `route config: ${relPath}`, weight: 3 });
+  }
+  return items;
+}
+function extractUiStrings(src) {
+  const out = [];
+  const textNodeRegex = />\s*([A-Za-z0-9][^<>]{2,120}?)\s*</g;
+  for (const m of src.matchAll(textNodeRegex)) {
+    const s = normaliseText(m[1] ?? "");
+    if (isUsefulString(s)) out.push(s);
+  }
+  const titleRegex = /<title>\s*([^<]{2,120})\s*<\/title>|title\s*[:=]\s*["'`](.{2,120}?)["'`]/g;
+  for (const m of src.matchAll(titleRegex)) {
+    const s = normaliseText((m[1] ?? m[2] ?? "").trim());
+    if (isUsefulString(s)) out.push(s);
+  }
+  const attrRegex = /(?:aria-label|label|placeholder|alt)\s*=\s*["'`](.{2,120}?)["'`]/g;
+  for (const m of src.matchAll(attrRegex)) {
+    const s = normaliseText(m[1] ?? "");
+    if (isUsefulString(s)) out.push(s);
+  }
+  const jsonValueRegex = /:\s*["'`](.{2,140}?)["'`]\s*[,\n]/g;
+  for (const m of src.matchAll(jsonValueRegex)) {
+    const s = normaliseText(m[1] ?? "");
+    if (isUsefulString(s)) out.push(s);
+  }
+  return out;
+}
+function classifyString(s) {
+  const lower = s.toLowerCase();
+  if (/(pricing|plan|billing|subscription|trial|credit)/.test(lower)) return "copy";
+  if (/(sign in|sign up|log in|register|invite|workspace|organization|sso|oauth)/.test(lower)) return "copy";
+  if (/(dashboard|reports|settings|integrations|users|roles|permissions)/.test(lower)) return "heading";
+  if (/(get started|start|scan|generate|export|run|deploy|upgrade|analy[sz]e)/.test(lower)) return "cta";
+  if (/(overview|features|about|documentation|docs)/.test(lower)) return "title";
+  if (/(menu|navigation|sidebar|breadcrumb)/.test(lower)) return "nav";
+  return "copy";
+}
+function scoreString(kind, value) {
+  const lower = value.toLowerCase();
+  if (GENERIC_LOW_SIGNAL.has(lower)) return 0;
+  let score = 1;
+  if (kind === "route") score += 4;
+  if (kind === "nav") score += 3;
+  if (kind === "title") score += 2;
+  if (kind === "heading") score += 2;
+  if (kind === "cta") score += 2;
+  if (/(pricing|billing|subscription|auth|security|integration)/.test(lower)) score += 2;
+  if (/(dashboard|report|scan|workspace|project|repository)/.test(lower)) score += 1;
+  return score;
+}
+function dedupeByKindValue(items) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = `${item.kind}::${item.value.toLowerCase()}`;
+    const prev = seen.get(key);
+    if (!prev || item.weight > prev.weight) {
+      seen.set(key, item);
+    }
+  }
+  return Array.from(seen.values()).filter((i) => i.weight > 0);
+}
+function buildUnknowns(items) {
+  const unknowns = [];
+  const hasPricing = items.some((i) => /pricing|billing|subscription|trial|credit/i.test(i.value));
+  const hasAuth = items.some((i) => /sign in|sign up|login|auth|sso|oauth|invite/i.test(i.value));
+  const hasIntegrations = items.some((i) => /integration|webhook|api key|connector/i.test(i.value));
+  const hasRoutes = items.some((i) => i.kind === "route");
+  if (!hasPricing) unknowns.push("No pricing or billing evidence found.");
+  if (!hasAuth) unknowns.push("No authentication or user access flow evidence found.");
+  if (!hasIntegrations) unknowns.push("No integrations/connectors evidence found.");
+  if (!hasRoutes) unknowns.push("No route structure evidence found.");
+  return unknowns;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object") return {};
+  return value;
+}
+function getDependencies(pkgJson) {
+  return Object.entries(asRecord(pkgJson.dependencies));
+}
+function normaliseText(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function isUsefulString(s) {
+  if (!s || s.length < 3 || s.length > 160) return false;
+  if (/^[0-9_./-]+$/.test(s)) return false;
+  if (/^(true|false|null|undefined)$/i.test(s)) return false;
+  if (/[<>{}]/.test(s)) return false;
+  if (/function\s*\(|=>|console\.|import\s+|export\s+/.test(s)) return false;
+  return true;
+}
+
+// src/reporting/data/standards-index.ts
+var standardsIndex = [{ "slug": "adonet-4-8", "name": "ADO.NET 4.8 Specification", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "aicpa-soc-2-tsc", "name": "AICPA SOC 2 (Trust Services Criteria 2017, rev. 2022)", "category": "compliance", "domains": ["security", "governance", "privacy"], "frameworks": ["soc2"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": "https://www.aicpa-cima.com/resources/landing/system-and-organization-controls-soc-suite-of-services" }, { "slug": "amqp-1-0", "name": "AMQP 1.0 (OASIS)", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "archimate-3-2", "name": "Archimate 3.2", "category": "modeling", "domains": ["architecture"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "argo-cd-appspec-v1", "name": "Argo CD AppSpec v1", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "aria-1-3", "name": "W3C ARIA 1.3", "category": "accessibility", "domains": ["accessibility", "frontend"], "frameworks": [], "projectTypes": ["web-app", "mobile"], "complianceRelevant": true, "officialUrl": null }, { "slug": "asyncapi-2-6", "name": "AsyncAPI 2.6", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "avro-1-11", "name": "Apache Avro 1.11", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "aws-well-architected-2023", "name": "AWS Well-Architected Framework 2023", "category": "cloud-architecture", "domains": ["cloud", "architecture"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "azure-waf-2024", "name": "Azure Well-Architected Framework 2024", "category": "cloud-architecture", "domains": ["cloud", "architecture"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "backstage-catalog-1-3", "name": "Backstage Software Catalog 1.3", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "bgp-4", "name": "BGP-4 (RFC 4271)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "bian-v10", "name": "BIAN Service Landscape v10", "category": "cloud-architecture", "domains": ["cloud", "architecture"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "bpmn-2-0-2", "name": "BPMN 2.0.2", "category": "modeling", "domains": ["architecture"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "bsimm-13", "name": "BSIMM13", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "c11", "name": "ISO/IEC 9899:2011 (C11)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "c18", "name": "ISO/IEC 9899:2018 (C18)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "capec-3-9", "name": "CAPEC v3.9", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "capnproto-0-9", "name": "Cap\u2019n Proto 0.9", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cbl-mariner-2-0", "name": "CBL-Mariner OS Spec 2.0", "category": "cloud-architecture", "domains": ["cloud", "architecture"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cbor-rfc-8949", "name": "CBOR (RFC 8949)", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ccpa", "name": "CCPA (AB 375)", "category": "compliance", "domains": ["security", "governance"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "cis-kubernetes-1-7", "name": "CIS Benchmarks Kubernetes v1.7", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "cloudevents-1-0", "name": "CloudEvents 1.0", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cmmi-v2-0", "name": "CMMI v2.0", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cmmn-1-1", "name": "CMMN 1.1", "category": "modeling", "domains": ["architecture"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cncf-cloud-native-v1", "name": "CNCF Cloud-Native Definition v1", "category": "cloud-architecture", "domains": ["cloud", "architecture"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "commonmark-0-30", "name": "CommonMark 0.30", "category": "documentation", "domains": ["documentation"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cpp-14", "name": "ISO/IEC 14882:2014 (C++14)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cpp-17", "name": "ISO/IEC 14882:2017 (C++17)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cpp-20", "name": "ISO/IEC 14882:2020 (C++20)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cpp-23", "name": "ISO/IEC 14882:2023 (C++23)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "csharp-11", "name": "ECMA-334 6th (C# 11)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "csharp-2-0", "name": "ISO/IEC 23270:2006 (C# 2.0)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "csv-rfc-4180", "name": "CSV (RFC 4180)", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "cwe-4-11", "name": "MITRE CWE 4.11", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "cwt-rfc-8392", "name": "CBOR Web Token (RFC 8392)", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "cyclonedx-1-6", "name": "CycloneDX 1.6 (SBOM)", "category": "security", "domains": ["security"], "frameworks": ["nist-csf"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "dicom-2024a", "name": "DICOM PS3.0 2024a", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "did-core-1-0", "name": "W3C DID Core 1.0", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "dmn-1-4", "name": "DMN 1.4", "category": "modeling", "domains": ["architecture"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "dns-rfc-1035", "name": "DNS (RFC 1035)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "docker-compose-v3", "name": "Docker Compose v3", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "dtd-1-2", "name": "DTD 1.2", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "elixir-1-17", "name": "Elixir 1.17", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "envoy-xds-v3", "name": "Envoy xDS v3", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "erlang-26", "name": "Erlang/OTP 26", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "eu-ai-act-2024", "name": "EU AI Act Proposal 2024", "category": "ai-governance", "domains": ["ai", "governance"], "frameworks": [], "projectTypes": ["ml", "any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "fedramp-moderate", "name": "FedRAMP Moderate Rev 5", "category": "compliance", "domains": ["security", "governance"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "fido2-webauthn-l2", "name": "FIDO2 WebAuthn Level 2", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "fix-5-0-sp2", "name": "FIX Protocol 5.0 SP2", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "flatbuffers-23-5", "name": "FlatBuffers 23.5", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ftps-rfc-4217", "name": "FTPS (RFC 4217)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "gcp-architecture-2023", "name": "Google Cloud Architecture Framework 2023", "category": "cloud-architecture", "domains": ["cloud", "architecture"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "gdpr-eu-2016-679", "name": "GDPR (EU 2016/679)", "category": "compliance", "domains": ["security", "governance"], "frameworks": ["gdpr"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "git-spec", "name": "Git Spec (Distributed VC)", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "gitops-principles-v1", "name": "GitOps Principles v1", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "go-1-22", "name": "Go 1.22 Spec", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "graphql-2023", "name": "GraphQL July-2023 Spec", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "grpc-v1", "name": "gRPC Protocol v1", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "haskell-2010", "name": "Haskell 2010 Report", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "helm-chart-3-10", "name": "Helm Chart Spec v3.10", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "hipaa-security-rule", "name": "HIPAA Security Rule", "category": "compliance", "domains": ["security", "governance"], "frameworks": ["hipaa"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "hl7-fhir-r5", "name": "HL7 FHIR R5", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "http-1-0", "name": "HTTP/1.0 (RFC 1945)", "category": "web-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["web-app", "api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "http-1-1", "name": "HTTP/1.1 (RFC 7230\u20137235)", "category": "web-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["web-app", "api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "http-2", "name": "HTTP/2 (RFC 7540)", "category": "web-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["web-app", "api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "http-3", "name": "HTTP/3 (RFC 9114)", "category": "web-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["web-app", "api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "http-3-rfc-9114", "name": "HTTP/3 (RFC 9114)", "category": "web-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["web-app", "api"], "complianceRelevant": false, "officialUrl": "https://www.rfc-editor.org/rfc/rfc9114" }, { "slug": "iec-61850-ed2-1", "name": "IEC 61850 Edition 2.1", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ieee-1012-2016", "name": "IEEE 1012-2016 (Verification & Validation)", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ieee-11073-20702", "name": "IEEE 11073-20702", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ieee-14764-2006", "name": "IEEE 14764-2006 (Software Maintenance)", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ieee-2410-2019", "name": "IEEE 2410-2019 (Bio-Open ID)", "category": "biometric", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "ieee-7001-2021", "name": "IEEE 7001-2021 (AI Transparency)", "category": "ai-governance", "domains": ["ai", "governance"], "frameworks": [], "projectTypes": ["ml", "any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "ieee-7002-2022", "name": "IEEE 7002-2022 (AI Privacy Data)", "category": "ai-governance", "domains": ["ai", "governance"], "frameworks": [], "projectTypes": ["ml", "any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "ieee-730-2014", "name": "IEEE 730-2014 (Software Quality)", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ieee-802-11ax", "name": "IEEE 802.11ax (Wi-Fi 6)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ieee-802-15-4-2020", "name": "IEEE 802.15.4-2020 (IoT WPAN)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ieee-802-1q-2018", "name": "IEEE 802.1Q-2018 (VLAN)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ieee-802-3-2022", "name": "IEEE 802.3-2022 (Ethernet)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ieee-829-2008", "name": "IEEE 829-2008 (Test Docs)", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "incits-459-2011", "name": "ANSI INCITS 459-2011 (JSON)", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ipv4", "name": "IPv4 (RFC 791)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ipv6", "name": "IPv6 (RFC 8200)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-12207-2017", "name": "ISO/IEC 12207:2017", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-15288-2015", "name": "ISO/IEC 15288:2015", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-15408-1-2022", "name": "ISO/IEC 15408-1:2022 (Common Criteria)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-15504", "name": "ISO/IEC 15504 (SPICE)", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-15926-2", "name": "ISO 15926 Part 2", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-18013-5-2021", "name": "ISO/IEC 18013-5:2021 (Mobile DL)", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-19770-1-2017", "name": "ISO/IEC 19770-1:2017 (IT Asset)", "category": "quality-management", "domains": ["process", "governance"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-19794-5-2011", "name": "ISO/IEC 19794-5:2011 (Face Images)", "category": "biometric", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-20022", "name": "ISO 20022 (Financial Messaging)", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-20922-2016", "name": "ISO/IEC 20922:2016 (AMQP 1.0)", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-21502-2020", "name": "ISO 21502:2020 (Project Management)", "category": "project-management", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-21504-2022", "name": "ISO 21504:2022 (Portfolio Management)", "category": "project-management", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-21511-2018", "name": "ISO 21511:2018 (Work Breakdown Structure)", "category": "project-management", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-22989-2022", "name": "ISO/IEC 22989:2022 (AI Concepts)", "category": "ai-governance", "domains": ["ai", "governance"], "frameworks": [], "projectTypes": ["ml", "any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-23053-2022", "name": "ISO/IEC 23053:2022 (AI Lifecycle)", "category": "ai-governance", "domains": ["ai", "governance"], "frameworks": [], "projectTypes": ["ml", "any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-23659-2024", "name": "ISO/IEC 23659:2024 (AI Risk Mgmt)", "category": "ai-governance", "domains": ["ai", "governance"], "frameworks": [], "projectTypes": ["ml", "any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-2382", "name": "ISO/IEC 2382 (IT Vocabulary)", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-24772-2-2023", "name": "ISO/IEC TR 24772-2:2023 (Safer Programming)", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-25010-2023", "name": "ISO/IEC 25010:2023 (Quality Model)", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-27001-2022", "name": "ISO/IEC 27001:2022", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-27002-2022", "name": "ISO/IEC 27002:2022", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-27017-2015", "name": "ISO/IEC 27017:2015 (Cloud Controls)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-27018-2019", "name": "ISO/IEC 27018:2019 (Cloud PII)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-27701-2019", "name": "ISO/IEC 27701:2019 (Privacy)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-29119-1-2022", "name": "ISO/IEC 29119-1:2022 (Software Testing)", "category": "software-process", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-29134-2017", "name": "ISO/IEC 29134:2017 (PIA)", "category": "compliance", "domains": ["security", "governance"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-29147-2018", "name": "ISO/IEC 29147:2018 (Vuln Disclosure)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-30107-3-2017", "name": "ISO/IEC 30107-3:2017 (PAD)", "category": "biometric", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-30111-2019", "name": "ISO/IEC 30111:2019 (Vulnerability Handling)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-38500-2015", "name": "ISO/IEC 38500:2015 (IT Governance)", "category": "quality-management", "domains": ["process", "governance"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-38505-1-2017", "name": "ISO/IEC 38505-1:2017 (Data Governance)", "category": "compliance", "domains": ["security", "governance"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-40500-2012", "name": "ISO/IEC 40500:2012 (WCAG 2.0)", "category": "accessibility", "domains": ["accessibility", "frontend"], "frameworks": [], "projectTypes": ["web-app", "mobile"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-7816-4-2020", "name": "ISO/IEC 7816-4:2020 (Smart Cards)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-8601-2019", "name": "ISO 8601:2019 (Date/Time)", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-9001-2015", "name": "ISO 9001:2015", "category": "quality-management", "domains": ["process", "governance"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-9126", "name": "ISO 9126 (Quality Model \u2013 Superseded)", "category": "quality-management", "domains": ["process", "governance"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "iso-9798-3-2014", "name": "ISO/IEC 9798-3:2014", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "iso-iec-27001-2022", "name": "ISO/IEC 27001:2022", "category": "compliance", "domains": ["security", "governance"], "frameworks": ["gdpr", "hipaa", "iso-27001", "soc2"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": "https://www.iso.org/standard/27001" }, { "slug": "iso-iec-27002-2022", "name": "ISO/IEC 27002:2022", "category": "compliance", "domains": ["security"], "frameworks": ["iso-27001"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": "https://www.iso.org/standard/75652.html" }, { "slug": "iso-iec-42001-2023", "name": "ISO/IEC 42001:2023 (AI management system)", "category": "ai-governance", "domains": ["ai", "governance"], "frameworks": [], "projectTypes": ["ml", "any"], "complianceRelevant": true, "officialUrl": "https://www.iso.org/standard/81230.html" }, { "slug": "istio-api-1-21", "name": "Istio API v1.21", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "jaeger-trace-v1", "name": "Jaeger Trace Spec v1", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "java-se-17", "name": "Java SE 17 (JSR 392)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "java-se-8", "name": "Java SE 8 (JSR 337)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "javascript-es2024", "name": "ECMA-262 2024 (ES2024)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "javascript-es6", "name": "ECMA-262 2015 (ES6)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "jdbc-4-3", "name": "JDBC 4.3", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "json-api-1-1", "name": "JSON:API 1.1", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "json-rfc-8259", "name": "JSON (RFC 8259)", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "json-rpc-2-0", "name": "JSON-RPC 2.0", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "json-schema-2020-12", "name": "JSON Schema 2020-12", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "jws-rfc-7515", "name": "RFC 7515 (JWS)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "jwt-rfc-7519", "name": "JWT (RFC 7519)", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "kafka-protocol-3-7", "name": "Kafka Protocol 3.7", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "kotlin-2-0", "name": "Kotlin 2.0 Spec", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "kubernetes-1-28", "name": "Kubernetes API v1.28", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "matter-1-3", "name": "Matter 1.3", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "messagepack-2-3", "name": "MessagePack 2.3", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "mitre-attack-v14", "name": "MITRE ATT&CK v14", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "modbus-tcp-1-1b", "name": "Modbus TCP 1.1b", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "mqtt-5-0", "name": "MQTT 5.0 (OASIS)", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "nats-2-9", "name": "NATS Protocol 2.9", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "nfs-4-1", "name": "NFS 4.1 (RFC 8881)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "nist-800-171-r3", "name": "NIST SP 800-171 Rev 3", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "nist-800-53-r5", "name": "NIST SP 800-53 Rev 5", "category": "security", "domains": ["security"], "frameworks": ["nist-csf"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "nist-ai-rmf-1-0", "name": "NIST AI RMF 1.0", "category": "ai-governance", "domains": ["ai", "governance"], "frameworks": [], "projectTypes": ["ml", "any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "nist-ccra", "name": "NIST Cloud Computing Ref Arch SP 500-292", "category": "cloud-architecture", "domains": ["cloud", "architecture"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "nist-csf-2-0", "name": "NIST Cybersecurity Framework (CSF) 2.0", "category": "security", "domains": ["security", "governance"], "frameworks": ["nist-csf"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": "https://www.nist.gov/cyberframework" }, { "slug": "oas-json-schema-2020-12", "name": "OpenAPI JSON Schema Dialect 2020-12", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "oauth-1-0a", "name": "OAuth 1.0a (RFC 5849)", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "oauth-2-0", "name": "OAuth 2.0 (RFC 6749)", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "oauth-2-1", "name": "OAuth 2.1 (Draft)", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": ["iso-27001", "soc2"], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "ocaml-5-2", "name": "OCaml 5.2 Spec", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "oci-image-1-1", "name": "OCI Image Spec 1.1", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "oci-runtime-1-1", "name": "OCI Runtime Spec 1.1", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "odata-4-01", "name": "OData 4.01", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "odbc-3-8", "name": "ODBC 3.8", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "odf-1-3", "name": "OpenDocument 1.3 (ISO/IEC 26300-1)", "category": "document-format", "domains": ["data"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "omg-mda-1-1", "name": "OMG MDA Guide v1.1", "category": "cloud-architecture", "domains": ["cloud", "architecture"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ooxml-ecma-376-4", "name": "Office Open XML (ECMA-376 4th)", "category": "document-format", "domains": ["data"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "opc-ua-1-05", "name": "OPC UA 1.05", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "openapi-2-0", "name": "OpenAPI Specification 2.0 (Swagger)", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "openapi-3-0", "name": "OpenAPI Specification 3.0", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "openapi-3-1", "name": "OpenAPI Specification 3.1", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "openapi-specification-3-1-0", "name": "OpenAPI Specification 3.1.0", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": "https://spec.openapis.org/oas/v3.1.0" }, { "slug": "openflow-1-5", "name": "OpenFlow 1.5", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "openid-connect-1-0", "name": "OpenID Connect 1.0", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "openssf-scorecard-4-10", "name": "OpenSSF Scorecard 4.10", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "opentelemetry-1-0-0", "name": "OpenTelemetry 1.0.0", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "opentracing-1-3", "name": "OpenTracing 1.3", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "orc-1-8", "name": "Apache ORC 1.8", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "owasp-api-top-10-2023", "name": "OWASP API Security Top 10 (2023)", "category": "security", "domains": ["security"], "frameworks": ["pci-dss", "soc2"], "projectTypes": ["api"], "complianceRelevant": true, "officialUrl": "https://owasp.org/API-Security/editions/2023/en/0x11-t10/" }, { "slug": "owasp-asvs-4-0", "name": "OWASP ASVS 4.0", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "owasp-asvs-5-0", "name": "OWASP Application Security Verification Standard (ASVS) 5.0", "category": "security", "domains": ["security"], "frameworks": ["hipaa", "iso-27001", "pci-dss", "soc2"], "projectTypes": ["web-app", "api"], "complianceRelevant": true, "officialUrl": "https://owasp.org/www-project-application-security-verification-standard/" }, { "slug": "owasp-top10-2023", "name": "OWASP Top 10 2023", "category": "security", "domains": ["security"], "frameworks": ["pci-dss"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "parquet-2-0", "name": "Apache Parquet 2.0", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "pci-dss-4-0", "name": "PCI-DSS 4.0", "category": "compliance", "domains": ["security", "governance"], "frameworks": ["pci-dss"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "pdf-1-7", "name": "PDF 1.7 (ISO 32000-1)", "category": "document-format", "domains": ["data"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "pdfa-4", "name": "PDF/A-4 (ISO 19005-4:2020)", "category": "document-format", "domains": ["data"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "pep-8", "name": "Python PEP 8 (Style Guide)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "perl-5-38", "name": "Perl 5.38 Syntax", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "php-8-3", "name": "PHP 8.3 Spec", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "pkcs12-v1-1", "name": "PKCS #12 v1.1", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "pkcs7-rfc-5652", "name": "PKCS #7 / CMS (RFC 5652)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "pmi-pmbok-7", "name": "PMI PMBOK 7th Edition", "category": "project-management", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "prince2-7", "name": "PRINCE2 7", "category": "project-management", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "prolog-1995", "name": "ISO/IEC 13211-1:1995 (Prolog)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "prometheus-expo-0-0-4", "name": "Prometheus Exposition Format 0.0.4", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "protobuf-v3", "name": "Protocol Buffers v3", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "python-3-12", "name": "Python 3.12 (PEP 693)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "restructuredtext-1-0", "name": "reStructuredText 1.0", "category": "documentation", "domains": ["documentation"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "rfc-2119", "name": "RFC 2119 (Keyword Conventions)", "category": "documentation", "domains": ["documentation"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "rfc-3339", "name": "RFC 3339 (Date/Time Format)", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "rfc-5280", "name": "RFC 5280 (PKIX)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "rfc-6962", "name": "RFC 6962 (Cert Transparency)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "rfc-7636", "name": "RFC 7636 (PKCE)", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "rfc-9081", "name": "RFC 9081 (IPFS HTTP Gateway)", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "rfc-9193", "name": "RFC 9193 (SFrame Media Encryption)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "ruby-3-1", "name": "ISO/IEC 30170:2022 (Ruby 3.1)", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "rust-2024", "name": "Rust 1.78 Edition 2024", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "safe-6-0", "name": "SAFe 6.0", "category": "project-management", "domains": ["process"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "saml-2-0", "name": "SAML 2.0 (OASIS)", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "sbvr-1-5", "name": "SBVR 1.5", "category": "modeling", "domains": ["architecture"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "scala-3-4", "name": "Scala 3.4 Reference", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "scim-2-0", "name": "SCIM 2.0 (RFC 7644)", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "section-508-2017", "name": "Section 508 Refresh (2017)", "category": "accessibility", "domains": ["accessibility", "frontend"], "frameworks": [], "projectTypes": ["web-app", "mobile"], "complianceRelevant": true, "officialUrl": null }, { "slug": "semver-2-0-0", "name": "SemVer 2.0.0", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sftp-rfc-9134", "name": "SFTP (RFC 9134)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "slsa-v1", "name": "SLSA v1 (Supply-Chain Levels)", "category": "security", "domains": ["security"], "frameworks": ["iso-27001", "nist-csf"], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "smb-3-1-1", "name": "SMB 3.1.1", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "snmp-v3", "name": "SNMP v3 (RFC 3411-3418)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "soap-1-2", "name": "SOAP 1.2", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "spdx-3-0", "name": "SPDX 3.0", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "spinnaker-spec", "name": "Spinnaker Deployment Spec", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-1986", "name": "ANSI SQL-86", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-1987", "name": "ISO/IEC 9075:1987 (SQL-87)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-1989", "name": "ANSI SQL-89", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-1992", "name": "ISO/IEC 9075:1992 (SQL-92)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-1999", "name": "ISO/IEC 9075:1999 (SQL:1999)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-2003", "name": "ISO/IEC 9075:2003 (SQL:2003)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-2006", "name": "ISO/IEC 9075:2006 (SQL:2006)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-2008", "name": "ISO/IEC 9075:2008 (SQL:2008)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-2011", "name": "ISO/IEC 9075:2011 (SQL:2011)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-2016", "name": "ISO/IEC 9075:2016 (SQL:2016)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-2019", "name": "ISO/IEC 9075:2019 (SQL:2019)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-2023", "name": "SQL:2023 (ISO/IEC 9075:2023)", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": "https://www.iso.org/standard/76583.html" }, { "slug": "sql-foundation-2016", "name": "SQL Foundation Part 2:2016", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-json-2019", "name": "SQL/JSON Part 15:2019", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-object-2023", "name": "SQL/Object Language Part 10:2023", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-psm-2016", "name": "SQL/PSM Part 4:2016", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sql-xml-2011", "name": "SQL/XML Part 14:2011", "category": "database-sql", "domains": ["data"], "frameworks": [], "projectTypes": ["data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ssh-2-0", "name": "SSH 2.0 (RFC 4251)", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "stomp-1-2", "name": "STOMP 1.2", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "swagger-1-2", "name": "Swagger 1.2", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "swift-5-9", "name": "Swift 5.9 Language Guide", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "sysml-1-6", "name": "SysML 1.6", "category": "modeling", "domains": ["architecture"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "terraform-hcl-2-0", "name": "Terraform HCL 2.0", "category": "devops", "domains": ["devops"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "thrift-0-16", "name": "Apache Thrift 0.16", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "tls-1-0", "name": "TLS 1.0 (RFC 2246)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "tls-1-1", "name": "TLS 1.1 (RFC 4346)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "tls-1-2", "name": "TLS 1.2 (RFC 5246)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "tls-1-3", "name": "TLS 1.3 (RFC 8446)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "togaf-10", "name": "TOGAF 10", "category": "cloud-architecture", "domains": ["cloud", "architecture"], "frameworks": [], "projectTypes": ["infra", "any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "typescript-5-4", "name": "TypeScript 5.4 Spec", "category": "programming-language", "domains": ["language"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "uk-gdpr-2021", "name": "UK GDPR 2021", "category": "compliance", "domains": ["security", "governance"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "uml-2-5-1", "name": "UML 2.5.1", "category": "modeling", "domains": ["architecture"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": false, "officialUrl": null }, { "slug": "unicode-15-1", "name": "Unicode 15.1", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "utf8-rfc-3629", "name": "UTF-8 (RFC 3629)", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "vc-data-2-0", "name": "VC Data Model 2.0", "category": "identity-auth", "domains": ["security", "identity"], "frameworks": [], "projectTypes": ["api", "web-app"], "complianceRelevant": true, "officialUrl": null }, { "slug": "wcag-2-2", "name": "W3C WCAG 2.2", "category": "accessibility", "domains": ["accessibility", "frontend"], "frameworks": [], "projectTypes": ["web-app", "mobile"], "complianceRelevant": true, "officialUrl": null }, { "slug": "websocket-rfc-6455", "name": "WebSocket (RFC 6455)", "category": "web-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["web-app", "api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "ws-security-1-2", "name": "WS-Security 1.2", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "wsdl-2-0", "name": "WSDL 2.0", "category": "api-spec", "domains": ["api"], "frameworks": [], "projectTypes": ["api"], "complianceRelevant": false, "officialUrl": null }, { "slug": "x509-2017", "name": "ISO/IEC 9594-8:2017 (X.509)", "category": "security", "domains": ["security"], "frameworks": [], "projectTypes": ["any"], "complianceRelevant": true, "officialUrl": null }, { "slug": "xml-1-0", "name": "XML 1.0 (Fifth Edition)", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "xml-namespaces-1-1", "name": "XML Namespaces 1.1", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "xsd-1-0", "name": "XML Schema Definition 1.0", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "xsd-1-1", "name": "XML Schema Definition 1.1", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "xslt-1-0", "name": "XSLT 1.0", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "xslt-2-0", "name": "XSLT 2.0", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "xslt-3-0", "name": "XSLT 3.0", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "yaml-1-2", "name": "YAML 1.2", "category": "data-format", "domains": ["data"], "frameworks": [], "projectTypes": ["api", "data"], "complianceRelevant": false, "officialUrl": null }, { "slug": "zigbee-3-0", "name": "Zigbee 3.0", "category": "network-protocol", "domains": ["networking"], "frameworks": [], "projectTypes": ["infra"], "complianceRelevant": false, "officialUrl": null }, { "slug": "zmtp-3-1", "name": "ZeroMQ ZMTP 3.1", "category": "messaging-protocol", "domains": ["integration"], "frameworks": [], "projectTypes": ["api", "infra"], "complianceRelevant": false, "officialUrl": null }];
+var complianceFrameworks = [{ "id": "iso-27001", "name": "ISO/IEC 27001:2022", "memberStandards": ["iso-iec-27001-2022", "iso-iec-27002-2022", "owasp-asvs-5-0", "oauth-2-1", "slsa-v1"], "controls": [{ "id": "A.5.15", "name": "Access control", "domain": "access" }, { "id": "A.5.16", "name": "Identity management", "domain": "identity" }, { "id": "A.8.5", "name": "Secure authentication", "domain": "identity" }, { "id": "A.8.8", "name": "Management of technical vulnerabilities", "domain": "supply-chain" }, { "id": "A.8.23", "name": "Web filtering / network controls", "domain": "transport" }, { "id": "A.8.24", "name": "Use of cryptography", "domain": "crypto" }, { "id": "A.8.15", "name": "Logging", "domain": "logging" }, { "id": "A.8.28", "name": "Secure coding", "domain": "appsec" }] }, { "id": "soc2", "name": "SOC 2 (Trust Services Criteria)", "memberStandards": ["aicpa-soc-2-tsc", "iso-iec-27001-2022", "owasp-asvs-5-0", "owasp-api-top-10-2023", "oauth-2-1"], "controls": [{ "id": "CC6.1", "name": "Logical access security", "domain": "identity" }, { "id": "CC6.3", "name": "Role-based access / least privilege", "domain": "access" }, { "id": "CC6.6", "name": "Boundary protection / abuse control", "domain": "transport" }, { "id": "CC6.7", "name": "Encryption in transit and at rest", "domain": "crypto" }, { "id": "CC7.1", "name": "Vulnerability detection", "domain": "supply-chain" }, { "id": "CC7.2", "name": "Security event monitoring", "domain": "logging" }, { "id": "CC8.1", "name": "Change management / secure SDLC", "domain": "appsec" }] }, { "id": "pci-dss", "name": "PCI DSS 4.0", "memberStandards": ["pci-dss-4-0", "owasp-asvs-5-0", "owasp-api-top-10-2023", "owasp-top10-2023"], "controls": [{ "id": "Req.3", "name": "Protect stored account data", "domain": "crypto" }, { "id": "Req.4", "name": "Protect data in transit", "domain": "transport" }, { "id": "Req.6", "name": "Secure systems and software", "domain": "appsec" }, { "id": "Req.8", "name": "Identify users and authenticate access", "domain": "identity" }, { "id": "Req.10", "name": "Log and monitor access", "domain": "logging" }] }, { "id": "nist-csf", "name": "NIST Cybersecurity Framework 2.0", "memberStandards": ["nist-csf-2-0", "nist-800-53-r5", "slsa-v1", "cyclonedx-1-6"], "controls": [{ "id": "GV", "name": "Govern", "domain": "governance" }, { "id": "ID.RA", "name": "Risk assessment", "domain": "supply-chain" }, { "id": "PR.AA", "name": "Identity management & access control", "domain": "identity" }, { "id": "PR.DS", "name": "Data security", "domain": "crypto" }, { "id": "DE.CM", "name": "Continuous monitoring", "domain": "logging" }] }, { "id": "hipaa", "name": "HIPAA Security Rule", "memberStandards": ["hipaa-security-rule", "iso-iec-27001-2022", "owasp-asvs-5-0"], "controls": [{ "id": "164.312(a)", "name": "Access control", "domain": "access" }, { "id": "164.312(e)", "name": "Transmission security", "domain": "transport" }, { "id": "164.312(b)", "name": "Audit controls", "domain": "logging" }] }, { "id": "gdpr", "name": "GDPR (EU 2016/679)", "memberStandards": ["gdpr-eu-2016-679", "iso-iec-27001-2022"], "controls": [{ "id": "Art.32", "name": "Security of processing", "domain": "crypto" }, { "id": "Art.30", "name": "Records of processing activities", "domain": "governance" }, { "id": "Art.17", "name": "Right to erasure", "domain": "privacy" }] }];
+
+// src/reporting/scanners/standards-mapper.ts
+var WEB_FRAMEWORK_RE = new RegExp(
+  "\\b(" + [
+    // JS/TS UI
+    "react",
+    "preact",
+    "next(?:\\.?js)?",
+    "remix",
+    "gatsby",
+    "vue",
+    "nuxt",
+    "angular",
+    "svelte(?:kit)?",
+    "solid(?:js|start)?",
+    "qwik",
+    "astro",
+    "ember",
+    "backbone",
+    "alpine",
+    "htmx",
+    "hotwire",
+    "turbo",
+    "stimulus",
+    "inertia",
+    // .NET UI
+    "blazor",
+    "razor",
+    "maui",
+    "wpf",
+    "winforms",
+    "xamarin",
+    "uno",
+    // Java/Kotlin/Scala UI
+    "jsf",
+    "thymeleaf",
+    "vaadin",
+    "wicket",
+    "gwt",
+    "compose(?: multiplatform)?",
+    // PHP UI
+    "livewire",
+    "filament",
+    "blade",
+    // Mobile / cross-platform UI
+    "flutter",
+    "swiftui",
+    "jetpack",
+    "react native"
+  ].join("|") + ")\\b"
+);
+var API_FRAMEWORK_RE = new RegExp(
+  "\\b(" + [
+    // Node/TS
+    "express",
+    "fastify",
+    "nest(?:js)?",
+    "koa",
+    "hapi",
+    "hono",
+    "adonis",
+    "sails",
+    "loopback",
+    "restify",
+    "feathers",
+    "h3",
+    "nitro",
+    "trpc",
+    // Python
+    "django",
+    "flask",
+    "fastapi",
+    "starlette",
+    "tornado",
+    "pyramid",
+    "sanic",
+    "aiohttp",
+    "bottle",
+    "falcon",
+    "cherrypy",
+    "quart",
+    "litestar",
+    "connexion",
+    // Java / Kotlin / Scala
+    "spring(?:boot)?",
+    "quarkus",
+    "micronaut",
+    "vert\\.?x",
+    "dropwizard",
+    "jersey",
+    "jax-?rs",
+    "struts",
+    "javalin",
+    "helidon",
+    "jhipster",
+    "ktor",
+    "http4s",
+    "finatra",
+    "scalatra",
+    "lagom",
+    "play",
+    "akka(?: ?http)?",
+    "spark java",
+    "ratpack",
+    // .NET
+    "asp\\.?net(?: ?core)?",
+    "signalr",
+    "nancy",
+    "servicestack",
+    "carter",
+    "minimal ?api",
+    "web ?api",
+    "mvc",
+    // Go
+    "gin",
+    "echo",
+    "fiber",
+    "chi",
+    "gorilla",
+    "beego",
+    "revel",
+    "buffalo",
+    "iris",
+    "gqlgen",
+    "mux",
+    "fasthttp",
+    // Ruby
+    "rails",
+    "sinatra",
+    "hanami",
+    "grape",
+    "padrino",
+    "roda",
+    "rack",
+    // PHP
+    "laravel",
+    "symfony",
+    "codeigniter",
+    "slim",
+    "lumen",
+    "yii",
+    "cakephp",
+    "phalcon",
+    "laminas",
+    "zend",
+    "fuel",
+    // Rust
+    "actix",
+    "axum",
+    "rocket",
+    "warp",
+    "tide",
+    "poem",
+    "salvo",
+    "hyper",
+    // Elixir
+    "phoenix",
+    "plug",
+    "cowboy",
+    // Swift / Dart
+    "vapor",
+    "kitura",
+    "hummingbird",
+    "perfect",
+    "shelf",
+    "aqueduct",
+    "conduit"
+  ].join("|") + ")\\b"
+);
+var API_DEP_STEMS = [
+  "springframework",
+  "spring-boot",
+  "springdoc",
+  "webflux",
+  "webmvc",
+  "quarkus",
+  "micronaut",
+  "dropwizard",
+  "jersey",
+  "resteasy",
+  "javalin",
+  "helidon",
+  "vertx",
+  "ratpack",
+  "restlet",
+  "django",
+  "fastapi",
+  "starlette",
+  "tornado",
+  "pyramid",
+  "sanic",
+  "aiohttp",
+  "litestar",
+  "falcon-",
+  "flask",
+  "express",
+  "fastify",
+  "nestjs",
+  "@nestjs",
+  "adonis",
+  "loopback",
+  "feathers",
+  "restify",
+  "aspnetcore",
+  "asp.net",
+  "servicestack",
+  "signalr",
+  "gin-gonic",
+  "gorilla/mux",
+  "gofiber",
+  "beego",
+  "buffalo",
+  "gqlgen",
+  "laravel",
+  "symfony",
+  "codeigniter",
+  "cakephp",
+  "phalcon",
+  "laminas",
+  "lumen",
+  "sinatra",
+  "hanami",
+  "grape",
+  "actix",
+  "axum",
+  "rocket",
+  "salvo",
+  "warp-",
+  "phoenix",
+  "cowboy",
+  "vapor",
+  "kitura",
+  "hummingbird",
+  "perfect-",
+  "aqueduct",
+  "conduit",
+  "rails",
+  "railties",
+  "actionpack"
+];
+var WEB_DEP_STEMS = [
+  "react",
+  "preact",
+  "next",
+  "nuxt",
+  "remix",
+  "gatsby",
+  "vue",
+  "angular",
+  "@angular",
+  "svelte",
+  "solid-js",
+  "qwik",
+  "astro",
+  "ember",
+  "backbone",
+  "blazor",
+  "razor",
+  "vaadin",
+  "thymeleaf",
+  "wicket",
+  "livewire",
+  "filament",
+  "inertia",
+  "flutter",
+  "jetpack",
+  "swiftui"
+];
+function matchesStem(haystack, stems) {
+  return stems.some((s) => haystack.includes(s));
+}
+var ML_RE = /\b(tensorflow|pytorch|torch|keras|jax|sklearn|scikit-?learn|pandas|numpy|scipy|xgboost|lightgbm|catboost|mxnet|spacy|transformers|huggingface|langchain|llama|onnx|mlflow|kubeflow|sagemaker|spark ?ml|mllib)\b/;
+var INFRA_RE = /\b(terraform|pulumi|kubernetes|\bk8s\b|helm|ansible|cdktf|aws cdk|\bcdk\b|bicep|crossplane|serverless framework|\bsst\b|cloudformation|packer|nomad)\b/;
+function archetypeCategory(archetype) {
+  switch (archetype) {
+    case "nextjs":
+    case "remix":
+    case "sveltekit":
+    case "nuxt":
+      return { category: "web-app", signal: `archetype:${archetype}` };
+    case "nestjs":
+    case "express":
+    case "fastify":
+    case "hono":
+    case "koa":
+    case "serverless":
+      return { category: "api", signal: `archetype:${archetype}` };
+    case "library":
+      return { category: "library", signal: "archetype:library" };
+    case "cli":
+      return { category: "cli", signal: "archetype:cli" };
+    default:
+      return null;
+  }
+}
+function inferProjectPurpose(project, uiPurpose) {
+  const signals = [];
+  const votes = {};
+  const vote = (category, weight, signal) => {
+    votes[category] = (votes[category] ?? 0) + weight;
+    signals.push(signal);
+  };
+  if (project.type === "node" || project.type === "typescript") {
+    const arch = archetypeCategory(project.architecture?.archetype);
+    if (arch) vote(arch.category, 3, arch.signal);
+  }
+  const fwNames = (project.frameworks ?? []).map((f) => f.name.toLowerCase());
+  const uiFw = (uiPurpose?.detectedFrameworks ?? []).map((f) => f.toLowerCase());
+  const fwText = [...fwNames, ...uiFw].join(" ");
+  if (WEB_FRAMEWORK_RE.test(fwText)) vote("web-app", 2, "web-framework");
+  if (API_FRAMEWORK_RE.test(fwText)) vote("api", 2, "api-framework");
+  const depText = (project.dependencies ?? []).map((d) => d.package.toLowerCase()).join(" ");
+  if (matchesStem(depText, WEB_DEP_STEMS)) vote("web-app", 1, "web-dependency");
+  if (matchesStem(depText, API_DEP_STEMS)) vote("api", 1, "api-dependency");
+  if (uiPurpose && (uiPurpose.routes?.length || uiPurpose.samples?.length)) {
+    vote("web-app", 1, "ui-evidence");
+  }
+  const haystack = `${fwText} ${depText}`;
+  if (ML_RE.test(haystack)) vote("ml", 2, "ml-libs");
+  if (INFRA_RE.test(haystack)) vote("infra", 2, "infra-tooling");
+  const entries = Object.entries(votes).sort((a, b) => b[1] - a[1]);
+  if (entries.length === 0) {
+    return { project: project.name, category: "any", confidence: 0.3, signals: ["no-strong-signal"] };
+  }
+  const [topCategory, topWeight] = entries[0];
+  const total = entries.reduce((s, [, w]) => s + w, 0);
+  const confidence = Math.min(0.95, 0.4 + topWeight / total * 0.55);
+  return {
+    project: project.name,
+    category: topCategory,
+    confidence: Number(confidence.toFixed(2)),
+    signals: [...new Set(signals)]
+  };
+}
+function appliesToPurpose(entry, category) {
+  if (!entry.projectTypes || entry.projectTypes.length === 0) return false;
+  return entry.projectTypes.includes("any") || entry.projectTypes.includes(category);
+}
+var AFFINITY = {
+  api: { categories: ["security", "api-spec"], domains: ["api", "security"] },
+  "web-app": { categories: ["security", "accessibility"], domains: ["security", "accessibility", "frontend"] },
+  library: { categories: ["software-process", "programming-language"], domains: ["process", "language"] },
+  cli: { categories: ["software-process"], domains: ["process"] },
+  data: { categories: ["database-sql", "data-format"], domains: ["data"] },
+  ml: { categories: ["ai-governance"], domains: ["ai"] },
+  infra: { categories: ["devops", "cloud-architecture"], domains: ["devops", "cloud"] }
+};
+function rankStandardsForCategory(category) {
+  const affinity = AFFINITY[category] ?? { categories: [], domains: [] };
+  const ranked = standardsIndex.filter((e) => appliesToPurpose(e, category)).map((e) => {
+    const tight = e.projectTypes.includes(category) && !e.projectTypes.includes("any");
+    const catIdx = affinity.categories.indexOf(e.category);
+    const categoryAffinity = catIdx >= 0 ? (affinity.categories.length - catIdx) * 2 : 0;
+    const domainAffinity = e.domains.some((d) => affinity.domains.includes(d)) ? 1 : 0;
+    const score = categoryAffinity + domainAffinity + (e.complianceRelevant ? 2 : 0) + (tight ? 1 : 0);
+    return { e, score, tight };
+  }).sort((a, b) => b.score - a.score || a.e.slug.localeCompare(b.e.slug));
+  return ranked.map(({ e, score, tight }) => ({
+    score,
+    rec: {
+      slug: e.slug,
+      name: e.name,
+      category: e.category,
+      reason: tight ? `Applies specifically to ${category} projects` : e.complianceRelevant ? "Compliance-relevant standard applicable to this stack" : "Generally applicable standard",
+      matchedProjectTypes: [category],
+      frameworks: e.frameworks,
+      complianceRelevant: e.complianceRelevant,
+      officialUrl: e.officialUrl
+    }
+  }));
+}
+function recommendStandards(projects, extended, options = {}) {
+  const perCategoryLimit = options.perCategoryLimit ?? 10;
+  const totalLimit = options.totalLimit ?? 40;
+  const fallbackUi = extended?.uiPurpose ? {
+    samples: [],
+    routes: [],
+    detectedFrameworks: extended.uiPurpose.detectedFrameworks ?? []
+  } : void 0;
+  const projectPurposes = projects.map((p) => inferProjectPurpose(p, p.uiPurpose ?? fallbackUi));
+  const categories = [...new Set(projectPurposes.map((p) => p.category))];
+  const bySlug = /* @__PURE__ */ new Map();
+  const scoreBySlug = /* @__PURE__ */ new Map();
+  for (const category of categories) {
+    const ranked = rankStandardsForCategory(category).slice(0, perCategoryLimit);
+    for (const { rec, score } of ranked) {
+      const existing = bySlug.get(rec.slug);
+      if (existing) {
+        if (!existing.matchedProjectTypes.includes(category)) existing.matchedProjectTypes.push(category);
+        scoreBySlug.set(rec.slug, Math.max(scoreBySlug.get(rec.slug) ?? 0, score));
+      } else {
+        bySlug.set(rec.slug, { ...rec });
+        scoreBySlug.set(rec.slug, score);
+      }
+    }
+  }
+  const recommended = [...bySlug.values()].sort(
+    (a, b) => (scoreBySlug.get(b.slug) ?? 0) - (scoreBySlug.get(a.slug) ?? 0) || b.matchedProjectTypes.length - a.matchedProjectTypes.length || a.slug.localeCompare(b.slug)
+  ).slice(0, totalLimit);
+  const recommendedSlugs = new Set(recommended.map((r) => r.slug));
+  const frameworks = complianceFrameworks.map((fw) => ({
+    id: fw.id,
+    name: fw.name,
+    recommendedMembers: fw.memberStandards.filter((s) => recommendedSlugs.has(s)).length,
+    totalMembers: fw.memberStandards.length
+  })).filter((f) => f.recommendedMembers > 0).sort((a, b) => b.recommendedMembers - a.recommendedMembers);
+  return { projectPurposes, recommended, frameworks };
+}
+
+// src/reporting/advanced-analysis.ts
+async function runAdvancedAnalysis(ctx) {
+  const { rootDir, opts, scanners, maxPrivacyMode, allProjects, solutions, projectsByPath, fileCache, progress, extended } = ctx;
+  if (scanners === false) {
+    extended.standards = recommendStandards(allProjects, extended);
+    return;
+  }
+  const scannerPolicy = {
+    platformMatrix: !maxPrivacyMode,
+    serviceDependencies: !maxPrivacyMode,
+    breakingChangeExposure: !maxPrivacyMode,
+    buildDeploy: !maxPrivacyMode,
+    tsModernity: !maxPrivacyMode,
+    fileHotspots: !maxPrivacyMode,
+    architecture: !maxPrivacyMode,
+    codeQuality: !maxPrivacyMode};
+  const advancedSteps = [
+    ...scannerPolicy.platformMatrix && scanners?.platformMatrix?.enabled !== false ? [{ id: "platform", label: "Platform matrix" }] : [],
+    ...scanners?.toolingInventory?.enabled !== false ? [{ id: "tooling", label: "Tooling inventory" }] : [],
+    ...scannerPolicy.serviceDependencies && scanners?.serviceDependencies?.enabled !== false ? [{ id: "services", label: "Service dependencies" }] : [],
+    ...scannerPolicy.breakingChangeExposure && scanners?.breakingChangeExposure?.enabled !== false ? [{ id: "breaking", label: "Breaking change exposure" }] : [],
+    ...scanners?.securityPosture?.enabled !== false ? [{ id: "security", label: "Security posture" }] : [],
+    ...scannerPolicy.buildDeploy && scanners?.buildDeploy?.enabled !== false ? [{ id: "build", label: "Build & deploy analysis" }] : [],
+    ...scannerPolicy.tsModernity && scanners?.tsModernity?.enabled !== false ? [{ id: "ts", label: "TypeScript modernity" }] : [],
+    ...scannerPolicy.fileHotspots && scanners?.fileHotspots?.enabled !== false ? [{ id: "hotspots", label: "File hotspots" }] : [],
+    ...scanners?.dependencyGraph?.enabled !== false ? [{ id: "depgraph", label: "Dependency graph" }] : [],
+    ...scanners?.dependencyRisk?.enabled !== false ? [{ id: "deprisk", label: "Dependency risk" }] : [],
+    ...scannerPolicy.architecture && scanners?.architecture?.enabled !== false ? [{ id: "architecture", label: "Architecture layers" }] : [],
+    ...scannerPolicy.codeQuality && scanners?.codeQuality?.enabled !== false ? [{ id: "codequality", label: "Code quality metrics" }] : [],
+    ...!maxPrivacyMode && (opts.uiPurpose || scanners?.uiPurpose?.enabled === true) ? [{ id: "uipurpose", label: "UI purpose evidence" }] : []
+  ];
+  for (const step of advancedSteps) {
+    progress.insertStepBefore("drift", step);
+  }
+  const scannerTasks = [];
+  if (scannerPolicy.platformMatrix && scanners?.platformMatrix?.enabled !== false) {
+    progress.startStep("platform");
+    scannerTasks.push(
+      scanPlatformMatrix(rootDir, fileCache).then((result) => {
+        extended.platformMatrix = result;
+        const nativeCount = result.nativeModules.length;
+        const dockerCount = result.dockerBaseImages.length;
+        const parts = [];
+        if (nativeCount > 0) parts.push(`${nativeCount} native`);
+        if (dockerCount > 0) parts.push(`${dockerCount} docker`);
+        progress.completeStep("platform", parts.join(", ") || "clean", nativeCount + dockerCount);
+      })
+    );
+  }
+  if (scanners?.toolingInventory?.enabled !== false) {
+    progress.startStep("tooling");
+    scannerTasks.push(
+      Promise.resolve().then(() => {
+        extended.toolingInventory = scanToolingInventory(allProjects);
+        const toolCount = Object.values(extended.toolingInventory).reduce((sum, arr) => sum + arr.length, 0);
+        progress.completeStep("tooling", `${toolCount} tool${toolCount !== 1 ? "s" : ""} mapped`, toolCount);
+      })
+    );
+  }
+  if (scannerPolicy.serviceDependencies && scanners?.serviceDependencies?.enabled !== false) {
+    progress.startStep("services");
+    scannerTasks.push(
+      Promise.resolve().then(() => {
+        extended.serviceDependencies = scanServiceDependencies(allProjects);
+        const svcCount = Object.values(extended.serviceDependencies).reduce((sum, arr) => sum + arr.length, 0);
+        progress.completeStep("services", `${svcCount} service${svcCount !== 1 ? "s" : ""} detected`, svcCount);
+      })
+    );
+  }
+  if (scannerPolicy.breakingChangeExposure && scanners?.breakingChangeExposure?.enabled !== false) {
+    progress.startStep("breaking");
+    scannerTasks.push(
+      Promise.resolve().then(async () => {
+        extended.breakingChangeExposure = await scanBreakingChangeExposure(allProjects, rootDir, fileCache);
+        const bc = extended.breakingChangeExposure;
+        const bcTotal = bc.deprecatedPackages.length + bc.legacyPolyfills.length;
+        progress.completeStep(
+          "breaking",
+          bcTotal > 0 ? `${bc.deprecatedPackages.length} deprecated, ${bc.legacyPolyfills.length} polyfills` : "none found",
+          bcTotal
+        );
+      })
+    );
+  }
+  if (scanners?.securityPosture?.enabled !== false) {
+    progress.startStep("security");
+    scannerTasks.push(
+      scanSecurityPosture(rootDir, fileCache).then((result) => {
+        extended.securityPosture = result;
+        const secDetail = result.lockfilePresent ? `lockfile \u2714${result.gitignoreCoversEnv ? " \xB7 .env \u2714" : " \xB7 .env \u2716"}` : "no lockfile";
+        progress.completeStep("security", secDetail);
+      })
+    );
+  }
+  if (scannerPolicy.buildDeploy && scanners?.buildDeploy?.enabled !== false) {
+    progress.startStep("build");
+    scannerTasks.push(
+      scanBuildDeploy(rootDir, fileCache).then((result) => {
+        extended.buildDeploy = result;
+        const bdParts = [];
+        if (result.ci.length > 0) bdParts.push(result.ci.join(", "));
+        if (result.docker.dockerfileCount > 0) bdParts.push(`${result.docker.dockerfileCount} Dockerfile${result.docker.dockerfileCount !== 1 ? "s" : ""}`);
+        progress.completeStep("build", bdParts.join(" \xB7 ") || "none detected");
+      })
+    );
+  }
+  if (scannerPolicy.tsModernity && scanners?.tsModernity?.enabled !== false) {
+    progress.startStep("ts");
+    scannerTasks.push(
+      scanTsModernity(rootDir, fileCache).then((result) => {
+        extended.tsModernity = result;
+        const tsParts = [];
+        if (result.typescriptVersion) tsParts.push(`v${result.typescriptVersion}`);
+        if (result.strict === true) tsParts.push("strict");
+        if (result.moduleType) tsParts.push(result.moduleType.toUpperCase());
+        progress.completeStep("ts", tsParts.join(" \xB7 ") || "no tsconfig");
+      })
+    );
+  }
+  if (scannerPolicy.fileHotspots && scanners?.fileHotspots?.enabled !== false) {
+    progress.startStep("hotspots");
+    scannerTasks.push(
+      scanFileHotspots(rootDir, fileCache).then((result) => {
+        extended.fileHotspots = result;
+        progress.completeStep("hotspots", `${result.totalFiles} files`, result.totalFiles);
+      })
+    );
+  }
+  if (scanners?.dependencyGraph?.enabled !== false) {
+    progress.startStep("depgraph");
+    scannerTasks.push(
+      scanDependencyGraph(rootDir, fileCache).then((result) => {
+        extended.dependencyGraph = result;
+        const dgDetail = result.lockfileType ? `${result.lockfileType} \xB7 ${result.totalUnique} unique` : "no lockfile";
+        progress.completeStep("depgraph", dgDetail, result.totalUnique);
+      })
+    );
+  }
+  if (scannerPolicy.codeQuality && scanners?.codeQuality?.enabled !== false) {
+    progress.startStep("codequality");
+    scannerTasks.push(
+      scanCodeQuality(rootDir, fileCache).then((result) => {
+        extended.codeQuality = result;
+        const cqParts = [];
+        cqParts.push(`${result.filesAnalyzed} files`);
+        cqParts.push(`${result.functionsAnalyzed} functions`);
+        if (result.circularDependencies > 0) cqParts.push(`${result.circularDependencies} cycles`);
+        progress.completeStep("codequality", cqParts.join(" \xB7 "), result.functionsAnalyzed);
+      })
+    );
+  }
+  if (scanners?.dependencyRisk?.enabled !== false) {
+    progress.startStep("deprisk");
+    scannerTasks.push(
+      Promise.resolve().then(() => {
+        extended.dependencyRisk = scanDependencyRisk(allProjects);
+        const dr = extended.dependencyRisk;
+        const drParts = [];
+        if (dr.deprecatedPackages.length > 0) drParts.push(`${dr.deprecatedPackages.length} deprecated`);
+        if (dr.nativeModulePackages.length > 0) drParts.push(`${dr.nativeModulePackages.length} native`);
+        progress.completeStep("deprisk", drParts.join(", ") || "low risk");
+      })
+    );
+  }
+  await Promise.all(scannerTasks);
+  if (!maxPrivacyMode && scanners?.uiPurpose?.enabled !== false) {
+    progress.startStep("uipurpose");
+    extended.uiPurpose = await scanUiPurpose(rootDir, fileCache);
+    const up = extended.uiPurpose;
+    const summary = [`${up.topEvidence.length} evidence`, ...up.capped ? ["capped"] : []].join(" \xB7 ");
+    progress.completeStep("uipurpose", summary, up.topEvidence.length);
+    await Promise.all(allProjects.map(async (project) => {
+      const projectDir = path3.join(rootDir, project.path);
+      const projectResult = await scanUiPurpose(projectDir, fileCache, 150);
+      if (projectResult.topEvidence.length > 0) {
+        project.uiPurpose = compactUiPurpose(projectResult);
+      }
+    }));
+  }
+  if (scannerPolicy.architecture && scanners?.architecture?.enabled !== false) {
+    progress.startStep("architecture");
+    extended.architecture = await scanArchitecture(
+      rootDir,
+      allProjects,
+      extended.toolingInventory,
+      extended.serviceDependencies,
+      fileCache
+    );
+    const arch = extended.architecture;
+    const layerCount = arch.layers.filter((l) => l.fileCount > 0).length;
+    await Promise.all(allProjects.map(async (project) => {
+      project.architectureMermaid = await buildProjectArchitectureMermaid(
+        rootDir,
+        project,
+        arch.archetype,
+        fileCache
+      );
+      project.architecture = await scanProjectArchitecture(rootDir, project, fileCache);
+    }));
+    for (const solution of solutions) {
+      const memberProjects = solution.projectPaths.map((pp) => projectsByPath.get(pp) ?? projectsByPath.get(path3.dirname(pp).replace(/\\/g, "/"))).filter((p) => Boolean(p));
+      const memberArchResults = memberProjects.map((p) => p.architecture).filter((a) => Boolean(a));
+      if (memberArchResults.length > 0) {
+        solution.architecture = aggregateSolutionArchitecture(memberArchResults);
+      }
+    }
+    progress.completeStep(
+      "architecture",
+      `${arch.archetype} \xB7 ${layerCount} layer${layerCount !== 1 ? "s" : ""} \xB7 ${arch.totalClassified} files`,
+      layerCount
+    );
+  }
+  extended.standards = recommendStandards(allProjects, extended);
+  let advancedFiles = 0;
+  if (extended.fileHotspots) advancedFiles += extended.fileHotspots.totalFiles;
+  if (extended.securityPosture) advancedFiles += 1;
+  if (extended.tsModernity?.typescriptVersion) advancedFiles += 1;
+  if (extended.dependencyGraph?.lockfileType) advancedFiles += 1;
+  if (extended.buildDeploy) {
+    advancedFiles += extended.buildDeploy.docker.dockerfileCount;
+    advancedFiles += extended.buildDeploy.ci.length;
+  }
+  if (extended.codeQuality) advancedFiles += extended.codeQuality.filesAnalyzed;
+  if (extended.uiPurpose) advancedFiles += extended.uiPurpose.topEvidence.length;
+  if (advancedFiles > 0) ctx.addFilesScanned(advancedFiles);
+}
+var advancedScanHook = runAdvancedAnalysis;
+
+// src/reporting/advanced-hook.ts
+async function loadAdvancedScanHook() {
+  return advancedScanHook;
+}
+
+// src/reporting/commands/baseline.ts
+async function runBaseline(rootDir) {
+  console.log(chalk.dim("Creating baseline..."));
+  const advanced = await loadAdvancedScanHook();
+  const artifact = await runCoreScan(rootDir, {
+    format: "text",
+    concurrency: 8
+  }, advanced);
+  const baselinePath = path3.join(rootDir, ".vibgrate", "baseline.json");
+  await writeJsonFile(baselinePath, artifact);
+  console.log(chalk.green("\u2714") + ` Baseline saved to ${chalk.bold(".vibgrate/baseline.json")}`);
+  console.log(chalk.dim(`  Baseline score: ${artifact.drift.score}/100`));
+}
+var baselineCommand = new Command("baseline").description("Create a drift baseline snapshot").argument("[path]", "Path to baseline", ".").action(async (targetPath) => {
+  const rootDir = path3.resolve(targetPath);
+  await runBaseline(rootDir);
+});
+
+export { baselineCommand, loadAdvancedScanHook, runBaseline };
+//# sourceMappingURL=chunk-FU4MOQTC.js.map
+//# sourceMappingURL=chunk-FU4MOQTC.js.map