@schemasentry/cli 0.5.0 → 0.6.0

package/dist/index.js

@@ -1,541 +1,14 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command } from "commander";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { readFileSync } from "fs";
-import path6 from "path";
-import { stableStringify as stableStringify4 } from "@schemasentry/core";
-
-// src/report.ts
-import {
-  stableStringify,
-  validateSchema
-} from "@schemasentry/core";
-
-// src/coverage.ts
-var buildCoverageResult = (input2, data) => {
-  const manifestRoutes = input2.expectedTypesByRoute ?? {};
-  const dataRoutes = data.routes ?? {};
-  const derivedRequiredRoutes = Object.entries(manifestRoutes).filter(([, types]) => (types ?? []).length > 0).map(([route]) => route);
-  const requiredRoutes = /* @__PURE__ */ new Set([
-    ...input2.requiredRoutes ?? [],
-    ...derivedRequiredRoutes
-  ]);
-  const allRoutes = Array.from(
-    /* @__PURE__ */ new Set([
-      ...Object.keys(manifestRoutes),
-      ...requiredRoutes,
-      ...Object.keys(dataRoutes)
-    ])
-  ).sort();
-  const issuesByRoute = {};
-  const summary = {
-    missingRoutes: 0,
-    missingTypes: 0,
-    unlistedRoutes: 0
-  };
-  for (const route of allRoutes) {
-    const issues = [];
-    const expectedTypes = manifestRoutes[route] ?? [];
-    const nodes = dataRoutes[route] ?? [];
-    const foundTypes = nodes.map((node) => node["@type"]).filter((type) => typeof type === "string");
-    if (requiredRoutes.has(route) && nodes.length === 0) {
-      issues.push({
-        path: `routes["${route}"]`,
-        message: "No schema blocks found for route",
-        severity: "error",
-        ruleId: "coverage.missing_route"
-      });
-      summary.missingRoutes += 1;
-    }
-    for (const expectedType of expectedTypes) {
-      if (!foundTypes.includes(expectedType)) {
-        issues.push({
-          path: `routes["${route}"].types`,
-          message: `Missing expected schema type '${expectedType}'`,
-          severity: "error",
-          ruleId: "coverage.missing_type"
-        });
-        summary.missingTypes += 1;
-      }
-    }
-    if (!manifestRoutes[route] && !requiredRoutes.has(route) && nodes.length > 0) {
-      issues.push({
-        path: `routes["${route}"]`,
-        message: "Route has schema but is missing from manifest",
-        severity: "warn",
-        ruleId: "coverage.unlisted_route"
-      });
-      summary.unlistedRoutes += 1;
-    }
-    if (issues.length > 0) {
-      issuesByRoute[route] = issues;
-    }
-  }
-  return {
-    allRoutes,
-    issuesByRoute,
-    summary
-  };
-};
-
-// src/report.ts
-var buildReport = (manifest, data, options = {}) => {
-  const manifestRoutes = manifest.routes ?? {};
-  const dataRoutes = data.routes ?? {};
-  const coverage = buildCoverageResult(
-    { expectedTypesByRoute: manifestRoutes },
-    data
-  );
-  const routes = coverage.allRoutes.map((route) => {
-    const expectedTypes = manifestRoutes[route] ?? [];
-    const nodes = dataRoutes[route] ?? [];
-    const foundTypes = nodes.map((node) => node["@type"]).filter((type) => typeof type === "string");
-    const validation = validateSchema(nodes, options);
-    const issues = [
-      ...validation.issues,
-      ...coverage.issuesByRoute[route] ?? []
-    ];
-    const errorCount = issues.filter((issue) => issue.severity === "error").length;
-    const warnCount = issues.filter((issue) => issue.severity === "warn").length;
-    const score = Math.max(0, validation.score - errorCount * 5 - warnCount * 2);
-    return {
-      route,
-      ok: errorCount === 0,
-      score,
-      issues,
-      expectedTypes,
-      foundTypes
-    };
-  });
-  const summaryErrors = routes.reduce(
-    (count, route) => count + route.issues.filter((i) => i.severity === "error").length,
-    0
-  );
-  const summaryWarnings = routes.reduce(
-    (count, route) => count + route.issues.filter((i) => i.severity === "warn").length,
-    0
-  );
-  const summaryScore = routes.length === 0 ? 0 : Math.round(
-    routes.reduce((total, route) => total + route.score, 0) / routes.length
-  );
-  return {
-    ok: summaryErrors === 0,
-    summary: {
-      routes: routes.length,
-      errors: summaryErrors,
-      warnings: summaryWarnings,
-      score: summaryScore,
-      coverage: coverage.summary
-    },
-    routes
-  };
-};
-
-// src/init.ts
-import { promises as fs } from "fs";
-import path from "path";
-import { SCHEMA_CONTEXT } from "@schemasentry/core";
-var DEFAULT_ANSWERS = {
-  siteName: "Acme Corp",
-  siteUrl: "https://acme.com",
-  authorName: "Jane Doe"
-};
-var getDefaultAnswers = () => ({ ...DEFAULT_ANSWERS });
-var buildManifest = (scannedRoutes = []) => {
-  const routes = {
-    "/": ["Organization", "WebSite"],
-    "/blog/[slug]": ["Article"]
-  };
-  for (const route of scannedRoutes) {
-    if (!routes[route]) {
-      routes[route] = ["WebPage"];
-    }
-  }
-  return { routes };
-};
-var formatDate = (value) => value.toISOString().slice(0, 10);
-var buildData = (answers, options = {}) => {
-  const { siteName, siteUrl, authorName } = answers;
-  const normalizedSiteUrl = normalizeUrl(siteUrl);
-  const today = options.today ?? /* @__PURE__ */ new Date();
-  const date = formatDate(today);
-  const logoUrl = new URL("/logo.png", normalizedSiteUrl).toString();
-  const articleUrl = new URL("/blog/hello-world", normalizedSiteUrl).toString();
-  const imageUrl = new URL("/blog/hello-world.png", normalizedSiteUrl).toString();
-  const routes = {
-    "/": [
-      {
-        "@context": SCHEMA_CONTEXT,
-        "@type": "Organization",
-        name: siteName,
-        url: normalizedSiteUrl,
-        logo: logoUrl,
-        description: `Official website of ${siteName}`
-      },
-      {
-        "@context": SCHEMA_CONTEXT,
-        "@type": "WebSite",
-        name: siteName,
-        url: normalizedSiteUrl,
-        description: `Learn more about ${siteName}`
-      }
-    ],
-    "/blog/[slug]": [
-      {
-        "@context": SCHEMA_CONTEXT,
-        "@type": "Article",
-        headline: "Hello World",
-        author: {
-          "@type": "Person",
-          name: authorName
-        },
-        datePublished: date,
-        dateModified: date,
-        description: `An introduction to ${siteName}`,
-        image: imageUrl,
-        url: articleUrl
-      }
-    ]
-  };
-  for (const route of options.scannedRoutes ?? []) {
-    if (routes[route]) {
-      continue;
-    }
-    routes[route] = [
-      {
-        "@context": SCHEMA_CONTEXT,
-        "@type": "WebPage",
-        name: routeToName(route),
-        url: new URL(route, normalizedSiteUrl).toString()
-      }
-    ];
-  }
-  return { routes };
-};
-var writeInitFiles = async (options) => {
-  const {
-    manifestPath,
-    dataPath,
-    overwriteManifest,
-    overwriteData,
-    answers,
-    today,
-    scannedRoutes
-  } = options;
-  const manifest = buildManifest(scannedRoutes ?? []);
-  const data = buildData(answers, { today, scannedRoutes });
-  const manifestResult = await writeJsonFile(
-    manifestPath,
-    manifest,
-    overwriteManifest
-  );
-  const dataResult = await writeJsonFile(dataPath, data, overwriteData);
-  return {
-    manifest: manifestResult,
-    data: dataResult
-  };
-};
-var writeJsonFile = async (filePath, payload, overwrite) => {
-  const exists = await fileExists(filePath);
-  if (exists && !overwrite) {
-    return "skipped";
-  }
-  await fs.mkdir(path.dirname(filePath), { recursive: true });
-  const json = JSON.stringify(payload, null, 2);
-  await fs.writeFile(filePath, `${json}
-`, "utf8");
-  return exists ? "overwritten" : "created";
-};
-var fileExists = async (filePath) => {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-};
-var normalizeUrl = (value) => {
-  try {
-    return new URL(value).toString();
-  } catch {
-    return new URL(`https://${value}`).toString();
-  }
-};
-var routeToName = (route) => {
-  if (route === "/") {
-    return "Home";
-  }
-  const cleaned = route.replace(/\[|\]/g, "").split("/").filter(Boolean).join(" ");
-  return cleaned.split(/\s+/).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
-};
-
-// src/audit.ts
-import {
-  validateSchema as validateSchema2
-} from "@schemasentry/core";
-var buildAuditReport = (data, options = {}) => {
-  const dataRoutes = data.routes ?? {};
-  const manifestRoutes = options.manifest?.routes ?? {};
-  const coverageEnabled = Boolean(options.manifest || options.requiredRoutes?.length);
-  const coverage = coverageEnabled ? buildCoverageResult(
-    {
-      expectedTypesByRoute: manifestRoutes,
-      requiredRoutes: options.requiredRoutes
-    },
-    data
-  ) : null;
-  const allRoutes = coverageEnabled ? coverage?.allRoutes ?? [] : Object.keys(dataRoutes).sort();
-  const routes = allRoutes.map((route) => {
-    const expectedTypes = coverageEnabled ? manifestRoutes[route] ?? [] : [];
-    const nodes = dataRoutes[route] ?? [];
-    const foundTypes = nodes.map((node) => node["@type"]).filter((type) => typeof type === "string");
-    const validation = validateSchema2(nodes, options);
-    const issues = [
-      ...validation.issues,
-      ...coverage?.issuesByRoute[route] ?? []
-    ];
-    const errorCount = issues.filter((issue) => issue.severity === "error").length;
-    const warnCount = issues.filter((issue) => issue.severity === "warn").length;
-    const score = Math.max(0, validation.score - errorCount * 5 - warnCount * 2);
-    return {
-      route,
-      ok: errorCount === 0,
-      score,
-      issues,
-      expectedTypes,
-      foundTypes
-    };
-  });
-  const summaryErrors = routes.reduce(
-    (count, route) => count + route.issues.filter((i) => i.severity === "error").length,
-    0
-  );
-  const summaryWarnings = routes.reduce(
-    (count, route) => count + route.issues.filter((i) => i.severity === "warn").length,
-    0
-  );
-  const summaryScore = routes.length === 0 ? 0 : Math.round(
-    routes.reduce((total, route) => total + route.score, 0) / routes.length
-  );
-  return {
-    ok: summaryErrors === 0,
-    summary: {
-      routes: routes.length,
-      errors: summaryErrors,
-      warnings: summaryWarnings,
-      score: summaryScore,
-      ...coverageEnabled ? { coverage: coverage?.summary } : {}
-    },
-    routes
-  };
-};
-
-// src/summary.ts
-var formatDuration = (durationMs) => {
-  if (!Number.isFinite(durationMs) || durationMs < 0) {
-    return "0ms";
-  }
-  if (durationMs < 1e3) {
-    return `${Math.round(durationMs)}ms`;
-  }
-  const seconds = durationMs / 1e3;
-  return `${seconds.toFixed(seconds < 10 ? 1 : 0)}s`;
-};
-var formatSummaryLine = (label, stats) => {
-  const parts = [
-    `Routes: ${stats.routes}`,
-    `Errors: ${stats.errors}`,
-    `Warnings: ${stats.warnings}`,
-    `Score: ${stats.score}`,
-    `Duration: ${formatDuration(stats.durationMs)}`
-  ];
-  if (stats.coverage) {
-    parts.push(
-      `Coverage: missing_routes=${stats.coverage.missingRoutes} missing_types=${stats.coverage.missingTypes} unlisted_routes=${stats.coverage.unlistedRoutes}`
-    );
-  }
-  return `${label} | ${parts.join(" | ")}`;
-};
-
-// src/config.ts
-import { promises as fs2 } from "fs";
-import path2 from "path";
-var ConfigError = class extends Error {
-  constructor(code, message, suggestion) {
-    super(message);
-    this.code = code;
-    this.suggestion = suggestion;
-  }
-};
-var DEFAULT_CONFIG_PATH = "schema-sentry.config.json";
-var loadConfig = async (options) => {
-  const cwd = options.cwd ?? process.cwd();
-  const explicit = Boolean(options.configPath);
-  const resolvedPath = path2.resolve(cwd, options.configPath ?? DEFAULT_CONFIG_PATH);
-  const exists = await fileExists2(resolvedPath);
-  if (!exists) {
-    if (explicit) {
-      throw new ConfigError(
-        "config.not_found",
-        `Config not found at ${resolvedPath}`,
-        "Provide a valid path or remove --config."
-      );
-    }
-    return null;
-  }
-  let raw;
-  try {
-    raw = await fs2.readFile(resolvedPath, "utf8");
-  } catch (error) {
-    throw new ConfigError(
-      "config.read_failed",
-      `Failed to read config at ${resolvedPath}`,
-      "Check file permissions or re-create the config file."
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    throw new ConfigError(
-      "config.invalid_json",
-      "Config is not valid JSON",
-      "Check the JSON syntax or regenerate the file."
-    );
-  }
-  if (!isConfig(parsed)) {
-    throw new ConfigError(
-      "config.invalid_shape",
-      "Config must be a JSON object with optional boolean 'recommended'",
-      'Example: { "recommended": false }'
-    );
-  }
-  return parsed;
-};
-var resolveRecommended = (cliOverride, config) => cliOverride ?? config?.recommended ?? true;
-var isConfig = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const config = value;
-  if (config.recommended !== void 0 && typeof config.recommended !== "boolean") {
-    return false;
-  }
-  return true;
-};
-var fileExists2 = async (filePath) => {
-  try {
-    await fs2.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-// src/routes.ts
-import { promises as fs3 } from "fs";
-import path3 from "path";
-var scanRoutes = async (options) => {
-  const rootDir = options.rootDir;
-  const routes = /* @__PURE__ */ new Set();
-  if (options.includeApp !== false) {
-    const appDir = path3.join(rootDir, "app");
-    if (await dirExists(appDir)) {
-      const files = await walkDir(appDir);
-      for (const file of files) {
-        if (!isAppPageFile(file)) {
-          continue;
-        }
-        const route = toAppRoute(appDir, file);
-        if (route) {
-          routes.add(route);
-        }
-      }
-    }
-  }
-  if (options.includePages !== false) {
-    const pagesDir = path3.join(rootDir, "pages");
-    if (await dirExists(pagesDir)) {
-      const files = await walkDir(pagesDir);
-      for (const file of files) {
-        if (!isPagesFile(file)) {
-          continue;
-        }
-        const route = toPagesRoute(pagesDir, file);
-        if (route) {
-          routes.add(route);
-        }
-      }
-    }
-  }
-  return Array.from(routes).sort();
-};
-var isAppPageFile = (filePath) => /\/page\.(t|j)sx?$/.test(filePath) || /\/page\.mdx$/.test(filePath);
-var isPagesFile = (filePath) => /\.(t|j)sx?$/.test(filePath) || /\.mdx$/.test(filePath);
-var toAppRoute = (appDir, filePath) => {
-  const relative = path3.relative(appDir, filePath);
-  const segments = relative.split(path3.sep);
-  if (segments.length === 0) {
-    return null;
-  }
-  segments.pop();
-  const routeSegments = segments.filter((segment) => segment.length > 0).filter((segment) => !isGroupSegment(segment)).filter((segment) => !isParallelSegment(segment));
-  if (routeSegments.length === 0) {
-    return "/";
-  }
-  return `/${routeSegments.join("/")}`;
-};
-var toPagesRoute = (pagesDir, filePath) => {
-  const relative = path3.relative(pagesDir, filePath);
-  const segments = relative.split(path3.sep);
-  if (segments.length === 0) {
-    return null;
-  }
-  if (segments[0] === "api") {
-    return null;
-  }
-  const fileName = segments.pop();
-  if (!fileName) {
-    return null;
-  }
-  const baseName = fileName.replace(/\.[^/.]+$/, "");
-  if (baseName.startsWith("_")) {
-    return null;
-  }
-  const filtered = segments.filter((segment) => segment.length > 0);
-  if (baseName !== "index") {
-    filtered.push(baseName);
-  }
-  if (filtered.length === 0) {
-    return "/";
-  }
-  return `/${filtered.join("/")}`;
-};
-var isGroupSegment = (segment) => segment.startsWith("(") && segment.endsWith(")");
-var isParallelSegment = (segment) => segment.startsWith("@");
-var dirExists = async (dirPath) => {
-  try {
-    const stat = await fs3.stat(dirPath);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-};
-var walkDir = async (dirPath) => {
-  const entries = await fs3.readdir(dirPath, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const resolved = path3.join(dirPath, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...await walkDir(resolved));
-    } else if (entry.isFile()) {
-      files.push(resolved);
-    }
-  }
-  return files;
-};
+import { Command as Command6 } from "commander";
+
+// src/commands/validate.ts
+import { Command } from "commander";
+import { mkdir, readFile, writeFile, access } from "fs/promises";
+import path4 from "path";
+import chalk from "chalk";
+import { stableStringify as stableStringify4 } from "@schemasentry/core";
 
 // src/html.ts
 var escapeHtml = (value) => String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
@@ -654,15 +127,32 @@ var emitGitHubAnnotations = (report, commandLabel) => {
   }
 };
 
+// src/summary.ts
+var formatDuration = (durationMs) => {
+  if (!Number.isFinite(durationMs) || durationMs < 0) {
+    return "0ms";
+  }
+  if (durationMs < 1e3) {
+    return `${Math.round(durationMs)}ms`;
+  }
+  const seconds = durationMs / 1e3;
+  return `${seconds.toFixed(seconds < 10 ? 1 : 0)}s`;
+};
+
+// src/reality.ts
+import {
+  validateSchema
+} from "@schemasentry/core";
+
 // src/collect.ts
-import { promises as fs4 } from "fs";
-import path4 from "path";
-import { stableStringify as stableStringify2 } from "@schemasentry/core";
+import { promises as fs } from "fs";
+import path from "path";
+import { stableStringify } from "@schemasentry/core";
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules", ".pnpm-store"]);
 var SCRIPT_TAG_REGEX = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
 var JSON_LD_TYPE_REGEX = /\btype\s*=\s*(?:"application\/ld\+json"|'application\/ld\+json'|application\/ld\+json)/i;
 var collectSchemaData = async (options) => {
-  const rootDir = path4.resolve(options.rootDir);
+  const rootDir = path.resolve(options.rootDir);
   const requestedRoutes = normalizeRouteFilter(options.routes ?? []);
   const htmlFiles = (await walkHtmlFiles(rootDir)).sort((a, b) => a.localeCompare(b));
   const routes = {};
@@ -674,7 +164,7 @@ var collectSchemaData = async (options) => {
     if (!route) {
       continue;
     }
-    const html = await fs4.readFile(filePath, "utf8");
+    const html = await fs.readFile(filePath, "utf8");
     const extracted = extractSchemaNodes(html, filePath);
     if (extracted.nodes.length > 0) {
       routes[route] = [...routes[route] ?? [], ...extracted.nodes];
@@ -719,7 +209,7 @@ var compareSchemaData = (existing, collected) => {
   const addedRoutes = collectedKeys.filter((route) => !Object.prototype.hasOwnProperty.call(existingRoutes, route)).sort();
   const removedRoutes = existingKeys.filter((route) => !Object.prototype.hasOwnProperty.call(collectedRoutes, route)).sort();
   const changedRoutes = existingKeys.filter((route) => Object.prototype.hasOwnProperty.call(collectedRoutes, route)).filter(
-    (route) => stableStringify2(existingRoutes[route]) !== stableStringify2(collectedRoutes[route])
+    (route) => stableStringify(existingRoutes[route]) !== stableStringify(collectedRoutes[route])
   ).sort();
   const changedRouteDetails = changedRoutes.map(
     (route) => buildRouteDriftDetail(route, existingRoutes[route] ?? [], collectedRoutes[route] ?? [])
@@ -784,13 +274,13 @@ var normalizeRouteFilter = (input2) => {
   return Array.from(new Set(normalized)).sort();
 };
 var walkHtmlFiles = async (rootDir) => {
-  const entries = await fs4.readdir(rootDir, { withFileTypes: true });
+  const entries = await fs.readdir(rootDir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name)) {
       continue;
     }
-    const resolved = path4.join(rootDir, entry.name);
+    const resolved = path.join(rootDir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkHtmlFiles(resolved));
       continue;
@@ -802,7 +292,7 @@ var walkHtmlFiles = async (rootDir) => {
   return files;
 };
 var filePathToRoute = (rootDir, filePath) => {
-  const relative = path4.relative(rootDir, filePath).replace(/\\/g, "/");
+  const relative = path.relative(rootDir, filePath).replace(/\\/g, "/");
   if (relative === "index.html") {
     return "/";
   }
@@ -877,258 +367,432 @@ var schemaTypeLabel = (node) => {
   return typeof type === "string" && type.trim().length > 0 ? type : "(unknown)";
 };
 
-// src/scaffold.ts
-import { promises as fs5 } from "fs";
-import path5 from "path";
-import { stableStringify as stableStringify3 } from "@schemasentry/core";
+// src/source.ts
+import { promises as fs2 } from "fs";
+import path2 from "path";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".pnpm-store",
+  ".next",
+  "dist",
+  "build",
+  "out"
+]);
+var SCHEMA_IMPORT_PATTERN = /from\s+["']@schemasentry\/(?:next|core)["']/;
+var SCHEMA_COMPONENT_PATTERN = /<Schema\s/;
+var BUILDER_IMPORT_PATTERN = /import\s*\{([^}]+)\}\s*from\s*["']@schemasentry\/(?:next|core)["']/g;
+var BUILDER_NAME_PATTERN = /^(Organization|Person|Place|LocalBusiness|WebSite|WebPage|Article|BlogPosting|Product|VideoObject|ImageObject|Event|Review|FAQPage|HowTo|BreadcrumbList)$/;
+var scanSourceFiles = async (options) => {
+  const appDir = path2.resolve(options.rootDir, options.appDir ?? "app");
+  const pageFiles = await findPageFiles(appDir);
+  const routes = [];
+  for (const filePath of pageFiles) {
+    const route = filePathToRoute2(appDir, filePath);
+    if (!route) continue;
+    const content = await fs2.readFile(filePath, "utf8");
+    const info = analyzeSourceFile(filePath, route, content);
+    routes.push(info);
+  }
+  const filesWithSchema = routes.filter(
+    (r) => r.hasSchemaImport && r.hasSchemaUsage
+  ).length;
+  return {
+    routes,
+    totalFiles: routes.length,
+    filesWithSchema,
+    filesMissingSchema: routes.length - filesWithSchema
+  };
+};
+var findPageFiles = async (dir) => {
+  const files = [];
+  try {
+    const entries = await fs2.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!IGNORED_DIRS.has(entry.name)) {
+          files.push(...await findPageFiles(fullPath));
+        }
+      } else if (entry.isFile() && (entry.name === "page.tsx" || entry.name === "page.jsx" || entry.name === "page.ts" || entry.name === "page.js")) {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+};
+var filePathToRoute2 = (appDir, filePath) => {
+  const relative = path2.relative(appDir, filePath).replace(/\\/g, "/");
+  const withoutExt = relative.replace(/\/page\.(tsx|jsx|ts|js)$/, "");
+  if (withoutExt === "") {
+    return "/";
+  }
+  return `/${withoutExt}`;
+};
+var analyzeSourceFile = (filePath, route, content) => {
+  const hasSchemaImport = SCHEMA_IMPORT_PATTERN.test(content);
+  const hasSchemaUsage = SCHEMA_COMPONENT_PATTERN.test(content);
+  const importedBuilders = [];
+  const importMatch = BUILDER_IMPORT_PATTERN.exec(content);
+  if (importMatch && importMatch[1]) {
+    const imports = importMatch[1].split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    for (const imp of imports) {
+      const name = imp.split(/\s+as\s+/)[0].trim();
+      if (BUILDER_NAME_PATTERN.test(name)) {
+        importedBuilders.push(name);
+      }
+    }
+  }
+  return {
+    route,
+    filePath,
+    hasSchemaImport,
+    hasSchemaUsage,
+    importedBuilders
+  };
+};
 
-// src/patterns.ts
-var DEFAULT_PATTERNS = [
-  { pattern: "/blog/*", schemaType: "BlogPosting", priority: 10 },
-  { pattern: "/blog", schemaType: "WebPage", priority: 5 },
-  { pattern: "/products/*", schemaType: "Product", priority: 10 },
-  { pattern: "/product/*", schemaType: "Product", priority: 10 },
-  { pattern: "/faq", schemaType: "FAQPage", priority: 10 },
-  { pattern: "/faqs", schemaType: "FAQPage", priority: 10 },
-  { pattern: "/how-to/*", schemaType: "HowTo", priority: 10 },
-  { pattern: "/howto/*", schemaType: "HowTo", priority: 10 },
-  { pattern: "/events/*", schemaType: "Event", priority: 10 },
-  { pattern: "/event/*", schemaType: "Event", priority: 10 },
-  { pattern: "/reviews/*", schemaType: "Review", priority: 10 },
-  { pattern: "/review/*", schemaType: "Review", priority: 10 },
-  { pattern: "/videos/*", schemaType: "VideoObject", priority: 10 },
-  { pattern: "/video/*", schemaType: "VideoObject", priority: 10 },
-  { pattern: "/images/*", schemaType: "ImageObject", priority: 10 },
-  { pattern: "/image/*", schemaType: "ImageObject", priority: 10 },
-  { pattern: "/about", schemaType: "WebPage", priority: 10 },
-  { pattern: "/contact", schemaType: "WebPage", priority: 10 },
-  { pattern: "/", schemaType: "WebSite", priority: 1 }
-];
-var matchRouteToPatterns = (route, patterns = DEFAULT_PATTERNS) => {
-  const matches = [];
-  for (const rule of patterns) {
-    if (routeMatchesPattern(route, rule.pattern)) {
-      matches.push({
-        type: rule.schemaType,
-        priority: rule.priority ?? 5
+// src/reality.ts
+var performRealityCheck = async (options) => {
+  const sourceScan = await scanSourceFiles({ rootDir: options.sourceDir });
+  const collected = await collectSchemaData({ rootDir: options.builtOutputDir });
+  return buildRealityReport({
+    manifest: options.manifest,
+    sourceScan,
+    collected,
+    validationOptions: { recommended: options.recommended }
+  });
+};
+var buildRealityReport = (input2) => {
+  const { manifest, sourceScan, collected, validationOptions } = input2;
+  const manifestRoutes = manifest.routes ?? {};
+  const collectedRoutes = collected.data.routes ?? {};
+  const allRoutes = /* @__PURE__ */ new Set([
+    ...Object.keys(manifestRoutes),
+    ...sourceScan.routes.map((r) => r.route),
+    ...Object.keys(collectedRoutes)
+  ]);
+  const routeReports = [];
+  let validRoutes = 0;
+  let missingInHtml = 0;
+  let missingInSource = 0;
+  let missingFromManifest = 0;
+  let typeMismatches = 0;
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  for (const route of allRoutes) {
+    const sourceInfo = sourceScan.routes.find((r) => r.route === route);
+    const htmlNodes = collectedRoutes[route] ?? [];
+    const expectedTypes = manifestRoutes[route] ?? [];
+    const sourceHasComponent = sourceInfo?.hasSchemaImport && sourceInfo?.hasSchemaUsage;
+    const htmlHasSchema = htmlNodes.length > 0;
+    const validation = validateSchema(htmlNodes, validationOptions);
+    const foundTypes = htmlNodes.map((node) => node["@type"]).filter((type) => typeof type === "string");
+    let status;
+    const issues = [...validation.issues];
+    if (expectedTypes.length > 0 && !sourceHasComponent) {
+      status = "missing_in_source";
+      missingInSource++;
+      issues.push({
+        path: `routes["${route}"]`,
+        message: "Manifest expects schema but source file has no <Schema> component",
+        severity: "error",
+        ruleId: "reality.missing_source_component"
+      });
+    } else if (sourceHasComponent && !htmlHasSchema) {
+      status = "missing_in_html";
+      missingInHtml++;
+      issues.push({
+        path: `routes["${route}"]`,
+        message: "Source has <Schema> component but no JSON-LD found in built HTML. Did you build the app?",
+        severity: "error",
+        ruleId: "reality.missing_html_output"
+      });
+    } else if (htmlHasSchema && expectedTypes.length === 0) {
+      status = "missing_from_manifest";
+      missingFromManifest++;
+      issues.push({
+        path: `routes["${route}"]`,
+        message: `Route has schema in HTML but is not listed in manifest`,
+        severity: "warn",
+        ruleId: "reality.unlisted_route"
+      });
+    } else if (expectedTypes.length > 0 && htmlHasSchema && !expectedTypes.every((t) => foundTypes.includes(t))) {
+      status = "type_mismatch";
+      typeMismatches++;
+      const missingTypes = expectedTypes.filter((t) => !foundTypes.includes(t));
+      issues.push({
+        path: `routes["${route}"].types`,
+        message: `Missing expected schema types: ${missingTypes.join(", ")}`,
+        severity: "error",
+        ruleId: "reality.type_mismatch"
       });
+    } else if (htmlHasSchema) {
+      status = "valid";
+      validRoutes++;
+    } else {
+      status = "valid";
+      validRoutes++;
     }
+    const errorCount = issues.filter((i) => i.severity === "error").length;
+    const warnCount = issues.filter((i) => i.severity === "warn").length;
+    totalErrors += errorCount;
+    totalWarnings += warnCount;
+    const score = Math.max(0, 100 - errorCount * 10 - warnCount * 2);
+    routeReports.push({
+      route,
+      status,
+      sourceHasComponent: sourceHasComponent ?? false,
+      htmlHasSchema,
+      expectedTypes,
+      foundTypes,
+      issues,
+      score
+    });
   }
-  matches.sort((a, b) => b.priority - a.priority);
-  return [...new Set(matches.map((m) => m.type))];
+  routeReports.sort((a, b) => a.route.localeCompare(b.route));
+  const avgScore = routeReports.length === 0 ? 100 : Math.round(
+    routeReports.reduce((sum, r) => sum + r.score, 0) / routeReports.length
+  );
+  return {
+    ok: totalErrors === 0,
+    summary: {
+      routes: routeReports.length,
+      errors: totalErrors,
+      warnings: totalWarnings,
+      score: avgScore,
+      validRoutes,
+      missingInHtml,
+      missingInSource,
+      missingFromManifest,
+      typeMismatches
+    },
+    routes: routeReports
+  };
 };
-var routeMatchesPattern = (route, pattern) => {
-  if (pattern === route) {
-    return true;
-  }
-  if (pattern.endsWith("/*")) {
-    const prefix = pattern.slice(0, -1);
-    return route.startsWith(prefix);
+
+// src/commands/utils.ts
+import { readFileSync } from "fs";
+import { stableStringify as stableStringify3 } from "@schemasentry/core";
+
+// src/config.ts
+import { promises as fs3 } from "fs";
+import path3 from "path";
+var ConfigError = class extends Error {
+  constructor(code, message, suggestion) {
+    super(message);
+    this.code = code;
+    this.suggestion = suggestion;
   }
-  const patternRegex = pattern.replace(/\*/g, "[^/]+").replace(/\?/g, ".");
-  const regex = new RegExp(`^${patternRegex}$`);
-  return regex.test(route);
 };
-var inferSchemaTypes = (routes, customPatterns) => {
-  const patterns = customPatterns ?? DEFAULT_PATTERNS;
-  const result = /* @__PURE__ */ new Map();
-  for (const route of routes) {
-    const types = matchRouteToPatterns(route, patterns);
-    if (types.length > 0) {
-      result.set(route, types);
+var DEFAULT_CONFIG_PATH = "schema-sentry.config.json";
+var loadConfig = async (options) => {
+  const cwd = options.cwd ?? process.cwd();
+  const explicit = Boolean(options.configPath);
+  const resolvedPath = path3.resolve(cwd, options.configPath ?? DEFAULT_CONFIG_PATH);
+  const exists = await fileExists(resolvedPath);
+  if (!exists) {
+    if (explicit) {
+      throw new ConfigError(
+        "config.not_found",
+        `Config not found at ${resolvedPath}`,
+        "Provide a valid path or remove --config."
+      );
     }
+    return null;
+  }
+  let raw;
+  try {
+    raw = await fs3.readFile(resolvedPath, "utf8");
+  } catch (error) {
+    throw new ConfigError(
+      "config.read_failed",
+      `Failed to read config at ${resolvedPath}`,
+      "Check file permissions or re-create the config file."
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new ConfigError(
+      "config.invalid_json",
+      "Config is not valid JSON",
+      "Check the JSON syntax or regenerate the file."
+    );
   }
-  return result;
-};
-var generateManifestEntries = (routes, customPatterns) => {
-  const inferred = inferSchemaTypes(routes, customPatterns);
-  const entries = {};
-  for (const [route, types] of inferred) {
-    entries[route] = types;
+  if (!isConfig(parsed)) {
+    throw new ConfigError(
+      "config.invalid_shape",
+      "Config must be a JSON object with optional boolean 'recommended'",
+      'Example: { "recommended": false }'
+    );
   }
-  return entries;
+  return parsed;
 };
-
-// src/scaffold.ts
-var scaffoldSchema = async (options) => {
-  const manifest = await loadManifest(options.manifestPath);
-  const data = await loadData(options.dataPath);
-  const discoveredRoutes = await scanRoutes({ rootDir: options.rootDir });
-  const routesNeedingSchema = discoveredRoutes.filter(
-    (route) => !data.routes[route] || data.routes[route].length === 0
-  );
-  const inferredTypes = inferSchemaTypes(routesNeedingSchema, options.customPatterns);
-  const manifestEntries = generateManifestEntries(
-    routesNeedingSchema,
-    options.customPatterns
-  );
-  const generatedSchemas = /* @__PURE__ */ new Map();
-  for (const [route, types] of inferredTypes) {
-    const schemas = types.map((type) => generateSchemaStub(type, route));
-    generatedSchemas.set(route, schemas);
+var resolveRecommended = (cliOverride, config) => cliOverride ?? config?.recommended ?? true;
+var isConfig = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
   }
-  const wouldUpdate = routesNeedingSchema.length > 0;
-  return {
-    routesToScaffold: routesNeedingSchema,
-    generatedSchemas,
-    manifestUpdates: manifestEntries,
-    wouldUpdate
-  };
+  const config = value;
+  if (config.recommended !== void 0 && typeof config.recommended !== "boolean") {
+    return false;
+  }
+  return true;
 };
-var loadManifest = async (manifestPath) => {
+var fileExists = async (filePath) => {
   try {
-    const raw = await fs5.readFile(manifestPath, "utf8");
-    return JSON.parse(raw);
+    await fs3.access(filePath);
+    return true;
   } catch {
-    return { routes: {} };
+    return false;
   }
 };
-var loadData = async (dataPath) => {
+
+// src/commands/utils.ts
+function resolveCliVersion() {
   try {
-    const raw = await fs5.readFile(dataPath, "utf8");
-    return JSON.parse(raw);
+    const raw = readFileSync(new URL("../../package.json", import.meta.url), "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed.version ?? "0.0.0";
   } catch {
-    return { routes: {} };
-  }
-};
-var generateSchemaStub = (type, route) => {
-  const base = {
-    "@context": "https://schema.org",
-    "@type": type
-  };
-  switch (type) {
-    case "BlogPosting":
-      return {
-        ...base,
-        headline: "Blog Post Title",
-        author: {
-          "@type": "Person",
-          name: "Author Name"
-        },
-        datePublished: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
-        url: route
-      };
-    case "Product":
-      return {
-        ...base,
-        name: "Product Name",
-        description: "Product description",
-        offers: {
-          "@type": "Offer",
-          price: "0.00",
-          priceCurrency: "USD"
-        }
-      };
-    case "FAQPage":
-      return {
-        ...base,
-        mainEntity: []
-      };
-    case "HowTo":
-      return {
-        ...base,
-        name: "How-To Title",
-        step: []
-      };
-    case "Event":
-      return {
-        ...base,
-        name: "Event Name",
-        startDate: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    case "Organization":
-      return {
-        ...base,
-        name: "Organization Name",
-        url: route
-      };
-    case "WebSite":
-      return {
-        ...base,
-        name: "Website Name",
-        url: route
-      };
-    case "Article":
-      return {
-        ...base,
-        headline: "Article Headline",
-        author: {
-          "@type": "Person",
-          name: "Author Name"
-        },
-        datePublished: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
-      };
-    default:
-      return {
-        ...base,
-        name: `${type} Name`
-      };
+    return "0.0.0";
   }
-};
-var formatScaffoldPreview = (result) => {
-  if (result.routesToScaffold.length === 0) {
-    return "No routes need schema generation.";
+}
+function resolveOutputFormat(value) {
+  const format = (value ?? "json").trim().toLowerCase();
+  if (format === "json" || format === "html") {
+    return format;
   }
-  const lines = [
-    `Routes to scaffold: ${result.routesToScaffold.length}`,
-    ""
-  ];
-  for (const route of result.routesToScaffold) {
-    const types = result.manifestUpdates[route] || [];
-    lines.push(`  ${route}`);
-    lines.push(`    Schema types: ${types.join(", ") || "None detected"}`);
+  printCliError(
+    "output.invalid_format",
+    `Unsupported report format '${value ?? ""}'`,
+    "Use --format json or --format html."
+  );
+  process.exit(1);
+  return "json";
+}
+function resolveCollectOutputFormat(value) {
+  const format = (value ?? "json").trim().toLowerCase();
+  if (format === "json") {
+    return format;
   }
-  return lines.join("\n");
-};
-var applyScaffold = async (result, options) => {
-  if (!result.wouldUpdate) {
-    return;
+  printCliError(
+    "output.invalid_format",
+    `Unsupported collect output format '${value ?? ""}'`,
+    "Use --format json."
+  );
+  process.exit(1);
+  return "json";
+}
+function resolveAnnotationsMode(value) {
+  const mode = (value ?? "none").trim().toLowerCase();
+  if (mode === "none" || mode === "github") {
+    return mode;
   }
-  const manifest = await loadManifest(options.manifestPath);
-  const data = await loadData(options.dataPath);
-  for (const [route, types] of Object.entries(result.manifestUpdates)) {
-    if (!manifest.routes[route]) {
-      manifest.routes[route] = types;
+  printCliError(
+    "annotations.invalid_provider",
+    `Unsupported annotations provider '${value ?? ""}'`,
+    "Use --annotations none or --annotations github."
+  );
+  process.exit(1);
+  return "none";
+}
+async function resolveRecommendedOption(configPath) {
+  const override = getRecommendedOverride(process.argv);
+  try {
+    const config = await loadConfig({ configPath });
+    return resolveRecommended(override, config);
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      printCliError(error.code, error.message, error.suggestion);
+      process.exit(1);
+      return true;
     }
+    throw error;
   }
-  for (const [route, schemas] of result.generatedSchemas) {
-    if (!data.routes[route]) {
-      data.routes[route] = schemas;
-    }
+}
+function getRecommendedOverride(argv) {
+  if (argv.includes("--recommended")) {
+    return true;
   }
-  await fs5.mkdir(path5.dirname(options.manifestPath), { recursive: true });
-  await fs5.mkdir(path5.dirname(options.dataPath), { recursive: true });
-  await fs5.writeFile(
-    options.manifestPath,
-    stableStringify3(manifest),
-    "utf8"
+  if (argv.includes("--no-recommended")) {
+    return false;
+  }
+  return void 0;
+}
+function printCliError(code, message, suggestion) {
+  console.error(
+    stableStringify3({
+      ok: false,
+      errors: [
+        {
+          code,
+          message,
+          ...suggestion !== void 0 ? { suggestion } : {}
+        }
+      ]
+    })
   );
-  await fs5.writeFile(options.dataPath, stableStringify3(data), "utf8");
-};
+}
+function isManifest(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const manifest = value;
+  if (!manifest.routes || typeof manifest.routes !== "object") {
+    return false;
+  }
+  for (const entry of Object.values(manifest.routes)) {
+    if (!Array.isArray(entry) || entry.some((item) => typeof item !== "string")) {
+      return false;
+    }
+  }
+  return true;
+}
+function isSchemaData(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const data = value;
+  if (!data.routes || typeof data.routes !== "object") {
+    return false;
+  }
+  for (const entry of Object.values(data.routes)) {
+    if (!Array.isArray(entry)) {
+      return false;
+    }
+  }
+  return true;
+}
 
-// src/index.ts
-import { createInterface } from "readline/promises";
-import { stdin as input, stdout as output } from "process";
-var program = new Command();
-program.name("schemasentry").description("Schema Sentry CLI").version(resolveCliVersion());
-program.command("validate").description("Validate schema coverage and rules").option(
+// src/commands/validate.ts
+var validateCommand = new Command("validate").description("Validate schema by checking built HTML output against manifest (validates reality, not just config files)").option(
   "-m, --manifest <path>",
   "Path to manifest JSON",
   "schema-sentry.manifest.json"
 ).option(
-  "-d, --data <path>",
-  "Path to schema data JSON",
-  "schema-sentry.data.json"
+  "-r, --root <path>",
+  "Root directory containing built HTML output (e.g., ./out or ./.next/server/app)",
+  "./out"
+).option(
+  "--app-dir <path>",
+  "Path to Next.js app directory for source scanning",
+  "./app"
 ).option("-c, --config <path>", "Path to config JSON").option("--format <format>", "Report format (json|html)", "json").option("--annotations <provider>", "Emit CI annotations (none|github)", "none").option("-o, --output <path>", "Write report output to file").option("--recommended", "Enable recommended field checks").option("--no-recommended", "Disable recommended field checks").action(async (options) => {
   const start = Date.now();
   const format = resolveOutputFormat(options.format);
   const annotationsMode = resolveAnnotationsMode(options.annotations);
   const recommended = await resolveRecommendedOption(options.config);
-  const manifestPath = path6.resolve(process.cwd(), options.manifest);
-  const dataPath = path6.resolve(process.cwd(), options.data);
-  let raw;
+  const manifestPath = path4.resolve(process.cwd(), options.manifest);
+  const builtOutputDir = path4.resolve(process.cwd(), options.root);
+  const appDir = path4.resolve(process.cwd(), options.appDir ?? "./app");
+  let manifest;
   try {
-    raw = await readFile(manifestPath, "utf8");
+    const raw = await readFile(manifestPath, "utf8");
+    manifest = JSON.parse(raw);
   } catch (error) {
     printCliError(
       "manifest.not_found",
@@ -1138,72 +802,399 @@ program.command("validate").description("Validate schema coverage and rules").op
     process.exit(1);
     return;
   }
-  let manifest;
+  if (!isManifest(manifest)) {
+    printCliError(
+      "manifest.invalid_shape",
+      "Manifest must contain a 'routes' object with string array values",
+      "Ensure each route maps to an array of schema type names."
+    );
+    process.exit(1);
+    return;
+  }
+  console.error(chalk.blue.bold("\u{1F50D} Schema Sentry Reality Check"));
+  console.error(chalk.gray("Validating actual built HTML against manifest expectations...\n"));
   try {
-    manifest = JSON.parse(raw);
-  } catch (error) {
+    await access(builtOutputDir);
+  } catch {
     printCliError(
-      "manifest.invalid_json",
-      "Manifest is not valid JSON",
-      "Check the JSON syntax or regenerate with `schemasentry init`."
+      "validate.no_build_output",
+      `No built HTML output found at ${builtOutputDir}`,
+      "Build your Next.js app first with `next build`, then run validate."
     );
     process.exit(1);
     return;
   }
-  if (!isManifest(manifest)) {
+  let report;
+  try {
+    report = await performRealityCheck({
+      manifest,
+      builtOutputDir,
+      sourceDir: appDir,
+      recommended
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
     printCliError(
-      "manifest.invalid_shape",
-      "Manifest must contain a 'routes' object with string array values",
-      "Ensure each route maps to an array of schema type names."
+      "validate.check_failed",
+      `Failed to validate: ${message}`,
+      "Ensure your app is built and the --root points to the output directory."
     );
     process.exit(1);
     return;
   }
-  let dataRaw;
-  try {
-    dataRaw = await readFile(dataPath, "utf8");
-  } catch (error) {
-    printCliError(
-      "data.not_found",
-      `Schema data not found at ${dataPath}`,
-      "Run `schemasentry init` to generate starter files."
-    );
-    process.exit(1);
-    return;
+  if (format === "json") {
+    if (options.output) {
+      const outputPath = path4.resolve(process.cwd(), options.output);
+      await mkdir(path4.dirname(outputPath), { recursive: true });
+      await writeFile(outputPath, stableStringify4(report), "utf8");
+      console.error(chalk.green(`
+\u2713 Report written to ${outputPath}`));
+    } else {
+      console.log(stableStringify4(report));
+    }
+  } else {
+    if (options.output) {
+      const outputPath = path4.resolve(process.cwd(), options.output);
+      await mkdir(path4.dirname(outputPath), { recursive: true });
+      const legacyReport = convertRealityToLegacyReport(report);
+      await writeFile(outputPath, renderHtmlReport(legacyReport, { title: "Schema Sentry Validate Report" }), "utf8");
+      console.error(chalk.green(`
+\u2713 HTML report written to ${outputPath}`));
+    }
+  }
+  printRealitySummary(report, Date.now() - start);
+  if (annotationsMode === "github") {
+    const legacyReport = convertRealityToLegacyReport(report);
+    emitGitHubAnnotations(legacyReport, "validate");
+  }
+  process.exit(report.ok ? 0 : 1);
+});
+function printRealitySummary(report, durationMs) {
+  console.error("");
+  if (report.ok) {
+    console.error(chalk.green.bold("\u2705 All routes pass reality check"));
+  } else {
+    console.error(chalk.red.bold("\u274C Reality check failed"));
+  }
+  console.error(chalk.gray(`
+\u{1F4CA} Summary:`));
+  console.error(`   Routes checked: ${report.summary.routes}`);
+  console.error(`   Score: ${report.summary.score}/100`);
+  console.error(`   Duration: ${formatDuration(durationMs)}`);
+  if (report.summary.validRoutes > 0) {
+    console.error(chalk.green(`   \u2705 Valid: ${report.summary.validRoutes}`));
+  }
+  if (report.summary.missingInSource > 0) {
+    console.error(chalk.red(`   \u274C Missing in source: ${report.summary.missingInSource}`));
+  }
+  if (report.summary.missingInHtml > 0) {
+    console.error(chalk.red(`   \u274C Missing in HTML: ${report.summary.missingInHtml}`));
+  }
+  if (report.summary.missingFromManifest > 0) {
+    console.error(chalk.yellow(`   \u26A0\uFE0F  Missing from manifest: ${report.summary.missingFromManifest}`));
+  }
+  if (report.summary.typeMismatches > 0) {
+    console.error(chalk.red(`   \u274C Type mismatches: ${report.summary.typeMismatches}`));
+  }
+  if (report.summary.errors > 0 || report.summary.warnings > 0) {
+    console.error(chalk.gray(`
+\u{1F4DD} Details:`));
+    console.error(`   Errors: ${chalk.red(report.summary.errors.toString())}`);
+    console.error(`   Warnings: ${chalk.yellow(report.summary.warnings.toString())}`);
+  }
+  const problemRoutes = report.routes.filter((r) => r.issues.length > 0);
+  if (problemRoutes.length > 0) {
+    console.error(chalk.gray(`
+\u{1F50D} Problem routes:`));
+    for (const route of problemRoutes.slice(0, 5)) {
+      console.error(chalk.white(`
+   ${route.route}`));
+      for (const issue of route.issues) {
+        const icon = issue.severity === "error" ? chalk.red("\u274C") : chalk.yellow("\u26A0\uFE0F");
+        console.error(`     ${icon} ${issue.message}`);
+      }
+    }
+    if (problemRoutes.length > 5) {
+      console.error(chalk.gray(`
+   ... and ${problemRoutes.length - 5} more`));
+    }
+  }
+  console.error("");
+}
+function convertRealityToLegacyReport(report) {
+  return {
+    ok: report.ok,
+    summary: {
+      routes: report.summary.routes,
+      errors: report.summary.errors,
+      warnings: report.summary.warnings,
+      score: report.summary.score,
+      coverage: {
+        missingRoutes: report.summary.missingInSource + report.summary.missingInHtml,
+        missingTypes: report.summary.typeMismatches,
+        unlistedRoutes: report.summary.missingFromManifest
+      }
+    },
+    routes: report.routes.map((r) => ({
+      route: r.route,
+      ok: r.status === "valid" && r.issues.filter((i) => i.severity === "error").length === 0,
+      score: r.score,
+      issues: r.issues,
+      expectedTypes: r.expectedTypes,
+      foundTypes: r.foundTypes
+    }))
+  };
+}
+
+// src/commands/init.ts
+import { Command as Command2 } from "commander";
+import path7 from "path";
+
+// src/init.ts
+import { promises as fs4 } from "fs";
+import path5 from "path";
+import { SCHEMA_CONTEXT } from "@schemasentry/core";
+var DEFAULT_ANSWERS = {
+  siteName: "Acme Corp",
+  siteUrl: "https://acme.com",
+  authorName: "Jane Doe"
+};
+var getDefaultAnswers = () => ({ ...DEFAULT_ANSWERS });
+var buildManifest = (scannedRoutes = []) => {
+  const routes = {
+    "/": ["Organization", "WebSite"],
+    "/blog/[slug]": ["Article"]
+  };
+  for (const route of scannedRoutes) {
+    if (!routes[route]) {
+      routes[route] = ["WebPage"];
+    }
+  }
+  return { routes };
+};
+var formatDate = (value) => value.toISOString().slice(0, 10);
+var buildData = (answers, options = {}) => {
+  const { siteName, siteUrl, authorName } = answers;
+  const normalizedSiteUrl = normalizeUrl(siteUrl);
+  const today = options.today ?? /* @__PURE__ */ new Date();
+  const date = formatDate(today);
+  const logoUrl = new URL("/logo.png", normalizedSiteUrl).toString();
+  const articleUrl = new URL("/blog/hello-world", normalizedSiteUrl).toString();
+  const imageUrl = new URL("/blog/hello-world.png", normalizedSiteUrl).toString();
+  const routes = {
+    "/": [
+      {
+        "@context": SCHEMA_CONTEXT,
+        "@type": "Organization",
+        name: siteName,
+        url: normalizedSiteUrl,
+        logo: logoUrl,
+        description: `Official website of ${siteName}`
+      },
+      {
+        "@context": SCHEMA_CONTEXT,
+        "@type": "WebSite",
+        name: siteName,
+        url: normalizedSiteUrl,
+        description: `Learn more about ${siteName}`
+      }
+    ],
+    "/blog/[slug]": [
+      {
+        "@context": SCHEMA_CONTEXT,
+        "@type": "Article",
+        headline: "Hello World",
+        author: {
+          "@type": "Person",
+          name: authorName
+        },
+        datePublished: date,
+        dateModified: date,
+        description: `An introduction to ${siteName}`,
+        image: imageUrl,
+        url: articleUrl
+      }
+    ]
+  };
+  for (const route of options.scannedRoutes ?? []) {
+    if (routes[route]) {
+      continue;
+    }
+    routes[route] = [
+      {
+        "@context": SCHEMA_CONTEXT,
+        "@type": "WebPage",
+        name: routeToName(route),
+        url: new URL(route, normalizedSiteUrl).toString()
+      }
+    ];
+  }
+  return { routes };
+};
+var writeInitFiles = async (options) => {
+  const {
+    manifestPath,
+    dataPath,
+    overwriteManifest,
+    overwriteData,
+    answers,
+    today,
+    scannedRoutes
+  } = options;
+  const manifest = buildManifest(scannedRoutes ?? []);
+  const data = buildData(answers, { today, scannedRoutes });
+  const manifestResult = await writeJsonFile(
+    manifestPath,
+    manifest,
+    overwriteManifest
+  );
+  const dataResult = await writeJsonFile(dataPath, data, overwriteData);
+  return {
+    manifest: manifestResult,
+    data: dataResult
+  };
+};
+var writeJsonFile = async (filePath, payload, overwrite) => {
+  const exists = await fileExists2(filePath);
+  if (exists && !overwrite) {
+    return "skipped";
+  }
+  await fs4.mkdir(path5.dirname(filePath), { recursive: true });
+  const json = JSON.stringify(payload, null, 2);
+  await fs4.writeFile(filePath, `${json}
+`, "utf8");
+  return exists ? "overwritten" : "created";
+};
+var fileExists2 = async (filePath) => {
+  try {
+    await fs4.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var normalizeUrl = (value) => {
+  try {
+    return new URL(value).toString();
+  } catch {
+    return new URL(`https://${value}`).toString();
+  }
+};
+var routeToName = (route) => {
+  if (route === "/") {
+    return "Home";
+  }
+  const cleaned = route.replace(/\[|\]/g, "").split("/").filter(Boolean).join(" ");
+  return cleaned.split(/\s+/).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
+};
+
+// src/routes.ts
+import { promises as fs5 } from "fs";
+import path6 from "path";
+var scanRoutes = async (options) => {
+  const rootDir = options.rootDir;
+  const routes = /* @__PURE__ */ new Set();
+  if (options.includeApp !== false) {
+    const appDir = path6.join(rootDir, "app");
+    if (await dirExists(appDir)) {
+      const files = await walkDir(appDir);
+      for (const file of files) {
+        if (!isAppPageFile(file)) {
+          continue;
+        }
+        const route = toAppRoute(appDir, file);
+        if (route) {
+          routes.add(route);
+        }
+      }
+    }
+  }
+  if (options.includePages !== false) {
+    const pagesDir = path6.join(rootDir, "pages");
+    if (await dirExists(pagesDir)) {
+      const files = await walkDir(pagesDir);
+      for (const file of files) {
+        if (!isPagesFile(file)) {
+          continue;
+        }
+        const route = toPagesRoute(pagesDir, file);
+        if (route) {
+          routes.add(route);
+        }
+      }
+    }
+  }
+  return Array.from(routes).sort();
+};
+var isAppPageFile = (filePath) => /\/page\.(t|j)sx?$/.test(filePath) || /\/page\.mdx$/.test(filePath);
+var isPagesFile = (filePath) => /\.(t|j)sx?$/.test(filePath) || /\.mdx$/.test(filePath);
+var toAppRoute = (appDir, filePath) => {
+  const relative = path6.relative(appDir, filePath);
+  const segments = relative.split(path6.sep);
+  if (segments.length === 0) {
+    return null;
+  }
+  segments.pop();
+  const routeSegments = segments.filter((segment) => segment.length > 0).filter((segment) => !isGroupSegment(segment)).filter((segment) => !isParallelSegment(segment));
+  if (routeSegments.length === 0) {
+    return "/";
+  }
+  return `/${routeSegments.join("/")}`;
+};
+var toPagesRoute = (pagesDir, filePath) => {
+  const relative = path6.relative(pagesDir, filePath);
+  const segments = relative.split(path6.sep);
+  if (segments.length === 0) {
+    return null;
+  }
+  if (segments[0] === "api") {
+    return null;
+  }
+  const fileName = segments.pop();
+  if (!fileName) {
+    return null;
+  }
+  const baseName = fileName.replace(/\.[^/.]+$/, "");
+  if (baseName.startsWith("_")) {
+    return null;
+  }
+  const filtered = segments.filter((segment) => segment.length > 0);
+  if (baseName !== "index") {
+    filtered.push(baseName);
+  }
+  if (filtered.length === 0) {
+    return "/";
   }
-  let data;
+  return `/${filtered.join("/")}`;
+};
+var isGroupSegment = (segment) => segment.startsWith("(") && segment.endsWith(")");
+var isParallelSegment = (segment) => segment.startsWith("@");
+var dirExists = async (dirPath) => {
   try {
-    data = JSON.parse(dataRaw);
-  } catch (error) {
-    printCliError(
-      "data.invalid_json",
-      "Schema data is not valid JSON",
-      "Check the JSON syntax or regenerate with `schemasentry init`."
-    );
-    process.exit(1);
-    return;
+    const stat = await fs5.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
   }
-  if (!isSchemaData(data)) {
-    printCliError(
-      "data.invalid_shape",
-      "Schema data must contain a 'routes' object with array values",
-      "Ensure each route maps to an array of JSON-LD blocks."
-    );
-    process.exit(1);
-    return;
+};
+var walkDir = async (dirPath) => {
+  const entries = await fs5.readdir(dirPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const resolved = path6.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkDir(resolved));
+    } else if (entry.isFile()) {
+      files.push(resolved);
+    }
   }
-  const report = buildReport(manifest, data, { recommended });
-  await emitReport({
-    report,
-    format,
-    outputPath: options.output,
-    title: "Schema Sentry Validate Report"
-  });
-  emitAnnotations(report, annotationsMode, "validate");
-  printValidateSummary(report, Date.now() - start);
-  process.exit(report.ok ? 0 : 1);
-});
-program.command("init").description("Interactive setup wizard").option(
+  return files;
+};
+
+// src/commands/init.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+var initCommand = new Command2("init").description("Interactive setup wizard").option(
   "-m, --manifest <path>",
   "Path to manifest JSON",
   "schema-sentry.manifest.json"
@@ -1212,12 +1203,12 @@ program.command("init").description("Interactive setup wizard").option(
   "Path to schema data JSON",
   "schema-sentry.data.json"
 ).option("-y, --yes", "Use defaults and skip prompts").option("-f, --force", "Overwrite existing files").option("--scan", "Scan the filesystem for routes and add WebPage entries").option("--root <path>", "Project root for scanning", ".").action(async (options) => {
-  const manifestPath = path6.resolve(process.cwd(), options.manifest);
-  const dataPath = path6.resolve(process.cwd(), options.data);
+  const manifestPath = path7.resolve(process.cwd(), options.manifest);
+  const dataPath = path7.resolve(process.cwd(), options.data);
   const force = options.force ?? false;
   const useDefaults = options.yes ?? false;
   const answers = useDefaults ? getDefaultAnswers() : await promptAnswers();
-  const scannedRoutes = options.scan ? await scanRoutes({ rootDir: path6.resolve(process.cwd(), options.root ?? ".") }) : [];
+  const scannedRoutes = options.scan ? await scanRoutes({ rootDir: path7.resolve(process.cwd(), options.root ?? ".") }) : [];
   if (options.scan && scannedRoutes.length === 0) {
     console.error("No routes found during scan.");
   }
@@ -1237,457 +1228,484 @@ program.command("init").description("Interactive setup wizard").option(
   });
   printInitSummary({ manifestPath, dataPath, result });
 });
-program.command("audit").description("Analyze schema health and report issues").option(
-  "-d, --data <path>",
-  "Path to schema data JSON",
-  "schema-sentry.data.json"
-).option("-m, --manifest <path>", "Path to manifest JSON (optional)").option("--scan", "Scan the filesystem for routes").option("--root <path>", "Project root for scanning", ".").option("-c, --config <path>", "Path to config JSON").option("--format <format>", "Report format (json|html)", "json").option("--annotations <provider>", "Emit CI annotations (none|github)", "none").option("-o, --output <path>", "Write report output to file").option("--recommended", "Enable recommended field checks").option("--no-recommended", "Disable recommended field checks").action(async (options) => {
-  const start = Date.now();
-  const format = resolveOutputFormat(options.format);
-  const annotationsMode = resolveAnnotationsMode(options.annotations);
-  const recommended = await resolveRecommendedOption(options.config);
-  const dataPath = path6.resolve(process.cwd(), options.data);
-  let dataRaw;
+async function promptAnswers() {
+  const defaults = getDefaultAnswers();
+  const rl = createInterface({ input, output });
   try {
-    dataRaw = await readFile(dataPath, "utf8");
-  } catch (error) {
-    printCliError(
-      "data.not_found",
-      `Schema data not found at ${dataPath}`,
-      "Run `schemasentry init` to generate starter files."
-    );
-    process.exit(1);
-    return;
+    const siteName = await ask(rl, "Site name", defaults.siteName);
+    const siteUrl = await ask(rl, "Base URL", defaults.siteUrl);
+    const authorName = await ask(rl, "Primary author name", defaults.authorName);
+    return { siteName, siteUrl, authorName };
+  } finally {
+    rl.close();
   }
-  let data;
+}
+async function ask(rl, question, fallback) {
+  const answer = (await rl.question(`${question} (${fallback}): `)).trim();
+  return answer.length > 0 ? answer : fallback;
+}
+async function resolveOverwrites(options) {
+  const { manifestPath, dataPath, force, interactive } = options;
+  if (force) {
+    return [true, true];
+  }
+  const manifestExists = await fileExists2(manifestPath);
+  const dataExists = await fileExists2(dataPath);
+  if (!interactive) {
+    return [false, false];
+  }
+  const rl = createInterface({ input, output });
   try {
-    data = JSON.parse(dataRaw);
-  } catch (error) {
-    printCliError(
-      "data.invalid_json",
-      "Schema data is not valid JSON",
-      "Check the JSON syntax or regenerate with `schemasentry init`."
-    );
-    process.exit(1);
-    return;
+    const overwriteManifest = manifestExists ? await confirm(rl, `Manifest exists at ${manifestPath}. Overwrite?`, false) : false;
+    const overwriteData = dataExists ? await confirm(rl, `Data file exists at ${dataPath}. Overwrite?`, false) : false;
+    return [overwriteManifest, overwriteData];
+  } finally {
+    rl.close();
   }
-  if (!isSchemaData(data)) {
-    printCliError(
-      "data.invalid_shape",
-      "Schema data must contain a 'routes' object with array values",
-      "Ensure each route maps to an array of JSON-LD blocks."
-    );
-    process.exit(1);
-    return;
+}
+async function confirm(rl, question, defaultValue) {
+  const hint = defaultValue ? "Y/n" : "y/N";
+  const answer = (await rl.question(`${question} (${hint}): `)).trim().toLowerCase();
+  if (!answer) {
+    return defaultValue;
   }
-  let manifest;
-  if (options.manifest) {
-    const manifestPath = path6.resolve(process.cwd(), options.manifest);
-    let manifestRaw;
-    try {
-      manifestRaw = await readFile(manifestPath, "utf8");
-    } catch (error) {
-      printCliError(
-        "manifest.not_found",
-        `Manifest not found at ${manifestPath}`,
-        "Run `schemasentry init` to generate starter files."
-      );
-      process.exit(1);
-      return;
-    }
-    try {
-      manifest = JSON.parse(manifestRaw);
-    } catch (error) {
-      printCliError(
-        "manifest.invalid_json",
-        "Manifest is not valid JSON",
-        "Check the JSON syntax or regenerate with `schemasentry init`."
-      );
-      process.exit(1);
-      return;
-    }
-    if (!isManifest(manifest)) {
-      printCliError(
-        "manifest.invalid_shape",
-        "Manifest must contain a 'routes' object with string array values",
-        "Ensure each route maps to an array of schema type names."
-      );
-      process.exit(1);
-      return;
-    }
+  return answer === "y" || answer === "yes";
+}
+function printInitSummary(options) {
+  const { manifestPath, dataPath, result } = options;
+  const created = [];
+  if (result.manifest !== "skipped") {
+    created.push(`${manifestPath} (${result.manifest})`);
   }
-  const requiredRoutes = options.scan ? await scanRoutes({ rootDir: path6.resolve(process.cwd(), options.root ?? ".") }) : [];
-  if (options.scan && requiredRoutes.length === 0) {
-    console.error("No routes found during scan.");
+  if (result.data !== "skipped") {
+    created.push(`${dataPath} (${result.data})`);
   }
-  const report = buildAuditReport(data, {
-    recommended,
-    manifest,
-    requiredRoutes: requiredRoutes.length > 0 ? requiredRoutes : void 0
-  });
-  await emitReport({
-    report,
-    format,
-    outputPath: options.output,
-    title: "Schema Sentry Audit Report"
-  });
-  emitAnnotations(report, annotationsMode, "audit");
-  printAuditSummary(report, Boolean(manifest), Date.now() - start);
-  process.exit(report.ok ? 0 : 1);
-});
-program.command("collect").description("Collect JSON-LD blocks from built HTML output").option("--root <path>", "Root directory to scan for HTML files", ".").option("--routes <routes...>", "Only collect specific routes (repeat or comma-separated)").option("--strict-routes", "Fail when any route passed via --routes is missing").option("--format <format>", "Output format (json)", "json").option("-o, --output <path>", "Write collected schema data to file").option("--check", "Compare collected output with an existing schema data file").option(
-  "-d, --data <path>",
-  "Path to existing schema data JSON for --check",
-  "schema-sentry.data.json"
-).action(async (options) => {
-  const start = Date.now();
-  const format = resolveCollectOutputFormat(options.format);
-  const rootDir = path6.resolve(process.cwd(), options.root ?? ".");
-  const check = options.check ?? false;
-  const requestedRoutes = normalizeRouteFilter(options.routes ?? []);
-  const strictRoutes = options.strictRoutes ?? false;
-  let collected;
-  try {
-    collected = await collectSchemaData({ rootDir, routes: requestedRoutes });
-  } catch (error) {
-    const reason = error instanceof Error && error.message.length > 0 ? error.message : "Unknown file system error";
-    printCliError(
-      "collect.scan_failed",
-      `Could not scan HTML output at ${rootDir}: ${reason}`,
-      "Point --root to a directory containing built HTML output."
-    );
-    process.exit(1);
-    return;
+  if (created.length > 0) {
+    console.log("Schema Sentry init complete.");
+    console.log(`Created ${created.length} file(s):`);
+    created.forEach((entry) => console.log(`- ${entry}`));
   }
-  if (collected.stats.htmlFiles === 0) {
-    printCliError(
-      "collect.no_html",
-      `No HTML files found under ${rootDir}`,
-      "Point --root to a static output directory (for example ./out)."
-    );
-    process.exit(1);
-    return;
+  if (result.manifest === "skipped" || result.data === "skipped") {
+    console.log("Some files were skipped. Use --force to overwrite.");
   }
-  if (strictRoutes && collected.missingRoutes.length > 0) {
-    printCliError(
-      "collect.missing_required_routes",
-      `Required routes were not found in collected HTML: ${collected.missingRoutes.join(", ")}`,
-      "Rebuild output, adjust --root, or update --routes."
-    );
-    process.exit(1);
-    return;
+  if (result.manifest === "skipped" && result.data === "skipped") {
+    console.log("No files were written.");
   }
-  let driftDetected = false;
-  if (check) {
-    const existingPath = path6.resolve(process.cwd(), options.data);
-    let existingRaw;
-    try {
-      existingRaw = await readFile(existingPath, "utf8");
-    } catch (error) {
-      printCliError(
-        "data.not_found",
-        `Schema data not found at ${existingPath}`,
-        "Run `schemasentry collect --output ./schema-sentry.data.json` to generate it."
-      );
-      process.exit(1);
-      return;
-    }
-    let existingData;
-    try {
-      existingData = JSON.parse(existingRaw);
-    } catch (error) {
-      printCliError(
-        "data.invalid_json",
-        "Schema data is not valid JSON",
-        "Check the JSON syntax or regenerate with `schemasentry collect --output`."
-      );
-      process.exit(1);
-      return;
+  if (created.length > 0) {
+    console.log("Next: run `schemasentry validate` to verify your setup.");
+  }
+}
+
+// src/commands/audit.ts
+import { Command as Command3 } from "commander";
+import { readFile as readFile2 } from "fs/promises";
+import { promises as fs6 } from "fs";
+import path8 from "path";
+import chalk2 from "chalk";
+
+// src/audit.ts
+import {
+  validateSchema as validateSchema2
+} from "@schemasentry/core";
+
+// src/coverage.ts
+var buildCoverageResult = (input2, data) => {
+  const manifestRoutes = input2.expectedTypesByRoute ?? {};
+  const dataRoutes = data.routes ?? {};
+  const derivedRequiredRoutes = Object.entries(manifestRoutes).filter(([, types]) => (types ?? []).length > 0).map(([route]) => route);
+  const requiredRoutes = /* @__PURE__ */ new Set([
+    ...input2.requiredRoutes ?? [],
+    ...derivedRequiredRoutes
+  ]);
+  const allRoutes = Array.from(
+    /* @__PURE__ */ new Set([
+      ...Object.keys(manifestRoutes),
+      ...requiredRoutes,
+      ...Object.keys(dataRoutes)
+    ])
+  ).sort();
+  const issuesByRoute = {};
+  const summary = {
+    missingRoutes: 0,
+    missingTypes: 0,
+    unlistedRoutes: 0
+  };
+  for (const route of allRoutes) {
+    const issues = [];
+    const expectedTypes = manifestRoutes[route] ?? [];
+    const nodes = dataRoutes[route] ?? [];
+    const foundTypes = nodes.map((node) => node["@type"]).filter((type) => typeof type === "string");
+    if (requiredRoutes.has(route) && nodes.length === 0) {
+      issues.push({
+        path: `routes["${route}"]`,
+        message: "No schema blocks found for route",
+        severity: "error",
+        ruleId: "coverage.missing_route"
+      });
+      summary.missingRoutes += 1;
     }
-    if (!isSchemaData(existingData)) {
-      printCliError(
-        "data.invalid_shape",
-        "Schema data must contain a 'routes' object with array values",
-        "Ensure each route maps to an array of JSON-LD blocks."
-      );
-      process.exit(1);
-      return;
+    for (const expectedType of expectedTypes) {
+      if (!foundTypes.includes(expectedType)) {
+        issues.push({
+          path: `routes["${route}"].types`,
+          message: `Missing expected schema type '${expectedType}'`,
+          severity: "error",
+          ruleId: "coverage.missing_type"
+        });
+        summary.missingTypes += 1;
+      }
     }
-    const existingDataForCompare = requestedRoutes.length > 0 ? filterSchemaDataByRoutes(existingData, requestedRoutes) : existingData;
-    const drift = compareSchemaData(existingDataForCompare, collected.data);
-    driftDetected = drift.hasChanges;
-    if (driftDetected) {
-      console.error(formatSchemaDataDrift(drift));
-    } else {
-      console.error("collect | No schema data drift detected.");
+    if (!manifestRoutes[route] && !requiredRoutes.has(route) && nodes.length > 0) {
+      issues.push({
+        path: `routes["${route}"]`,
+        message: "Route has schema but is missing from manifest",
+        severity: "warn",
+        ruleId: "coverage.unlisted_route"
+      });
+      summary.unlistedRoutes += 1;
     }
-  }
-  const content = formatCollectOutput(collected.data, format);
-  if (options.output) {
-    const resolvedPath = path6.resolve(process.cwd(), options.output);
-    try {
-      await mkdir(path6.dirname(resolvedPath), { recursive: true });
-      await writeFile(resolvedPath, `${content}
-`, "utf8");
-      console.error(`Collected data written to ${resolvedPath}`);
-    } catch (error) {
-      const reason = error instanceof Error && error.message.length > 0 ? error.message : "Unknown file system error";
-      printCliError(
-        "output.write_failed",
-        `Could not write collected data to ${resolvedPath}: ${reason}`
-      );
-      process.exit(1);
-      return;
+    if (issues.length > 0) {
+      issuesByRoute[route] = issues;
     }
-  } else if (!check) {
-    console.log(content);
   }
-  printCollectWarnings(collected.warnings);
-  printCollectSummary({
-    stats: collected.stats,
-    durationMs: Date.now() - start,
-    checked: check,
-    driftDetected,
-    requestedRoutes: collected.requestedRoutes,
-    missingRoutes: collected.missingRoutes,
-    strictRoutes
+  return {
+    allRoutes,
+    issuesByRoute,
+    summary
+  };
+};
+
+// src/audit.ts
+var buildAuditReport = (data, options = {}) => {
+  const dataRoutes = data.routes ?? {};
+  const manifestRoutes = options.manifest?.routes ?? {};
+  const coverageEnabled = Boolean(options.manifest || options.requiredRoutes?.length);
+  const coverage = coverageEnabled ? buildCoverageResult(
+    {
+      expectedTypesByRoute: manifestRoutes,
+      requiredRoutes: options.requiredRoutes
+    },
+    data
+  ) : null;
+  const allRoutes = coverageEnabled ? coverage?.allRoutes ?? [] : Object.keys(dataRoutes).sort();
+  const routes = allRoutes.map((route) => {
+    const expectedTypes = coverageEnabled ? manifestRoutes[route] ?? [] : [];
+    const nodes = dataRoutes[route] ?? [];
+    const foundTypes = nodes.map((node) => node["@type"]).filter((type) => typeof type === "string");
+    const validation = validateSchema2(nodes, options);
+    const issues = [
+      ...validation.issues,
+      ...coverage?.issuesByRoute[route] ?? []
+    ];
+    const errorCount = issues.filter((issue) => issue.severity === "error").length;
+    const warnCount = issues.filter((issue) => issue.severity === "warn").length;
+    const score = Math.max(0, validation.score - errorCount * 5 - warnCount * 2);
+    return {
+      route,
+      ok: errorCount === 0,
+      score,
+      issues,
+      expectedTypes,
+      foundTypes
+    };
   });
-  process.exit(driftDetected ? 1 : 0);
-});
-program.command("scaffold").description("Generate schema stubs for routes without schema (dry-run by default)").option(
-  "-m, --manifest <path>",
-  "Path to manifest JSON",
-  "schema-sentry.manifest.json"
-).option(
+  const summaryErrors = routes.reduce(
+    (count, route) => count + route.issues.filter((i) => i.severity === "error").length,
+    0
+  );
+  const summaryWarnings = routes.reduce(
+    (count, route) => count + route.issues.filter((i) => i.severity === "warn").length,
+    0
+  );
+  const summaryScore = routes.length === 0 ? 0 : Math.round(
+    routes.reduce((total, route) => total + route.score, 0) / routes.length
+  );
+  return {
+    ok: summaryErrors === 0,
+    summary: {
+      routes: routes.length,
+      errors: summaryErrors,
+      warnings: summaryWarnings,
+      score: summaryScore,
+      ...coverageEnabled ? { coverage: coverage?.summary } : {}
+    },
+    routes
+  };
+};
+
+// src/commands/audit.ts
+var auditCommand = new Command3("audit").description("Analyze schema health and check for ghost routes (routes in manifest without Schema components)").option(
   "-d, --data <path>",
-  "Path to schema data JSON",
+  "Path to schema data JSON (optional, for legacy mode)",
   "schema-sentry.data.json"
-).option("--root <path>", "Project root for scanning", ".").option("--write", "Apply changes (default is dry-run)").option("-f, --force", "Skip confirmation prompts").action(async (options) => {
+).option("-m, --manifest <path>", "Path to manifest JSON (optional)", "schema-sentry.manifest.json").option("--scan", "Scan the filesystem for routes").option("--root <path>", "Project root for scanning", ".").option("--app-dir <path>", "Path to Next.js app directory for source scanning", "./app").option("--source-scan", "Enable source file scanning for ghost route detection", true).option("-c, --config <path>", "Path to config JSON").option("--format <format>", "Report format (json|html)", "json").option("--annotations <provider>", "Emit CI annotations (none|github)", "none").option("-o, --output <path>", "Write report output to file").option("--recommended", "Enable recommended field checks").option("--no-recommended", "Disable recommended field checks").action(async (options) => {
   const start = Date.now();
-  const manifestPath = path6.resolve(process.cwd(), options.manifest);
-  const dataPath = path6.resolve(process.cwd(), options.data);
-  const rootDir = path6.resolve(process.cwd(), options.root ?? ".");
-  const dryRun = !(options.write ?? false);
-  const force = options.force ?? false;
-  const result = await scaffoldSchema({
-    manifestPath,
-    dataPath,
-    rootDir,
-    dryRun,
-    force
-  });
-  console.error(formatScaffoldPreview(result));
-  if (!result.wouldUpdate) {
-    process.exit(0);
-    return;
-  }
-  if (dryRun) {
-    console.error("\nDry run complete. Use --write to apply changes.");
-    process.exit(0);
-    return;
-  }
-  if (!force) {
-    console.error("\nScaffolding will update:");
-    console.error(`  - ${manifestPath}`);
-    console.error(`  - ${dataPath}`);
-    console.error("\nUse --force to skip this confirmation.");
+  const skipSourceScan = process.env.SKIP_SOURCE_SCAN === "1";
+  const sourceScanEnabled = skipSourceScan ? false : options.sourceScan ?? true;
+  const format = resolveOutputFormat(options.format);
+  const annotationsMode = resolveAnnotationsMode(options.annotations);
+  const recommended = await resolveRecommendedOption(options.config);
+  const appDir = path8.resolve(process.cwd(), options.appDir ?? "./app");
+  console.error(chalk2.blue.bold("\u{1F50D} Schema Sentry Audit"));
+  console.error(chalk2.gray("Analyzing schema health and checking for ghost routes...\n"));
+  let manifest;
+  const manifestPath = options.manifest ? path8.resolve(process.cwd(), options.manifest) : void 0;
+  if (manifestPath) {
+    try {
+      const manifestRaw = await readFile2(manifestPath, "utf8");
+      manifest = JSON.parse(manifestRaw);
+      if (!isManifest(manifest)) {
+        printCliError(
+          "manifest.invalid_shape",
+          "Manifest must contain a 'routes' object with string array values",
+          "Ensure each route maps to an array of schema type names."
+        );
+        process.exit(1);
+        return;
+      }
+    } catch {
+      manifest = void 0;
+    }
   }
+  let data;
+  const dataPath = path8.resolve(process.cwd(), options.data);
   try {
-    await applyScaffold(result, {
-      manifestPath,
-      dataPath,
-      rootDir,
-      dryRun,
-      force
-    });
-    console.error(`
-Scaffold complete in ${Date.now() - start}ms`);
-    process.exit(0);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    printCliError(
-      "scaffold.apply_failed",
-      `Failed to apply scaffold: ${message}`,
-      "Check file permissions or disk space."
-    );
-    process.exit(1);
-  }
-});
-function isManifest(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const manifest = value;
-  if (!manifest.routes || typeof manifest.routes !== "object") {
-    return false;
-  }
-  for (const entry of Object.values(manifest.routes)) {
-    if (!Array.isArray(entry) || entry.some((item) => typeof item !== "string")) {
-      return false;
+    const dataRaw = await readFile2(dataPath, "utf8");
+    data = JSON.parse(dataRaw);
+    if (!isSchemaData(data)) {
+      data = void 0;
     }
-  }
-  return true;
-}
-function isSchemaData(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const data = value;
-  if (!data.routes || typeof data.routes !== "object") {
-    return false;
-  }
-  for (const entry of Object.values(data.routes)) {
-    if (!Array.isArray(entry)) {
-      return false;
+  } catch {
+    data = void 0;
+  }
+  const sourceScanResult = !sourceScanEnabled ? { routes: [], totalFiles: 0, filesWithSchema: 0, filesMissingSchema: 0 } : await scanSourceFiles({ rootDir: options.root ?? ".", appDir });
+  const scannedRoutes = options.scan ? await scanRoutes({ rootDir: path8.resolve(process.cwd(), options.root ?? ".") }) : [];
+  const ghostRoutes = [];
+  if (manifest && sourceScanEnabled) {
+    for (const route of Object.keys(manifest.routes)) {
+      const sourceInfo = sourceScanResult.routes.find((r) => r.route === route);
+      if (!sourceInfo?.hasSchemaUsage) {
+        ghostRoutes.push(route);
+      }
     }
   }
-  return true;
-}
-function resolveOutputFormat(value) {
-  const format = (value ?? "json").trim().toLowerCase();
-  if (format === "json" || format === "html") {
-    return format;
+  const report = buildAuditReport(data ?? { routes: {} }, {
+    recommended,
+    manifest,
+    requiredRoutes: scannedRoutes.length > 0 ? scannedRoutes : void 0
+  });
+  if (format === "json") {
+    if (options.output) {
+      const outputPath = path8.resolve(process.cwd(), options.output);
+      console.log(JSON.stringify(report, null, 2));
+    } else {
+      console.log(JSON.stringify(report, null, 2));
+    }
+  } else {
+    if (options.output) {
+      const outputPath = path8.resolve(process.cwd(), options.output);
+      const html = renderHtmlReport(report, { title: "Schema Sentry Audit Report" });
+      await fs6.writeFile(outputPath, html, "utf8");
+      console.error(chalk2.green(`
+\u2713 HTML report written to ${outputPath}`));
+    }
   }
-  printCliError(
-    "output.invalid_format",
-    `Unsupported report format '${value ?? ""}'`,
-    "Use --format json or --format html."
-  );
-  process.exit(1);
-  return "json";
-}
-function resolveAnnotationsMode(value) {
-  const mode = (value ?? "none").trim().toLowerCase();
-  if (mode === "none" || mode === "github") {
-    return mode;
+  if (annotationsMode === "github") {
+    emitGitHubAnnotations(report, "audit");
   }
-  printCliError(
-    "annotations.invalid_provider",
-    `Unsupported annotations provider '${value ?? ""}'`,
-    "Use --annotations none or --annotations github."
-  );
-  process.exit(1);
-  return "none";
-}
-function resolveCollectOutputFormat(value) {
-  const format = (value ?? "json").trim().toLowerCase();
-  if (format === "json") {
-    return format;
+  printEnhancedAuditSummary({
+    report,
+    hasManifest: Boolean(manifest),
+    ghostRoutes,
+    sourceScan: sourceScanResult,
+    durationMs: Date.now() - start
+  });
+  process.exit(report.ok && ghostRoutes.length === 0 ? 0 : 1);
+});
+function printEnhancedAuditSummary(options) {
+  const { report, hasManifest, ghostRoutes, sourceScan, durationMs } = options;
+  console.error("");
+  if (report.ok && ghostRoutes.length === 0) {
+    console.error(chalk2.green.bold("\u2705 Audit passed"));
+  } else {
+    console.error(chalk2.red.bold("\u274C Audit found issues"));
+  }
+  console.error(chalk2.gray(`
+\u{1F4CA} Summary:`));
+  console.error(`   Routes analyzed: ${report.summary.routes}`);
+  console.error(`   Score: ${report.summary.score}/100`);
+  console.error(`   Duration: ${formatDuration(durationMs)}`);
+  if (sourceScan.totalFiles > 0) {
+    console.error(chalk2.gray(`
+\u{1F4C1} Source Code Analysis:`));
+    console.error(`   Page files found: ${sourceScan.totalFiles}`);
+    console.error(chalk2.green(`   \u2705 With Schema components: ${sourceScan.filesWithSchema}`));
+    if (sourceScan.filesMissingSchema > 0) {
+      console.error(chalk2.red(`   \u274C Missing Schema: ${sourceScan.filesMissingSchema}`));
+    }
   }
-  printCliError(
-    "output.invalid_format",
-    `Unsupported collect output format '${value ?? ""}'`,
-    "Use --format json."
-  );
-  process.exit(1);
-  return "json";
-}
-function formatReportOutput(report, format, title) {
-  if (format === "html") {
-    return renderHtmlReport(report, { title });
+  if (hasManifest && ghostRoutes.length > 0) {
+    console.error(chalk2.red(`
+\u{1F47B} Ghost Routes (${ghostRoutes.length}):`));
+    console.error(chalk2.gray("   Routes in manifest but no <Schema> component in source:"));
+    for (const route of ghostRoutes.slice(0, 5)) {
+      console.error(chalk2.red(`   \u274C ${route}`));
+    }
+    if (ghostRoutes.length > 5) {
+      console.error(chalk2.gray(`   ... and ${ghostRoutes.length - 5} more`));
+    }
+    console.error(chalk2.gray("\n   These routes are in your manifest but don't have Schema components."));
+    console.error(chalk2.gray("   Run `schemasentry scaffold` to see what code to add."));
   }
-  return stableStringify4(report);
-}
-function formatCollectOutput(data, format) {
-  if (format === "json") {
-    return stableStringify4(data);
+  if (report.summary.errors > 0 || report.summary.warnings > 0) {
+    console.error(chalk2.gray(`
+\u{1F4DD} Data File Issues:`));
+    console.error(`   Errors: ${chalk2.red(report.summary.errors.toString())}`);
+    console.error(`   Warnings: ${chalk2.yellow(report.summary.warnings.toString())}`);
   }
-  return stableStringify4(data);
+  console.error("");
 }
-async function emitReport(options) {
-  const { report, format, outputPath, title } = options;
-  const content = formatReportOutput(report, format, title);
-  if (!outputPath) {
-    console.log(content);
-    return;
-  }
-  const resolvedPath = path6.resolve(process.cwd(), outputPath);
+
+// src/commands/collect.ts
+import { Command as Command4 } from "commander";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile3 } from "fs/promises";
+import path9 from "path";
+import { stableStringify as stableStringify5 } from "@schemasentry/core";
+var collectCommand = new Command4("collect").description("Collect JSON-LD blocks from built HTML output").option("--root <path>", "Root directory to scan for HTML files", ".").option("--routes <routes...>", "Only collect specific routes (repeat or comma-separated)").option("--strict-routes", "Fail when any route passed via --routes is missing").option("--format <format>", "Output format (json)", "json").option("-o, --output <path>", "Write collected schema data to file").option("--check", "Compare collected output with an existing schema data file").option(
+  "-d, --data <path>",
+  "Path to existing schema data JSON for --check",
+  "schema-sentry.data.json"
+).action(async (options) => {
+  const start = Date.now();
+  const format = resolveCollectOutputFormat(options.format);
+  const rootDir = path9.resolve(process.cwd(), options.root ?? ".");
+  const check = options.check ?? false;
+  const requestedRoutes = normalizeRouteFilter(options.routes ?? []);
+  const strictRoutes = options.strictRoutes ?? false;
+  let collected;
   try {
-    await mkdir(path6.dirname(resolvedPath), { recursive: true });
-    await writeFile(resolvedPath, content, "utf8");
-    console.error(`Report written to ${resolvedPath}`);
+    collected = await collectSchemaData({ rootDir, routes: requestedRoutes });
   } catch (error) {
     const reason = error instanceof Error && error.message.length > 0 ? error.message : "Unknown file system error";
     printCliError(
-      "output.write_failed",
-      `Could not write report to ${resolvedPath}: ${reason}`
+      "collect.scan_failed",
+      `Could not scan HTML output at ${rootDir}: ${reason}`,
+      "Point --root to a directory containing built HTML output."
     );
     process.exit(1);
+    return;
   }
-}
-function emitAnnotations(report, mode, commandLabel) {
-  if (mode !== "github") {
+  if (collected.stats.htmlFiles === 0) {
+    printCliError(
+      "collect.no_html",
+      `No HTML files found under ${rootDir}`,
+      "Point --root to a static output directory (for example ./out)."
+    );
+    process.exit(1);
     return;
   }
-  emitGitHubAnnotations(report, commandLabel);
-}
-function printCliError(code, message, suggestion) {
-  console.error(
-    stableStringify4({
-      ok: false,
-      errors: [
-        {
-          code,
-          message,
-          ...suggestion !== void 0 ? { suggestion } : {}
-        }
-      ]
-    })
-  );
-}
-async function resolveRecommendedOption(configPath) {
-  const override = getRecommendedOverride(process.argv);
-  try {
-    const config = await loadConfig({ configPath });
-    return resolveRecommended(override, config);
-  } catch (error) {
-    if (error instanceof ConfigError) {
-      printCliError(error.code, error.message, error.suggestion);
+  if (strictRoutes && collected.missingRoutes.length > 0) {
+    printCliError(
+      "collect.missing_required_routes",
+      `Required routes were not found in collected HTML: ${collected.missingRoutes.join(", ")}`,
+      "Rebuild output, adjust --root, or update --routes."
+    );
+    process.exit(1);
+    return;
+  }
+  let driftDetected = false;
+  if (check) {
+    const existingPath = path9.resolve(process.cwd(), options.data);
+    let existingRaw;
+    try {
+      existingRaw = await readFile3(existingPath, "utf8");
+    } catch (error) {
+      printCliError(
+        "data.not_found",
+        `Schema data not found at ${existingPath}`,
+        "Run `schemasentry collect --output ./schema-sentry.data.json` to generate it."
+      );
       process.exit(1);
-      return true;
+      return;
+    }
+    let existingData;
+    try {
+      existingData = JSON.parse(existingRaw);
+    } catch (error) {
+      printCliError(
+        "data.invalid_json",
+        "Schema data is not valid JSON",
+        "Check the JSON syntax or regenerate with `schemasentry collect --output`."
+      );
+      process.exit(1);
+      return;
+    }
+    if (!isSchemaData(existingData)) {
+      printCliError(
+        "data.invalid_shape",
+        "Schema data must contain a 'routes' object with array values",
+        "Ensure each route maps to an array of JSON-LD blocks."
+      );
+      process.exit(1);
+      return;
+    }
+    const existingDataForCompare = requestedRoutes.length > 0 ? filterSchemaDataByRoutes(existingData, requestedRoutes) : existingData;
+    const drift = compareSchemaData(existingDataForCompare, collected.data);
+    driftDetected = drift.hasChanges;
+    if (driftDetected) {
+      console.error(formatSchemaDataDrift(drift));
+    } else {
+      console.error("collect | No schema data drift detected.");
     }
-    throw error;
-  }
-}
-function getRecommendedOverride(argv) {
-  if (argv.includes("--recommended")) {
-    return true;
   }
-  if (argv.includes("--no-recommended")) {
-    return false;
+  const content = formatCollectOutput(collected.data, format);
+  if (options.output) {
+    const resolvedPath = path9.resolve(process.cwd(), options.output);
+    try {
+      await mkdir2(path9.dirname(resolvedPath), { recursive: true });
+      await writeFile2(resolvedPath, `${content}
+`, "utf8");
+      console.error(`Collected data written to ${resolvedPath}`);
+    } catch (error) {
+      const reason = error instanceof Error && error.message.length > 0 ? error.message : "Unknown file system error";
+      printCliError(
+        "output.write_failed",
+        `Could not write collected data to ${resolvedPath}: ${reason}`
+      );
+      process.exit(1);
+      return;
+    }
+  } else if (!check) {
+    console.log(content);
   }
-  return void 0;
-}
-function resolveCliVersion() {
-  try {
-    const raw = readFileSync(new URL("../package.json", import.meta.url), "utf8");
-    const parsed = JSON.parse(raw);
-    return parsed.version ?? "0.0.0";
-  } catch {
-    return "0.0.0";
+  printCollectWarnings(collected.warnings);
+  printCollectSummary({
+    stats: collected.stats,
+    durationMs: Date.now() - start,
+    checked: check,
+    driftDetected,
+    requestedRoutes: collected.requestedRoutes,
+    missingRoutes: collected.missingRoutes,
+    strictRoutes
+  });
+  process.exit(driftDetected ? 1 : 0);
+});
+function formatCollectOutput(data, format) {
+  if (format === "json") {
+    return stableStringify5(data);
   }
+  return stableStringify5(data);
 }
-program.parse();
-function printValidateSummary(report, durationMs) {
-  console.error(
-    formatSummaryLine("validate", {
-      ...report.summary,
-      durationMs,
-      coverage: report.summary.coverage
-    })
-  );
-}
-function printAuditSummary(report, coverageEnabled, durationMs) {
-  console.error(
-    formatSummaryLine("audit", {
-      ...report.summary,
-      durationMs,
-      coverage: report.summary.coverage
-    })
-  );
-  if (!coverageEnabled) {
-    console.error("Coverage checks skipped (no manifest provided).");
+function filterSchemaDataByRoutes(data, routes) {
+  const filteredRoutes = {};
+  for (const route of routes) {
+    if (Object.prototype.hasOwnProperty.call(data.routes, route)) {
+      filteredRoutes[route] = data.routes[route];
+    }
   }
+  return {
+    routes: filteredRoutes
+  };
 }
 function printCollectWarnings(warnings) {
   if (warnings.length === 0) {
@@ -1725,89 +1743,437 @@ function printCollectSummary(options) {
   if (requestedRoutes.length > 0) {
     parts.push(`Route filter: ${requestedRoutes.length}`);
   }
-  if (missingRoutes.length > 0) {
-    parts.push(`Missing filtered routes: ${missingRoutes.length}`);
+  if (missingRoutes.length > 0) {
+    parts.push(`Missing filtered routes: ${missingRoutes.length}`);
+  }
+  if (strictRoutes) {
+    parts.push("Strict routes: enabled");
+  }
+  console.error(`collect | ${parts.join(" | ")}`);
+}
+
+// src/commands/scaffold.ts
+import { Command as Command5 } from "commander";
+import path11 from "path";
+import chalk4 from "chalk";
+
+// src/scaffold.ts
+import { promises as fs7 } from "fs";
+import path10 from "path";
+import chalk3 from "chalk";
+import { stableStringify as stableStringify6 } from "@schemasentry/core";
+
+// src/patterns.ts
+var DEFAULT_PATTERNS = [
+  { pattern: "/blog/*", schemaType: "BlogPosting", priority: 10 },
+  { pattern: "/blog", schemaType: "WebPage", priority: 5 },
+  { pattern: "/products/*", schemaType: "Product", priority: 10 },
+  { pattern: "/product/*", schemaType: "Product", priority: 10 },
+  { pattern: "/faq", schemaType: "FAQPage", priority: 10 },
+  { pattern: "/faqs", schemaType: "FAQPage", priority: 10 },
+  { pattern: "/how-to/*", schemaType: "HowTo", priority: 10 },
+  { pattern: "/howto/*", schemaType: "HowTo", priority: 10 },
+  { pattern: "/events/*", schemaType: "Event", priority: 10 },
+  { pattern: "/event/*", schemaType: "Event", priority: 10 },
+  { pattern: "/reviews/*", schemaType: "Review", priority: 10 },
+  { pattern: "/review/*", schemaType: "Review", priority: 10 },
+  { pattern: "/videos/*", schemaType: "VideoObject", priority: 10 },
+  { pattern: "/video/*", schemaType: "VideoObject", priority: 10 },
+  { pattern: "/images/*", schemaType: "ImageObject", priority: 10 },
+  { pattern: "/image/*", schemaType: "ImageObject", priority: 10 },
+  { pattern: "/about", schemaType: "WebPage", priority: 10 },
+  { pattern: "/contact", schemaType: "WebPage", priority: 10 },
+  { pattern: "/", schemaType: "WebSite", priority: 1 }
+];
+var matchRouteToPatterns = (route, patterns = DEFAULT_PATTERNS) => {
+  const matches = [];
+  for (const rule of patterns) {
+    if (routeMatchesPattern(route, rule.pattern)) {
+      matches.push({
+        type: rule.schemaType,
+        priority: rule.priority ?? 5
+      });
+    }
+  }
+  matches.sort((a, b) => b.priority - a.priority);
+  return [...new Set(matches.map((m) => m.type))];
+};
+var routeMatchesPattern = (route, pattern) => {
+  if (pattern === route) {
+    return true;
+  }
+  if (pattern.endsWith("/*")) {
+    const prefix = pattern.slice(0, -1);
+    return route.startsWith(prefix);
+  }
+  const patternRegex = pattern.replace(/\*/g, "[^/]+").replace(/\?/g, ".");
+  const regex = new RegExp(`^${patternRegex}$`);
+  return regex.test(route);
+};
+var inferSchemaTypes = (routes, customPatterns) => {
+  const patterns = customPatterns ?? DEFAULT_PATTERNS;
+  const result = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const types = matchRouteToPatterns(route, patterns);
+    if (types.length > 0) {
+      result.set(route, types);
+    }
+  }
+  return result;
+};
+var generateManifestEntries = (routes, customPatterns) => {
+  const inferred = inferSchemaTypes(routes, customPatterns);
+  const entries = {};
+  for (const [route, types] of inferred) {
+    entries[route] = types;
+  }
+  return entries;
+};
+
+// src/scaffold.ts
+var scaffoldSchema = async (options) => {
+  const manifest = await loadManifest(options.manifestPath);
+  const data = await loadData(options.dataPath);
+  const discoveredRoutes = await scanRoutes({ rootDir: options.rootDir });
+  const routesNeedingSchema = discoveredRoutes.filter(
+    (route) => !data.routes[route] || data.routes[route].length === 0
+  );
+  const inferredTypes = inferSchemaTypes(routesNeedingSchema, options.customPatterns);
+  const manifestEntries = generateManifestEntries(
+    routesNeedingSchema,
+    options.customPatterns
+  );
+  const generatedSchemas = /* @__PURE__ */ new Map();
+  for (const [route, types] of inferredTypes) {
+    const schemas = types.map((type) => generateSchemaStub(type, route));
+    generatedSchemas.set(route, schemas);
+  }
+  const wouldUpdate = routesNeedingSchema.length > 0;
+  return {
+    routesToScaffold: routesNeedingSchema,
+    generatedSchemas,
+    manifestUpdates: manifestEntries,
+    wouldUpdate
+  };
+};
+var loadManifest = async (manifestPath) => {
+  try {
+    const raw = await fs7.readFile(manifestPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return { routes: {} };
   }
-  if (strictRoutes) {
-    parts.push("Strict routes: enabled");
+};
+var loadData = async (dataPath) => {
+  try {
+    const raw = await fs7.readFile(dataPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return { routes: {} };
   }
-  console.error(`collect | ${parts.join(" | ")}`);
-}
-function filterSchemaDataByRoutes(data, routes) {
-  const filteredRoutes = {};
-  for (const route of routes) {
-    if (Object.prototype.hasOwnProperty.call(data.routes, route)) {
-      filteredRoutes[route] = data.routes[route];
-    }
+};
+var generateSchemaStub = (type, route) => {
+  const base = {
+    "@context": "https://schema.org",
+    "@type": type
+  };
+  switch (type) {
+    case "BlogPosting":
+      return {
+        ...base,
+        headline: "Blog Post Title",
+        author: {
+          "@type": "Person",
+          name: "Author Name"
+        },
+        datePublished: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+        url: route
+      };
+    case "Product":
+      return {
+        ...base,
+        name: "Product Name",
+        description: "Product description",
+        offers: {
+          "@type": "Offer",
+          price: "0.00",
+          priceCurrency: "USD"
+        }
+      };
+    case "FAQPage":
+      return {
+        ...base,
+        mainEntity: []
+      };
+    case "HowTo":
+      return {
+        ...base,
+        name: "How-To Title",
+        step: []
+      };
+    case "Event":
+      return {
+        ...base,
+        name: "Event Name",
+        startDate: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    case "Organization":
+      return {
+        ...base,
+        name: "Organization Name",
+        url: route
+      };
+    case "WebSite":
+      return {
+        ...base,
+        name: "Website Name",
+        url: route
+      };
+    case "Article":
+      return {
+        ...base,
+        headline: "Article Headline",
+        author: {
+          "@type": "Person",
+          name: "Author Name"
+        },
+        datePublished: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      };
+    default:
+      return {
+        ...base,
+        name: `${type} Name`
+      };
   }
+};
+var generateComponentCode = (route, types, siteUrl = "https://yoursite.com") => {
+  const filePath = routeToFilePath(route);
+  const builders = [];
+  const imports = /* @__PURE__ */ new Set(["Schema"]);
+  for (const type of types) {
+    imports.add(type);
+    const builderCode = generateBuilderCode(type, route, siteUrl);
+    builders.push(builderCode);
+  }
+  const code = `import { ${Array.from(imports).join(", ")} } from "@schemasentry/next";
+
+${builders.join("\n\n")}
+
+export default function Page() {
+  return (
+    <>
+      <Schema data={[${types.join(", ").toLowerCase()}]} />
+      {/* Your existing page content */}
+    </>
+  );
+}`;
   return {
-    routes: filteredRoutes
+    route,
+    filePath,
+    code,
+    imports: Array.from(imports),
+    builders
   };
-}
-async function promptAnswers() {
-  const defaults = getDefaultAnswers();
-  const rl = createInterface({ input, output });
-  try {
-    const siteName = await ask(rl, "Site name", defaults.siteName);
-    const siteUrl = await ask(rl, "Base URL", defaults.siteUrl);
-    const authorName = await ask(rl, "Primary author name", defaults.authorName);
-    return { siteName, siteUrl, authorName };
-  } finally {
-    rl.close();
-  }
-}
-async function ask(rl, question, fallback) {
-  const answer = (await rl.question(`${question} (${fallback}): `)).trim();
-  return answer.length > 0 ? answer : fallback;
-}
-async function resolveOverwrites(options) {
-  const { manifestPath, dataPath, force, interactive } = options;
-  if (force) {
-    return [true, true];
+};
+var routeToFilePath = (route) => {
+  if (route === "/") {
+    return "app/page.tsx";
   }
-  const manifestExists = await fileExists(manifestPath);
-  const dataExists = await fileExists(dataPath);
-  if (!interactive) {
-    return [false, false];
+  const segments = route.split("/").filter(Boolean);
+  return `app/${segments.join("/")}/page.tsx`;
+};
+var generateBuilderCode = (type, route, siteUrl) => {
+  const normalizedRoute = route === "/" ? "" : route;
+  const fullUrl = `${siteUrl}${normalizedRoute}`;
+  const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  const varName = type.charAt(0).toLowerCase() + type.slice(1);
+  switch (type) {
+    case "BlogPosting":
+      return `const ${varName} = BlogPosting({
+  headline: "Blog Post Title",
+  authorName: "Author Name",
+  datePublished: "${today}",
+  url: "${fullUrl}"
+});`;
+    case "Article":
+      return `const ${varName} = Article({
+  headline: "Article Headline",
+  authorName: "Author Name",
+  datePublished: "${today}",
+  url: "${fullUrl}"
+});`;
+    case "Product":
+      return `const ${varName} = Product({
+  name: "Product Name",
+  description: "Product description",
+  url: "${fullUrl}"
+});`;
+    case "Organization":
+      return `const ${varName} = Organization({
+  name: "Organization Name",
+  url: "${siteUrl}"
+});`;
+    case "WebSite":
+      return `const ${varName} = WebSite({
+  name: "Website Name",
+  url: "${siteUrl}"
+});`;
+    case "WebPage":
+      return `const ${varName} = WebPage({
+  name: "Page Name",
+  url: "${fullUrl}"
+});`;
+    case "FAQPage":
+      return `const ${varName} = FAQPage({
+  questions: [
+    { question: "Question 1?", answer: "Answer 1" }
+  ]
+});`;
+    case "HowTo":
+      return `const ${varName} = HowTo({
+  name: "How-To Title",
+  steps: [
+    { text: "Step 1 description" }
+  ]
+});`;
+    case "Event":
+      return `const ${varName} = Event({
+  name: "Event Name",
+  startDate: "${today}"
+});`;
+    default:
+      return `const ${varName} = ${type}({
+  name: "${type} Name"
+});`;
   }
-  const rl = createInterface({ input, output });
-  try {
-    const overwriteManifest = manifestExists ? await confirm(rl, `Manifest exists at ${manifestPath}. Overwrite?`, false) : false;
-    const overwriteData = dataExists ? await confirm(rl, `Data file exists at ${dataPath}. Overwrite?`, false) : false;
-    return [overwriteManifest, overwriteData];
-  } finally {
-    rl.close();
+};
+var formatScaffoldPreview = (result) => {
+  if (result.routesToScaffold.length === 0) {
+    return "\u2705 No routes need schema generation. All routes have schema!";
   }
-}
-async function confirm(rl, question, defaultValue) {
-  const hint = defaultValue ? "Y/n" : "y/N";
-  const answer = (await rl.question(`${question} (${hint}): `)).trim().toLowerCase();
-  if (!answer) {
-    return defaultValue;
+  const lines = [
+    `\u{1F4CB} Found ${result.routesToScaffold.length} route(s) that need schema:
+`
+  ];
+  for (const route of result.routesToScaffold.slice(0, 5)) {
+    const types = result.manifestUpdates[route] || [];
+    const example = generateComponentCode(route, types);
+    lines.push(chalk3.cyan.bold(`\u{1F4C4} ${route}`));
+    lines.push(chalk3.gray(`   File: ${example.filePath}`));
+    lines.push(chalk3.gray(`   Types: ${types.join(", ") || "WebPage"}`));
+    lines.push("");
+    lines.push(chalk3.yellow("   Add this code to your page:"));
+    lines.push(chalk3.gray("   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    lines.push(example.code.split("\n").map((l) => "   " + l).join("\n"));
+    lines.push(chalk3.gray("   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n"));
+  }
+  if (result.routesToScaffold.length > 5) {
+    lines.push(chalk3.gray(`... and ${result.routesToScaffold.length - 5} more routes`));
+  }
+  lines.push(chalk3.blue("\n\u{1F4A1} Next steps:"));
+  lines.push("   1. Copy the code above into each route's page.tsx file");
+  lines.push("   2. Customize the values (titles, names, URLs)");
+  lines.push("   3. Run `next build` to build your app");
+  lines.push("   4. Run `schemasentry validate` to verify\n");
+  lines.push(chalk3.gray("   Note: Use --write to also update the manifest and data JSON files"));
+  return lines.join("\n");
+};
+var applyScaffold = async (result, options) => {
+  if (!result.wouldUpdate) {
+    return;
   }
-  return answer === "y" || answer === "yes";
-}
-function printInitSummary(options) {
-  const { manifestPath, dataPath, result } = options;
-  const created = [];
-  if (result.manifest !== "skipped") {
-    created.push(`${manifestPath} (${result.manifest})`);
+  const manifest = await loadManifest(options.manifestPath);
+  const data = await loadData(options.dataPath);
+  for (const [route, types] of Object.entries(result.manifestUpdates)) {
+    if (!manifest.routes[route]) {
+      manifest.routes[route] = types;
+    }
   }
-  if (result.data !== "skipped") {
-    created.push(`${dataPath} (${result.data})`);
+  for (const [route, schemas] of result.generatedSchemas) {
+    if (!data.routes[route]) {
+      data.routes[route] = schemas;
+    }
   }
-  if (created.length > 0) {
-    console.log("Schema Sentry init complete.");
-    console.log(`Created ${created.length} file(s):`);
-    created.forEach((entry) => console.log(`- ${entry}`));
+  await fs7.mkdir(path10.dirname(options.manifestPath), { recursive: true });
+  await fs7.mkdir(path10.dirname(options.dataPath), { recursive: true });
+  await fs7.writeFile(
+    options.manifestPath,
+    stableStringify6(manifest),
+    "utf8"
+  );
+  await fs7.writeFile(options.dataPath, stableStringify6(data), "utf8");
+};
+
+// src/commands/scaffold.ts
+var scaffoldCommand = new Command5("scaffold").description("Generate schema stubs for routes without schema (dry-run by default)").option(
+  "-m, --manifest <path>",
+  "Path to manifest JSON",
+  "schema-sentry.manifest.json"
+).option(
+  "-d, --data <path>",
+  "Path to schema data JSON",
+  "schema-sentry.data.json"
+).option("--root <path>", "Project root for scanning", ".").option("--write", "Apply changes (default is dry-run)").option("-f, --force", "Skip confirmation prompts").action(async (options) => {
+  const start = Date.now();
+  const manifestPath = path11.resolve(process.cwd(), options.manifest);
+  const dataPath = path11.resolve(process.cwd(), options.data);
+  const rootDir = path11.resolve(process.cwd(), options.root ?? ".");
+  const dryRun = !(options.write ?? false);
+  const force = options.force ?? false;
+  console.error(chalk4.blue.bold("\u{1F3D7}\uFE0F  Schema Sentry Scaffold\n"));
+  console.error(chalk4.gray("Scanning for routes that need schema...\n"));
+  const result = await scaffoldSchema({
+    manifestPath,
+    dataPath,
+    rootDir,
+    dryRun,
+    force
+  });
+  console.error(formatScaffoldPreview(result));
+  if (!result.wouldUpdate) {
+    console.error(chalk4.green("\n\u2705 All routes have schema!"));
+    process.exit(0);
+    return;
   }
-  if (result.manifest === "skipped" || result.data === "skipped") {
-    console.log("Some files were skipped. Use --force to overwrite.");
+  if (dryRun) {
+    console.error(chalk4.yellow("\n\u26A0\uFE0F  Dry run complete."));
+    console.error("Use --write to update JSON files (does NOT modify source code).\n");
+    process.exit(0);
+    return;
   }
-  if (result.manifest === "skipped" && result.data === "skipped") {
-    console.log("No files were written.");
+  if (!force) {
+    console.error(chalk4.yellow("\n\u26A0\uFE0F  Scaffolding will update:"));
+    console.error(`   - ${manifestPath}`);
+    console.error(`   - ${dataPath}`);
+    console.error("\nUse --force to skip this confirmation.");
   }
-  if (created.length > 0) {
-    console.log("Next: run `schemasentry validate` to verify your setup.");
+  try {
+    await applyScaffold(result, {
+      manifestPath,
+      dataPath,
+      rootDir,
+      dryRun,
+      force
+    });
+    console.error(chalk4.green(`
+\u2713 Scaffold complete in ${Date.now() - start}ms`));
+    console.error(chalk4.gray("\nRemember: You still need to add the Schema components to your source files!"));
+    process.exit(0);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(chalk4.red(`
+\u274C Failed to apply scaffold: ${message}`));
+    console.error("Check file permissions or disk space.");
+    process.exit(1);
   }
-}
+});
+
+// src/index.ts
+var program = new Command6();
+program.name("schemasentry").description("Schema Sentry CLI - Type-safe JSON-LD structured data for Next.js").version(resolveCliVersion());
+program.addCommand(initCommand);
+program.addCommand(validateCommand);
+program.addCommand(auditCommand);
+program.addCommand(collectCommand);
+program.addCommand(scaffoldCommand);
+program.parse();