@brandlab-digital/conformance 0.1.0-alpha.8 → 1.0.0-rc.1

package/dist/vitest.js

@@ -1,69 +1,519 @@
-import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
-import { basename, join, relative } from 'node:path';
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, join, relative } from "node:path";
 const DEFAULT_EXTENSIONS = new Set([
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.md',
-    '.mdx',
-    '.json',
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".md",
+    ".mdx",
+    ".json",
+]);
+const DEFAULT_IGNORED_DIRS = new Set([
+    "node_modules",
+    ".next",
+    ".vercel",
+    "dist",
+    "coverage",
 ]);
-const DEFAULT_IGNORED_DIRS = new Set(['node_modules', '.next', 'dist', 'coverage']);
 const ARCHITECTURE_PROFILES = new Set([
-    'dynamic-data-driven',
-    'root-level-data-driven',
-    'static-route-heavy-legacy',
+    "dynamic-data-driven",
+    "root-level-data-driven",
+    "static-route-heavy-legacy",
 ]);
-const ARCHITECTURE_STATUSES = new Set(['standard', 'legacy-exception']);
+const ARCHITECTURE_STATUSES = new Set(["standard", "legacy-exception"]);
 const DEFAULT_STATIC_ROUTE_FILE_LIMIT = 50;
-const DEFAULT_LARGE_ROUTE_FILE_LINE_LIMIT = 220;
+const DEFAULT_LARGE_ROUTE_FILE_LINE_LIMIT = 150;
+const DEFAULT_ROUTE_FILE_CONTENT_CHAR_LIMIT = 500;
+const DEFAULT_COMPONENT_CONTENT_CHAR_LIMIT = 1400;
 const DEFAULT_TOPOLOGY_ALLOWED_ROOT_DIRS = [
-    'app',
-    'components',
-    'config',
-    'content',
-    'data',
-    'lib',
+    "app",
+    "components",
+    "config",
+    "content",
+    "data",
+    "lib",
 ];
 const DEFAULT_TOPOLOGY_ALLOWED_COMPONENT_DIRS = [
-    'analytics',
-    'contact',
-    'layout',
-    'sections',
-    'templates',
-    'ui',
+    "analytics",
+    "contact",
+    "layout",
+    "sections",
+    "templates",
+    "ui",
 ];
 const DEFAULT_TOPOLOGY_ALLOWED_LIB_DIRS = [
-    'analytics',
-    'contact',
-    'content',
-    'media',
-    'seo',
+    "analytics",
+    "contact",
+    "content",
+    "seo",
+];
+const DEFAULT_TOPOLOGY_ALLOWED_TYPE_FILES = [];
+const STANDARD_PACKAGE_MANAGER = "npm@11.14.1";
+const STANDARD_NEXT_BASELINE = {
+    baseline: "2026-07",
+    nextVersion: "16.2.9",
+    reactVersion: "19.2.7",
+    reactDomVersion: "19.2.7",
+    node: "24.x",
+    minimumNode: "20.9.0",
+    router: "app",
+    bundler: "turbopack",
+    cacheComponents: false,
+    analyzeBundleScript: "next experimental-analyze",
+    imageQualities: [75, 90],
+};
+const STANDARD_TYPESCRIPT_TARGET = "ES2022";
+const CONTENT_ARRAY_NAMES = [
+    "faqs",
+    "faqItems",
+    "testimonials",
+    "defaultTestimonials",
+    "features",
+    "defaultFeatures",
+    "serviceFeatures",
+    "advantages",
+    "processSteps",
+    "seoContent",
+    "featuredServices",
+    "locationHighlights",
+];
+const CONTENT_JSX_ARRAY_PROP_NAMES = [
+    "faqs",
+    "faqItems",
+    "testimonials",
+    "features",
+    "items",
+    "cards",
+    "stats",
+];
+const ROUTE_OWNED_COPY_PROPERTY_NAMES = [
+    "alt",
+    "ariaLabel",
+    "bio",
+    "buttonLabel",
+    "buttonText",
+    "contactButtonText",
+    "description",
+    "emptyMessage",
+    "heading",
+    "keywords",
+    "loadingText",
+    "mapLabel",
+    "message",
+    "metaDescription",
+    "metaKeywords",
+    "metaTitle",
+    "pageLabel",
+    "placeholder",
+    "quoteButtonText",
+    "reviewButtonLabel",
+    "schemaDescription",
+    "service",
+    "submitButtonText",
+    "subtitle",
+    "tag",
+    "text",
+    "title",
+];
+const COMPONENT_COPY_OWNERSHIP_ROOTS = [
+    "src/components/contact/",
+    "src/components/layout/",
+    "src/components/sections/",
+    "src/components/templates/",
+];
+const COMPONENT_COPY_ALLOWED_VALUES = new Set([
+    "Back to top",
+    "Close image gallery",
+    "Close modal",
+    "Close quote modal",
+    "Collapse section",
+    "Email *",
+    "Expand section",
+    "How can we help",
+    "Maximum 5 images",
+    "Message sent successfully.",
+    "Message sent successfully! Redirecting...",
+    "Mobile *",
+    "Name *",
+    "Sending your message...",
+    "Share on Facebook",
+    "Share on LinkedIn",
+    "Share on X",
+    "Share via Email",
+    "Site navigation",
+    "Suburb *",
+    "View next image",
+    "View previous image",
+]);
+const CONTENT_ARRAY_PATTERN = new RegExp(`\\b(?:const|let|var)\\s+(?:${CONTENT_ARRAY_NAMES.join("|")})\\s*(?::[^=]+)?=\\s*\\[`, "m");
+const CONTENT_JSX_ARRAY_PROP_PATTERN = new RegExp(`\\b(?:${CONTENT_JSX_ARRAY_PROP_NAMES.join("|")})\\s*=\\s*\\{\\s*\\[`, "m");
+const REQUIRED_STANDARD_FILES = [
+    { path: "src/app/robots.ts", code: "brandlab-architecture-required-robots" },
+    {
+        path: "src/app/sitemap.ts",
+        code: "brandlab-architecture-required-sitemap",
+    },
+    {
+        path: "src/app/manifest.ts",
+        code: "brandlab-architecture-required-manifest",
+    },
+    {
+        path: "src/app/error.tsx",
+        code: "brandlab-architecture-required-error-boundary",
+    },
+    {
+        path: "src/app/global-error.tsx",
+        code: "brandlab-architecture-required-global-error-boundary",
+    },
+    {
+        path: "src/config/business.ts",
+        code: "brandlab-architecture-required-business-config",
+    },
+    {
+        path: "src/config/env.d.ts",
+        code: "brandlab-architecture-required-env-types",
+    },
+    {
+        path: "src/lib/contact/actions.ts",
+        code: "brandlab-architecture-required-contact-actions",
+    },
+    {
+        path: "src/lib/contact/ContactFormEmail.tsx",
+        code: "brandlab-architecture-required-contact-email-template",
+    },
+    {
+        path: "src/lib/contact/attachments.ts",
+        code: "brandlab-architecture-required-contact-attachments",
+    },
+    {
+        path: "src/lib/contact/client.ts",
+        code: "brandlab-architecture-required-contact-client-entrypoint",
+    },
+    {
+        path: "src/lib/contact/constants.ts",
+        code: "brandlab-architecture-required-contact-constants",
+    },
+    {
+        path: "src/lib/contact/rateLimit.ts",
+        code: "brandlab-architecture-required-contact-rate-limit",
+    },
+    {
+        path: "src/lib/contact/schema.ts",
+        code: "brandlab-architecture-required-contact-schema",
+    },
+    {
+        path: "src/lib/contact/tracking.ts",
+        code: "brandlab-architecture-required-contact-tracking",
+    },
+    {
+        path: "src/lib/contact/imageUploads.ts",
+        code: "brandlab-architecture-required-contact-image-uploads",
+    },
+    {
+        path: "src/lib/contact/useContactAttachments.ts",
+        code: "brandlab-architecture-required-contact-attachment-hook",
+    },
+    {
+        path: "src/lib/contact/useFormDraftPersistence.ts",
+        code: "brandlab-architecture-required-contact-draft-hook",
+    },
+    {
+        path: "src/components/contact/index.ts",
+        code: "brandlab-architecture-required-contact-component-entrypoint",
+    },
+    {
+        path: "src/components/contact/HeroQuoteAside.tsx",
+        code: "brandlab-architecture-required-hero-quote-aside",
+    },
+    {
+        path: "src/components/contact/QuoteTriggerButton.tsx",
+        code: "brandlab-architecture-required-quote-trigger-button",
+    },
+    {
+        path: "src/components/ui/OverlayDialog.tsx",
+        code: "brandlab-architecture-required-overlay-dialog",
+    },
+    {
+        path: "src/components/ui/FAQAccordion.tsx",
+        code: "brandlab-architecture-required-faq-accordion",
+    },
+    {
+        path: "src/components/ui/button/index.ts",
+        code: "brandlab-architecture-required-button-module",
+    },
+    {
+        path: "src/components/ui/button/Button.tsx",
+        code: "brandlab-architecture-required-button-component",
+    },
+    {
+        path: "src/components/ui/button/ButtonLink.tsx",
+        code: "brandlab-architecture-required-button-link-component",
+    },
+    {
+        path: "src/components/ui/button/ButtonContent.tsx",
+        code: "brandlab-architecture-required-button-content",
+    },
+    {
+        path: "src/components/ui/button/buttonStyles.ts",
+        code: "brandlab-architecture-required-button-styles",
+    },
+    {
+        path: "src/lib/seo/schema/blog.ts",
+        code: "brandlab-architecture-required-schema-blog-module",
+    },
+    {
+        path: "src/lib/seo/schema/marketing.ts",
+        code: "brandlab-architecture-required-schema-marketing-module",
+    },
+    {
+        path: "src/lib/seo/schema/serviceLocation.ts",
+        code: "brandlab-architecture-required-schema-service-location-module",
+    },
+    {
+        path: "src/lib/seo/sitemaps/staticRoutes.ts",
+        code: "brandlab-architecture-required-sitemap-static-routes",
+    },
+    {
+        path: "src/lib/seo/sitemaps/constants.ts",
+        code: "brandlab-architecture-required-sitemap-constants",
+    },
+];
+const REQUIRED_STANDARD_TEST_FILES = [
+    "tests/config/brandlab-config.test.ts",
+    "tests/config/brandlab-conformance.test.ts",
+    "tests/config/config.test.ts",
+    "tests/config/tooling.test.ts",
+    "tests/config/env.test.ts",
+    "tests/config/server-env.test.ts",
+    "tests/app/customer-copy-leakage.test.ts",
+    "tests/app/content-ownership.test.ts",
+    "tests/app/robots.test.ts",
+    "tests/lib/entrypoints.test.ts",
+    "tests/lib/seo/metadata.test.ts",
+    "tests/lib/seo/schema-file-contract.test.ts",
+    "tests/lib/seo/schema-id-stability.test.ts",
+    "tests/lib/seo/sitemaps.test.ts",
+    "tests/lib/contact/actions.test.ts",
+    "tests/lib/contact/schema.test.ts",
+    "tests/lib/contact/tracking.test.ts",
+    "tests/instrumentation-client.test.ts",
+];
+const REQUIRED_ALTERNATIVE_TEST_FILES = [
+    {
+        code: "brandlab-architecture-required-analytics-tests",
+        detail: "Brandlab standard projects must test canonical lead analytics events and fake-success suppression.",
+        paths: ["tests/lib/analytics.test.ts", "tests/lib/analytics.test.tsx"],
+    },
+];
+const CANONICAL_SOURCE_ROOTS = [
+    "src/app",
+    "src/data/blog/pageModels.tsx",
+    "src/data/site/pages",
+    "src/lib/seo",
+];
+const FORBIDDEN_STANDARD_FILES = [
+    { path: "CLAUDE.md", code: "brandlab-architecture-root-agent-doc" },
+    { path: ".node-version", code: "brandlab-architecture-root-node-version" },
+    {
+        path: "tailwind.config.js",
+        code: "brandlab-architecture-legacy-tailwind-config",
+    },
+    {
+        path: "tsconfig.tsbuildinfo",
+        code: "brandlab-architecture-build-artifact",
+    },
+    {
+        path: "src/lib/metadata.ts",
+        code: "brandlab-architecture-legacy-metadata-wrapper",
+    },
+    { path: "src/lib/api.ts", code: "brandlab-architecture-legacy-api-wrapper" },
+    {
+        path: "src/lib/seo/useBreadcrumbs.ts",
+        code: "brandlab-architecture-legacy-breadcrumb-hook",
+    },
+    {
+        path: "src/components/ui/StructuredData.tsx",
+        code: "brandlab-architecture-legacy-structured-data",
+    },
+    {
+        path: "src/components/ui/ContactForm.tsx",
+        code: "brandlab-architecture-contact-component-ownership",
+    },
+    {
+        path: "src/components/ui/QuoteModal.tsx",
+        code: "brandlab-architecture-contact-component-ownership",
+    },
+    {
+        path: "src/components/ui/QuoteSidebar.tsx",
+        code: "brandlab-architecture-contact-component-ownership",
+    },
+    {
+        path: "src/components/contact/QuoteSidebar.tsx",
+        code: "brandlab-architecture-contact-aside-name",
+    },
+    {
+        path: "src/components/layout/Layout.tsx",
+        code: "brandlab-architecture-layout-wrapper",
+    },
+    {
+        path: "src/components/templates/ServicePageModels.tsx",
+        code: "brandlab-architecture-component-service-page-models",
+    },
+    {
+        path: "src/components/templates/blogHeadings.tsx",
+        code: "brandlab-architecture-component-helper-file",
+    },
+    {
+        path: "src/app/api/contact/route.ts",
+        code: "brandlab-architecture-contact-api-route",
+    },
+    {
+        path: "src/lib/contact/index.ts",
+        code: "brandlab-architecture-mixed-contact-barrel",
+    },
+    {
+        path: "src/lib/contact/server-actions.ts",
+        code: "brandlab-architecture-contact-compat-action-wrapper",
+    },
+    {
+        path: "src/lib/seo/schema/base.ts",
+        code: "brandlab-architecture-legacy-schema-module",
+    },
+    {
+        path: "src/lib/seo/schema/pages.ts",
+        code: "brandlab-architecture-legacy-schema-module",
+    },
+    {
+        path: "src/lib/seo/schema/services.ts",
+        code: "brandlab-architecture-legacy-schema-module",
+    },
+    {
+        path: "src/lib/seo/schema/site.ts",
+        code: "brandlab-architecture-legacy-schema-module",
+    },
+];
+const FORBIDDEN_STANDARD_DIRECTORIES = [
+    {
+        path: ".cursor",
+        code: "brandlab-architecture-root-cursor-directory",
+    },
+    {
+        path: "docs",
+        code: "brandlab-architecture-root-docs-directory",
+    },
+    {
+        path: "files",
+        code: "brandlab-architecture-root-files-directory",
+    },
+    {
+        path: "PROJECT_STANDARDISATION",
+        code: "brandlab-architecture-root-standardisation-directory",
+    },
+    {
+        path: "src/components/templates/pages",
+        code: "brandlab-architecture-component-page-modules-directory",
+    },
+    {
+        path: "src/components/templates/pageModels",
+        code: "brandlab-architecture-component-page-models-directory",
+    },
+    {
+        path: "src/components/templates/staticPages",
+        code: "brandlab-architecture-component-static-pages-directory",
+    },
+    {
+        path: "src/lib/content/pageModels",
+        code: "brandlab-architecture-content-page-models-directory",
+    },
+    {
+        path: "src/lib/seo/schema/builders",
+        code: "brandlab-architecture-legacy-schema-builders-directory",
+    },
+];
+const STANDARD_CONTACT_MODULE_FILES = new Set([
+    "ContactFormEmail.tsx",
+    "actions.ts",
+    "attachments.ts",
+    "client.ts",
+    "constants.ts",
+    "imageUploads.ts",
+    "rateLimit.ts",
+    "schema.ts",
+    "tracking.ts",
+    "useContactAttachments.ts",
+    "useFormDraftPersistence.ts",
+]);
+const CONTACT_EMAIL_CONTRACT_REQUIREMENTS = [
+    {
+        code: "brandlab-architecture-contact-email-submission-id",
+        pattern: /\bsubmissionId\b/,
+        detail: "src/lib/contact/ContactFormEmail.tsx must include the shared submissionId field.",
+    },
+    {
+        code: "brandlab-architecture-contact-email-page-path",
+        pattern: /\bpagePath\b/,
+        detail: "src/lib/contact/ContactFormEmail.tsx must include the submitted pagePath field.",
+    },
+    {
+        code: "brandlab-architecture-contact-email-page-url",
+        pattern: /\bpageUrl\b/,
+        detail: "src/lib/contact/ContactFormEmail.tsx must include the submitted pageUrl field.",
+    },
+    {
+        code: "brandlab-architecture-contact-email-traffic-source",
+        pattern: /\btrafficSource\b/,
+        detail: "src/lib/contact/ContactFormEmail.tsx must include the trafficSource field.",
+    },
+    {
+        code: "brandlab-architecture-contact-email-ad-click-rows",
+        pattern: /\b(adClickIds|getAdClickIdRows|formatAdClickIdsForEmailText)\b/,
+        detail: "src/lib/contact/ContactFormEmail.tsx must include ad-click ID rows.",
+    },
+    {
+        code: "brandlab-architecture-contact-email-attachments",
+        pattern: /\b(attachmentCount|attachments|formatContactFormEmailAttachmentSummary|getContactFormEmailContextRows)\b/,
+        detail: "src/lib/contact/ContactFormEmail.tsx must include an attachment summary.",
+    },
 ];
-const DEFAULT_TOPOLOGY_ALLOWED_TYPE_FILES = ['src/types/env.d.ts'];
-const CONTENT_ARRAY_PATTERN = /\b(?:const|let|var)\s+(?:faqs|faqItems|testimonials|serviceFeatures|advantages|processSteps|featuredServices|locationHighlights)\s*=\s*\[/m;
+const ALLOWED_RICH_DATA_CONTENT_PATTERNS = [
+    /^src\/data\/site\/legal\/[^/]+\.(?:ts|tsx)$/,
+];
+const LEGACY_ENV_ARTIFACT_PATTERNS = [
+    /\bNEXT_PUBLIC_RECAPTCHA_SITE_KEY\b/,
+    /\bNEXT_PUBLIC_GOOGLE_MAPS(?:_PLATFORM)?_API_KEY\b/,
+    /\bRECAPTCHA_SECRET_KEY\b/,
+    /\bOUTLOOK_EMAIL\b/,
+    /\bOUTLOOK_PASSWORD\b/,
+    /\bEMAIL_USER\b/,
+    /\bEMAIL_PASSWORD\b/,
+];
+const LEGACY_CSS_ARTIFACT_PATTERNS = [/\.grecaptcha-badge\b/];
 export const BRANDLAB_FORBIDDEN_SOURCE_PATTERNS = [
     {
-        name: 'legacy analytics event',
+        name: "legacy analytics event",
         pattern: /\b(contact_form_submission|phone_calls|form_start|cta_click)\b/,
     },
     {
-        name: 'non-standard indexing override',
+        name: "non-standard indexing override",
         pattern: /\bALLOW_INDEXING\s*=\s*true\b|ALLOW_INDEXING=true/,
     },
     {
-        name: 'disabled service-location sentinel',
+        name: "disabled service-location sentinel",
         pattern: /__service-location-disabled__/,
     },
     {
-        name: 'sitemap filesystem freshness',
+        name: "sitemap filesystem freshness",
         pattern: /\bfs\.statSync\b|\.mtime\b|\bmtime\b/,
     },
+    {
+        name: "public Google Maps API key",
+        pattern: /\bNEXT_PUBLIC_GOOGLE_MAPS(?:_PLATFORM)?_API_KEY\b/,
+    },
 ];
 function fileExtension(path) {
     const match = path.match(/\.[^.]+$/);
-    return match?.[0] ?? '';
+    return match?.[0] ?? "";
 }
 function walkFiles(root, files = []) {
     for (const entry of readdirSync(root)) {
@@ -98,10 +548,114 @@ function walkAllFiles(root, files = []) {
     return files;
 }
 function appFamilyForPage(path) {
-    const withoutPrefix = path.replace(/^src\/app\//, '');
-    if (withoutPrefix === 'page.tsx')
-        return 'home';
-    return withoutPrefix.split('/')[0] ?? 'unknown';
+    const withoutPrefix = path.replace(/^src\/app\//, "");
+    if (withoutPrefix === "page.tsx")
+        return "home";
+    return withoutPrefix.split("/")[0] ?? "unknown";
+}
+function appRouteFileIsDynamic(path) {
+    return /\/\[[^\]]+\]\//.test(path) || /\[[^\]]+\]/.test(path);
+}
+function routeTemplateImportMatches(source) {
+    return [
+        ...source.matchAll(/^\s*import\s+([^'"\n]+?)\s+from\s+['"](@\/components\/templates\/[^'"]+)['"]/gm),
+    ].flatMap((match) => {
+        const importClause = match[1].trim();
+        const modulePath = match[2];
+        const names = [];
+        const defaultName = importClause
+            .replace(/\{[\s\S]*?\}/g, "")
+            .split(",")[0]
+            ?.trim();
+        if (defaultName)
+            names.push(defaultName);
+        const namedClause = importClause.match(/\{([\s\S]*?)\}/)?.[1];
+        if (namedClause) {
+            for (const part of namedClause.split(",")) {
+                const name = part.trim().split(/\s+as\s+/).pop()?.trim();
+                if (name)
+                    names.push(name);
+            }
+        }
+        return names.map((name) => ({
+            localName: name,
+            modulePath,
+        }));
+    });
+}
+function extractQuotedStrings(line) {
+    const strings = [];
+    let quote = null;
+    let start = -1;
+    let escaped = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const char = line[index];
+        if (!quote) {
+            if (char === '"' || char === "'" || char === "`") {
+                quote = char;
+                start = index;
+            }
+            continue;
+        }
+        if (escaped)
+            escaped = false;
+        else if (char === "\\")
+            escaped = true;
+        else if (char === quote) {
+            strings.push({
+                value: line.slice(start + 1, index),
+                prefix: line.slice(Math.max(0, start - 32), start),
+            });
+            quote = null;
+            start = -1;
+        }
+    }
+    return strings;
+}
+function looksLikeCustomerFacingText(value) {
+    const cleanValue = value.replace(/\s+/g, " ").trim();
+    if (cleanValue.length < 12)
+        return false;
+    if (!/[A-Za-z]/.test(cleanValue))
+        return false;
+    if (!/\s/.test(cleanValue))
+        return false;
+    if (/^(?:https?:|mailto:|tel:|\/|\.\/|\.\.\/|@\/)/.test(cleanValue))
+        return false;
+    if (/^[a-z0-9_:/.[\]()%#,-]+$/i.test(cleanValue) && !/[.!?]/.test(cleanValue))
+        return false;
+    return true;
+}
+function countRouteOwnedContentChars(source) {
+    let total = 0;
+    for (const line of source.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("import ") ||
+            trimmed.startsWith("export ") ||
+            trimmed.startsWith("//") ||
+            trimmed.startsWith("*") ||
+            trimmed.startsWith("/*")) {
+            continue;
+        }
+        for (const { value, prefix } of extractQuotedStrings(line)) {
+            if (/(?:className|style|d|viewBox|fill|stroke|xmlns|aria-hidden|role|key|id|htmlFor|type|name|href|src)\s*=\s*{?\s*$/.test(prefix) ||
+                /(?:className|style)\s*:\s*$/.test(prefix)) {
+                continue;
+            }
+            if (looksLikeCustomerFacingText(value)) {
+                total += value.replace(/\s+/g, " ").trim().length;
+            }
+        }
+    }
+    const withoutCodeComments = source
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/\/\/.*$/gm, "");
+    for (const match of withoutCodeComments.matchAll(/>\s*([^<>{}][^<>{}]*)\s*</g)) {
+        const text = match[1].replace(/\s+/g, " ").trim();
+        if (looksLikeCustomerFacingText(text))
+            total += text.length;
+    }
+    return total;
 }
 function listImmediateDirectories(root) {
     if (!existsSync(root))
@@ -111,24 +665,114 @@ function listImmediateDirectories(root) {
         .map((entry) => entry.name)
         .sort();
 }
+function listImmediateFiles(root) {
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .sort();
+}
 function topologyArray(value, fallback = []) {
     return Array.isArray(value) ? [...value] : [...fallback];
 }
 function addTopologyIssue(options) {
-    const isAcceptedLegacy = options.architecture?.status === 'legacy-exception' && options.legacyAllowed;
     options.issues.push({
-        severity: isAcceptedLegacy ? 'legacy-accepted' : 'error',
+        severity: "error",
         code: options.code,
         detail: options.detail,
         path: options.path,
     });
 }
+function isAllowedRichDataContent(relativePath) {
+    return ALLOWED_RICH_DATA_CONTENT_PATTERNS.some((pattern) => pattern.test(relativePath));
+}
+function hasDataValueComponentImport(source) {
+    return /^\s*import\s+(?!type\b)[^\n]*\s+from\s+['"](?:@\/components\/|\.\.?\/.*components\/)/m.test(source);
+}
+function hasDataIconImport(source) {
+    return /^\s*import\s+(?!type\b)[^\n]*\s+from\s+['"](?:react-icons(?:\/[^'"]*)?|lucide-react)['"]/m.test(source);
+}
+function hasDataRenderFunction(source) {
+    return /\brender[A-Za-z0-9_]*\s*:\s*(?:\([^)]*\)\s*)?=>|\brender[A-Za-z0-9_]*\s*:\s*function\b|\b(?:React\.)?ReactNode\b/.test(source);
+}
+function hasDataJsxRendering(source) {
+    return /\bcreateElement\s*\(|(?<![A-Za-z0-9_])<[A-Z][A-Za-z0-9_.]*(?:\s+[A-Za-z_{]|>|\/>)/m.test(source);
+}
+function hasUseClientDirective(source) {
+    return /^\s*['"]use client['"];?/m.test(source);
+}
+function hasMetadataExport(source) {
+    return /\bexport\s+(?:const|let|var)\s+metadata\b|\bexport\s+(?:async\s+)?function\s+generateMetadata\b/.test(source);
+}
+function hasPageMetadataExport(source) {
+    return /\bexport\s+(?:const|let|var)\s+pageMetadata\b/.test(source);
+}
+function hasMetadataBuilderUsage(source) {
+    return /\bbuild(?:Page)?Metadata\s*\(/.test(source);
+}
+function hasRoutePageModuleReexport(source) {
+    return (/export\s+\{[^}]+\}\s+from\s+['"]@\/components\/templates\/pages\//.test(source) ||
+        /export\s+\{[^}]+\}\s+from\s+['"]@\/lib\/content\/pageModels\//.test(source));
+}
+function hasRawMetadataObjectExport(source) {
+    return /\bexport\s+const\s+metadata(?:\s*:\s*Metadata)?\s*=\s*\{/.test(source);
+}
+function routeOwnedCopyPropertyMatches(source) {
+    const matches = [];
+    const propertyPattern = ROUTE_OWNED_COPY_PROPERTY_NAMES.join("|");
+    const objectPropertyPattern = new RegExp(`\\b(${propertyPattern})\\s*:\\s*(['"\`])((?:\\\\.|(?!\\2)[\\s\\S])*?)\\2`, "g");
+    const jsxPropertyPattern = new RegExp(`\\b(${propertyPattern})\\s*=\\s*(['"\`])((?:\\\\.|(?!\\2)[\\s\\S])*?)\\2`, "g");
+    for (const pattern of [objectPropertyPattern, jsxPropertyPattern]) {
+        for (const match of source.matchAll(pattern)) {
+            const propertyName = match[1];
+            const value = match[3];
+            if (!looksLikeCustomerFacingText(value))
+                continue;
+            matches.push({
+                propertyName,
+                value: value.replace(/\s+/g, " ").trim(),
+            });
+        }
+    }
+    return matches;
+}
+function componentOwnedVisibleCopyPropertyMatches(source) {
+    return routeOwnedCopyPropertyMatches(source).filter((match) => !COMPONENT_COPY_ALLOWED_VALUES.has(match.value));
+}
+function hasComponentOwnedContentArray(source) {
+    return (CONTENT_ARRAY_PATTERN.test(source) ||
+        CONTENT_JSX_ARRAY_PROP_PATTERN.test(source));
+}
+function hasComponentExportedContentRecord(source) {
+    return (/\bexport\s+const\s+[A-Za-z0-9_]*(?:Content|Copy|Text)\s*(?::[^=]+)?=\s*\{/.test(source) && routeOwnedCopyPropertyMatches(source).length > 0);
+}
+function componentValueDataImportMatches(source) {
+    return [
+        ...source.matchAll(/^\s*import\s+(?!type\b)(?:(?!^\s*import\s)[\s\S])*?\s+from\s+['"](@\/data(?:\/[^'"]*)?)['"]/gm),
+    ].map((match) => match[1]);
+}
+function modulePathExists(root, modulePath) {
+    if (!modulePath)
+        return false;
+    return [
+        modulePath,
+        `${modulePath}.ts`,
+        `${modulePath}.tsx`,
+        `${modulePath}.js`,
+        `${modulePath}.jsx`,
+        `${modulePath}/index.ts`,
+        `${modulePath}/index.tsx`,
+        `${modulePath}/index.js`,
+        `${modulePath}/index.jsx`,
+    ].some((candidate) => existsSync(join(root, candidate)));
+}
 export function scanTextFiles(options) {
     return options.roots
         .flatMap((root) => walkFiles(root))
         .map((path) => ({
         path,
-        text: readFileSync(path, 'utf8'),
+        text: readFileSync(path, "utf8"),
     }));
 }
 export function findForbiddenBrandlabPatterns(options) {
@@ -154,30 +798,91 @@ export function findForbiddenBrandlabPatterns(options) {
     return matches;
 }
 function getPackageVersion(packageJson, packageName) {
-    return packageJson.dependencies?.[packageName] ?? packageJson.devDependencies?.[packageName] ?? null;
+    return (packageJson.dependencies?.[packageName] ??
+        packageJson.devDependencies?.[packageName] ??
+        null);
+}
+function isExactVersionSpec(version) {
+    return typeof version === "string" && !/^[~^*]|latest|workspace:|file:|link:/.test(version);
+}
+function extractDelimitedProperty(source, propertyName, openChar, closeChar) {
+    const propertyMatch = source.match(new RegExp(`${propertyName}\\s*:`));
+    if (!propertyMatch || propertyMatch.index === undefined)
+        return null;
+    const start = source.indexOf(openChar, propertyMatch.index + propertyMatch[0].length);
+    if (start === -1)
+        return null;
+    let depth = 0;
+    let quote = null;
+    let escaped = false;
+    for (let index = start; index < source.length; index += 1) {
+        const char = source[index];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (char === "\\")
+                escaped = true;
+            else if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'" || char === "`")
+            quote = char;
+        else if (char === openChar)
+            depth += 1;
+        else if (char === closeChar) {
+            depth -= 1;
+            if (depth === 0)
+                return source.slice(start + 1, index);
+        }
+    }
+    return null;
+}
+function extractStringProperty(source, propertyName) {
+    return source.match(new RegExp(`${propertyName}\\s*:\\s*['"\`]([^'"\`]+)['"\`]`, "m"))?.[1] ?? null;
+}
+function parseBrandlabNextContract(source) {
+    const nextSource = extractDelimitedProperty(source, "next", "{", "}");
+    if (!nextSource)
+        return null;
+    return {
+        baseline: extractStringProperty(nextSource, "baseline"),
+        nextVersion: extractStringProperty(nextSource, "nextVersion"),
+        reactVersion: extractStringProperty(nextSource, "reactVersion"),
+        reactDomVersion: extractStringProperty(nextSource, "reactDomVersion"),
+        node: extractStringProperty(nextSource, "node"),
+        minimumNode: extractStringProperty(nextSource, "minimumNode"),
+        router: extractStringProperty(nextSource, "router"),
+        bundler: extractStringProperty(nextSource, "bundler"),
+        cacheComponents: /cacheComponents\s*:\s*true/m.test(nextSource)
+            ? true
+            : /cacheComponents\s*:\s*false/m.test(nextSource)
+                ? false
+                : null,
+    };
 }
 export function evaluateSharedPackageVersionSpecs(options) {
     const issues = [];
     for (const packageName of options.packageNames) {
         const installedVersion = getPackageVersion(options.packageJson, packageName);
         if (!installedVersion) {
-            issues.push({ packageName, installedVersion, issue: 'missing' });
+            issues.push({ packageName, installedVersion, issue: "missing" });
             continue;
         }
         if (installedVersion !== options.expectedVersion) {
             issues.push({
                 packageName,
                 installedVersion,
-                issue: installedVersion.replace(/^[~^]/, '') === options.expectedVersion
-                    ? 'not-exact'
-                    : 'mismatch',
+                issue: installedVersion.replace(/^[~^]/, "") === options.expectedVersion
+                    ? "not-exact"
+                    : "mismatch",
             });
         }
     }
     return issues;
 }
 export function evaluateNpmDistTags(options) {
-    const tags = options.tags ?? ['alpha', 'latest'];
+    const tags = options.tags ?? ["alpha", "latest"];
     return tags.flatMap((tag) => {
         const actualVersion = options.distTags[tag] ?? null;
         return actualVersion === options.expectedVersion
@@ -202,81 +907,140 @@ export function isSearchCertificationFresh(evidence, now = Date.now(), maxAgeDay
 }
 export function evaluateBrandlabArchitecture(options) {
     const architecture = options.architecture ?? null;
-    const largeRouteFileLineLimit = options.largeRouteFileLineLimit ?? DEFAULT_LARGE_ROUTE_FILE_LINE_LIMIT;
-    const appRoot = join(options.root, 'src/app');
+    const largeRouteFileLineLimit = options.largeRouteFileLineLimit ??
+        architecture?.largeRouteFileLineLimit ??
+        DEFAULT_LARGE_ROUTE_FILE_LINE_LIMIT;
+    const routeFileContentCharLimit = options.routeFileContentCharLimit ??
+        architecture?.routeFileContentCharLimit ??
+        DEFAULT_ROUTE_FILE_CONTENT_CHAR_LIMIT;
+    const appRoot = join(options.root, "src/app");
     const pageFiles = walkAllFiles(appRoot)
-        .filter((path) => basename(path) === 'page.tsx')
-        .map((path) => relative(options.root, path).split(/[/\\]/).join('/'))
+        .filter((path) => basename(path) === "page.tsx")
+        .map((path) => relative(options.root, path).split(/[/\\]/).join("/"))
+        .sort();
+    const routeBoundaryFiles = walkAllFiles(appRoot)
+        .filter((path) => /[/\\](?:page|not-found)\.(?:ts|tsx|js|jsx)$/.test(path))
+        .map((path) => relative(options.root, path).split(/[/\\]/).join("/"))
         .sort();
     const issues = [];
     if (!architecture) {
         issues.push({
-            severity: 'error',
-            code: 'brandlab-architecture-config-missing',
-            detail: 'brandlab.config.ts is missing the architecture contract.',
+            severity: "error",
+            code: "brandlab-architecture-config-missing",
+            detail: "brandlab.config.ts is missing the architecture contract.",
         });
     }
     else {
-        if (!ARCHITECTURE_PROFILES.has(architecture.profile ?? '')) {
+        if (!ARCHITECTURE_PROFILES.has(architecture.profile ?? "")) {
             issues.push({
-                severity: 'error',
-                code: 'brandlab-architecture-profile',
-                detail: `Invalid architecture profile: ${architecture.profile ?? 'missing'}.`,
+                severity: "error",
+                code: "brandlab-architecture-profile",
+                detail: `Invalid architecture profile: ${architecture.profile ?? "missing"}.`,
             });
         }
-        if (!ARCHITECTURE_STATUSES.has(architecture.status ?? '')) {
+        if (!ARCHITECTURE_STATUSES.has(architecture.status ?? "")) {
             issues.push({
-                severity: 'error',
-                code: 'brandlab-architecture-status',
-                detail: `Invalid architecture status: ${architecture.status ?? 'missing'}.`,
+                severity: "error",
+                code: "brandlab-architecture-status",
+                detail: `Invalid architecture status: ${architecture.status ?? "missing"}.`,
             });
         }
-        if (architecture.status === 'standard' && architecture.profile === 'static-route-heavy-legacy') {
+        if (architecture.status === "standard" &&
+            architecture.profile === "static-route-heavy-legacy") {
             issues.push({
-                severity: 'error',
-                code: 'brandlab-architecture-static-standard',
-                detail: 'static-route-heavy-legacy cannot be marked as standard.',
+                severity: "error",
+                code: "brandlab-architecture-static-standard",
+                detail: "static-route-heavy-legacy cannot be marked as standard.",
             });
         }
-        if (architecture.status === 'legacy-exception' &&
+        if (architecture.status === "legacy-exception") {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-legacy-exception-status",
+                detail: "legacy-exception projects are not rollout-ready under the Brandlab Architecture Standard.",
+            });
+        }
+        if (architecture.status === "legacy-exception" &&
             (!architecture.targetProfile ||
                 architecture.targetProfile === architecture.profile ||
                 !ARCHITECTURE_PROFILES.has(architecture.targetProfile))) {
             issues.push({
-                severity: 'error',
-                code: 'brandlab-architecture-target-profile',
-                detail: 'Legacy architecture exceptions must declare a different valid targetProfile.',
+                severity: "error",
+                code: "brandlab-architecture-target-profile",
+                detail: "Legacy architecture exceptions must declare a different valid targetProfile.",
             });
         }
-        if (architecture.status === 'legacy-exception' &&
-            (!architecture.migrationRationale || architecture.migrationRationale.length < 20)) {
+        if (architecture.status === "legacy-exception" &&
+            (!architecture.migrationRationale ||
+                architecture.migrationRationale.length < 20)) {
             issues.push({
-                severity: 'error',
-                code: 'brandlab-architecture-migration-rationale',
-                detail: 'Legacy architecture exceptions must explain why the exception exists.',
+                severity: "error",
+                code: "brandlab-architecture-migration-rationale",
+                detail: "Legacy architecture exceptions must explain why the exception exists.",
             });
         }
-        if (!architecture.routeFamilies || architecture.routeFamilies.length === 0) {
+        if (!architecture.routeFamilies ||
+            architecture.routeFamilies.length === 0) {
             issues.push({
-                severity: 'error',
-                code: 'brandlab-architecture-route-families',
-                detail: 'Architecture contract is missing route-family declarations.',
+                severity: "error",
+                code: "brandlab-architecture-route-families",
+                detail: "Architecture contract is missing route-family declarations.",
             });
         }
-        if (architecture.contentOwnership?.routeFiles !== 'thin' ||
-            architecture.contentOwnership?.pageData !== 'src/data' ||
-            architecture.contentOwnership?.componentCopy !== 'data-props') {
+        if (architecture.status === "standard") {
+            for (const family of architecture.routeFamilies ?? []) {
+                if (family.model &&
+                    !["dynamic", "dynamic-root"].includes(family.model)) {
+                    issues.push({
+                        severity: "error",
+                        code: "brandlab-architecture-route-family-model",
+                        detail: `Standard architecture route families must be dynamic/data-driven; found model "${family.model}".`,
+                    });
+                }
+                if (family.name === "blog" &&
+                    family.route &&
+                    family.route !== "/blog/[slug]") {
+                    issues.push({
+                        severity: "error",
+                        code: "brandlab-architecture-route-family-convention",
+                        detail: `Blog route family uses "${family.route}" instead of the standard /blog/[slug] route convention.`,
+                        path: family.route,
+                    });
+                }
+                if (family.dataSource &&
+                    /\/(?:catalog|posts)$/.test(family.dataSource)) {
+                    issues.push({
+                        severity: "error",
+                        code: "brandlab-architecture-route-family-data-source-root",
+                        detail: `Route family "${family.name ?? "unknown"}" points to a leaf data module instead of the owning data folder.`,
+                        path: family.dataSource,
+                    });
+                }
+                if (!family.dataSource ||
+                    !modulePathExists(options.root, family.dataSource)) {
+                    issues.push({
+                        severity: "error",
+                        code: "brandlab-architecture-route-family-data-source",
+                        detail: `Route family "${family.name ?? "unknown"}" points to a missing dataSource module.`,
+                        path: family.dataSource,
+                    });
+                }
+            }
+        }
+        if (architecture.contentOwnership?.routeFiles !== "thin" ||
+            architecture.contentOwnership?.pageData !== "src/data" ||
+            architecture.contentOwnership?.componentCopy !== "data-props") {
             issues.push({
-                severity: 'error',
-                code: 'brandlab-architecture-content-ownership',
-                detail: 'Architecture contract must declare thin routes, src/data page ownership, and data-prop component copy.',
+                severity: "error",
+                code: "brandlab-architecture-content-ownership",
+                detail: "Architecture contract must declare thin routes, src/data page ownership, and data-prop component copy.",
             });
         }
         if (!architecture.topology) {
             issues.push({
-                severity: 'error',
-                code: 'brandlab-architecture-topology-config',
-                detail: 'Architecture contract is missing the source topology declaration.',
+                severity: "error",
+                code: "brandlab-architecture-topology-config",
+                detail: "Architecture contract is missing the source topology declaration.",
             });
         }
     }
@@ -290,93 +1054,1612 @@ export function evaluateBrandlabArchitecture(options) {
         const legacyAllowedComponentDirs = new Set(topologyArray(topology.legacyAllowedComponentDirs));
         const legacyAllowedLibDirs = new Set(topologyArray(topology.legacyAllowedLibDirs));
         const legacyAllowedTypeFiles = new Set(topologyArray(topology.legacyAllowedTypeFiles));
-        for (const directory of listImmediateDirectories(join(options.root, 'src'))) {
-            if (directory === 'types')
+        for (const directory of listImmediateDirectories(join(options.root, "src"))) {
+            if (directory === "types")
                 continue;
             if (allowedRootDirs.has(directory))
                 continue;
             addTopologyIssue({
                 issues,
                 architecture,
-                code: 'brandlab-architecture-root-directory',
+                code: "brandlab-architecture-root-directory",
                 detail: `src/${directory} is outside the Brandlab source topology.`,
                 path: `src/${directory}`,
                 legacyAllowed: legacyAllowedRootDirs.has(directory),
             });
         }
-        for (const directory of listImmediateDirectories(join(options.root, 'src/components'))) {
+        for (const directory of listImmediateDirectories(join(options.root, "src/components"))) {
             if (allowedComponentDirs.has(directory))
                 continue;
             addTopologyIssue({
                 issues,
                 architecture,
-                code: 'brandlab-architecture-component-directory',
+                code: "brandlab-architecture-component-directory",
                 detail: `src/components/${directory} is outside the Brandlab component topology.`,
                 path: `src/components/${directory}`,
                 legacyAllowed: legacyAllowedComponentDirs.has(directory),
             });
         }
-        for (const directory of listImmediateDirectories(join(options.root, 'src/lib'))) {
+        for (const directory of listImmediateDirectories(join(options.root, "src/lib"))) {
             if (allowedLibDirs.has(directory))
                 continue;
             addTopologyIssue({
                 issues,
                 architecture,
-                code: 'brandlab-architecture-lib-directory',
+                code: "brandlab-architecture-lib-directory",
                 detail: `src/lib/${directory} is outside the Brandlab library topology.`,
                 path: `src/lib/${directory}`,
                 legacyAllowed: legacyAllowedLibDirs.has(directory),
             });
         }
-        for (const filePath of walkAllFiles(join(options.root, 'src/types'))
-            .map((path) => relative(options.root, path).split(/[/\\]/).join('/'))
+        for (const fileName of listImmediateFiles(join(options.root, "src/lib"))) {
+            if (!/\.(?:ts|tsx|js|jsx)$/.test(fileName))
+                continue;
+            addTopologyIssue({
+                issues,
+                architecture,
+                code: "brandlab-architecture-root-lib-file",
+                detail: `src/lib/${fileName} sits directly under src/lib instead of an owning library namespace.`,
+                path: `src/lib/${fileName}`,
+                legacyAllowed: false,
+            });
+        }
+        for (const filePath of walkAllFiles(join(options.root, "src/types"))
+            .map((path) => relative(options.root, path).split(/[/\\]/).join("/"))
             .sort()) {
             if (allowedTypeFiles.has(filePath))
                 continue;
             addTopologyIssue({
                 issues,
                 architecture,
-                code: 'brandlab-architecture-type-file',
+                code: "brandlab-architecture-type-file",
                 detail: `${filePath} is outside the Brandlab type ownership topology.`,
                 path: filePath,
                 legacyAllowed: legacyAllowedTypeFiles.has(filePath),
             });
         }
     }
-    const familyCounts = new Map();
-    for (const filePath of pageFiles) {
-        const family = appFamilyForPage(filePath);
-        const current = familyCounts.get(family) ?? { staticCount: 0, dynamicCount: 0 };
-        if (filePath.includes('['))
-            current.dynamicCount += 1;
-        else
-            current.staticCount += 1;
-        familyCounts.set(family, current);
-        const source = readFileSync(join(options.root, filePath), 'utf8');
-        const lineCount = source.split(/\r?\n/).length;
-        if (lineCount > largeRouteFileLineLimit && !source.includes('@/data/site/pages')) {
+    if (architecture?.status === "standard") {
+        for (const forbiddenFile of FORBIDDEN_STANDARD_FILES) {
+            if (!existsSync(join(options.root, forbiddenFile.path)))
+                continue;
             issues.push({
-                severity: architecture?.status === 'legacy-exception' ? 'legacy-accepted' : 'warning',
-                code: 'large-route-file',
-                detail: `Route file has ${lineCount} lines and appears to own page content instead of delegating to src/data/page models.`,
-                path: filePath,
+                severity: "error",
+                code: forbiddenFile.code,
+                detail: `${forbiddenFile.path} is a legacy or mixed-boundary file outside the Brandlab standard architecture.`,
+                path: forbiddenFile.path,
             });
         }
-        if (CONTENT_ARRAY_PATTERN.test(source)) {
+        for (const requiredFile of REQUIRED_STANDARD_FILES) {
+            if (existsSync(join(options.root, requiredFile.path)))
+                continue;
             issues.push({
-                severity: architecture?.status === 'legacy-exception' ? 'legacy-accepted' : 'warning',
-                code: 'embedded-route-content-array',
-                detail: 'Route file declares customer-facing FAQ, testimonial, feature, or process arrays instead of importing page data.',
-                path: filePath,
+                severity: "error",
+                code: requiredFile.code,
+                detail: `Brandlab standard projects must include ${requiredFile.path}.`,
+                path: requiredFile.path,
+            });
+        }
+        for (const relativePath of REQUIRED_STANDARD_TEST_FILES) {
+            if (existsSync(join(options.root, relativePath)))
+                continue;
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-required-test",
+                detail: `${relativePath} is missing from the Brandlab standard test contract.`,
+                path: relativePath,
             });
         }
+        for (const alternative of REQUIRED_ALTERNATIVE_TEST_FILES) {
+            if (alternative.paths.some((relativePath) => existsSync(join(options.root, relativePath)))) {
+                continue;
+            }
+            issues.push({
+                severity: "error",
+                code: alternative.code,
+                detail: alternative.detail,
+            });
+        }
+        for (const forbiddenDirectory of FORBIDDEN_STANDARD_DIRECTORIES) {
+            const directoryPath = join(options.root, forbiddenDirectory.path);
+            if (!existsSync(directoryPath) || !statSync(directoryPath).isDirectory())
+                continue;
+            issues.push({
+                severity: "error",
+                code: forbiddenDirectory.code,
+                detail: `${forbiddenDirectory.path} is a legacy or project-local directory outside the Brandlab standard architecture.`,
+                path: forbiddenDirectory.path,
+            });
+        }
+        for (const fileName of listImmediateFiles(join(options.root, "src/data"))
+            .filter((name) => /\.(?:ts|tsx|js|jsx)$/.test(name))
+            .filter((name) => name !== "index.ts")) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-top-level-data-file",
+                detail: `src/data/${fileName} is a top-level data file. Standard projects keep content in owned data families.`,
+                path: `src/data/${fileName}`,
+            });
+        }
+        for (const file of walkAllFiles(join(options.root, "src/data"))) {
+            if (!/\.(?:ts|tsx|js|jsx)$/.test(file))
+                continue;
+            const relativePath = relative(options.root, file)
+                .split(/[/\\]/)
+                .join("/");
+            const source = readFileSync(file, "utf8");
+            if (hasDataValueComponentImport(source) || hasDataIconImport(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-data-component-import",
+                    detail: `${relativePath} imports render/component dependencies from data. Standard data modules must expose plain page models and leave component selection to templates.`,
+                    path: relativePath,
+                });
+            }
+            if (/export\s+(?:const|let|var)\s+metadata\b|export\s+(?:async\s+)?function\s+generateMetadata\b/.test(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-data-metadata-export",
+                    detail: `${relativePath} exports Next.js metadata from data. Standard data modules may provide SEO records, but route files own the Next.js metadata export.`,
+                    path: relativePath,
+                });
+            }
+            if (!isAllowedRichDataContent(relativePath) &&
+                hasDataRenderFunction(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-data-render-function",
+                    detail: `${relativePath} exposes render functions or React return types from data. Standard data modules should not own page rendering.`,
+                    path: relativePath,
+                });
+            }
+            if (!isAllowedRichDataContent(relativePath) &&
+                hasDataJsxRendering(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-data-rendering-file",
+                    detail: `${relativePath} is JSX-rendering data. Standard projects keep reusable rendering in src/components/templates and plain data in src/data.`,
+                    path: relativePath,
+                });
+            }
+        }
+        for (const file of walkAllFiles(join(options.root, "src/components"))) {
+            if (!/\.(?:ts|tsx|js|jsx)$/.test(file))
+                continue;
+            const relativePath = relative(options.root, file)
+                .split(/[/\\]/)
+                .join("/");
+            const source = readFileSync(file, "utf8");
+            const lineCount = source.split(/\r?\n/).length;
+            const componentOwnedContentChars = countRouteOwnedContentChars(source);
+            const visibleCopyMatches = componentOwnedVisibleCopyPropertyMatches(source);
+            const isComponentCopyOwnershipRoot = COMPONENT_COPY_OWNERSHIP_ROOTS.some((root) => relativePath.startsWith(root));
+            if ((relativePath.startsWith("src/components/templates/") ||
+                relativePath.startsWith("src/components/sections/")) &&
+                /\bSchemaScript\b|\bcreateSchema(?:Graph)?\b|\bschemas\./.test(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-schema-ownership",
+                    detail: `${relativePath} emits or builds JSON-LD from a component/template module. Standard schema emission belongs in src/app route files.`,
+                    path: relativePath,
+                });
+            }
+            if (relativePath.startsWith("src/components/templates/") ||
+                relativePath.startsWith("src/components/sections/")) {
+                const dataImports = componentValueDataImportMatches(source);
+                if (dataImports.length > 0) {
+                    issues.push({
+                        severity: "error",
+                        code: "brandlab-architecture-component-data-import",
+                        detail: `${relativePath} imports project data directly (${[...new Set(dataImports)].join(", ")}). Standard templates and sections must render props only; src/app routes or src/data page-model helpers own data selection.`,
+                        path: relativePath,
+                    });
+                }
+            }
+            if ((relativePath.startsWith("src/components/templates/") ||
+                relativePath.startsWith("src/components/sections/")) &&
+                hasComponentOwnedContentArray(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-owned-content-array",
+                    detail: `${relativePath} declares or inlines customer-facing content arrays. Standard components must receive FAQs, testimonials, features, process steps, and SEO copy from src/data page models.`,
+                    path: relativePath,
+                });
+            }
+            if ((relativePath.startsWith("src/components/templates/") ||
+                relativePath.startsWith("src/components/sections/")) &&
+                hasComponentExportedContentRecord(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-owned-content-record",
+                    detail: `${relativePath} exports a customer-facing content record from a component/template module. Standard components must receive page and section copy from src/data.`,
+                    path: relativePath,
+                });
+            }
+            if ((relativePath.startsWith("src/components/templates/") ||
+                relativePath.startsWith("src/components/sections/")) &&
+                componentOwnedContentChars > DEFAULT_COMPONENT_CONTENT_CHAR_LIMIT &&
+                !relativePath.startsWith("src/components/templates/LegalPageTemplate")) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-owned-page-copy",
+                    detail: `${relativePath} contains about ${componentOwnedContentChars} characters of customer-facing copy. Standard components and templates should render data-prop content, not own page copy.`,
+                    path: relativePath,
+                });
+            }
+            if (relativePath.startsWith("src/components/templates/") &&
+                lineCount > 900) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-monolithic-template",
+                    detail: `${relativePath} has ${lineCount} lines. Standard templates should stay focused and delegate page content to src/data and smaller presentational sections.`,
+                    path: relativePath,
+                });
+            }
+            if (isComponentCopyOwnershipRoot && visibleCopyMatches.length > 0) {
+                const propertyNames = [
+                    ...new Set(visibleCopyMatches.map((match) => match.propertyName)),
+                ].sort();
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-owned-visible-copy-property",
+                    detail: `${relativePath} owns customer-facing copy in component properties: ${propertyNames.join(", ")}. Standard components must receive finished copy from src/data page models or site layout data.`,
+                    path: relativePath,
+                });
+            }
+            if (relativePath.startsWith("src/components/templates/pageModels/")) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-page-model",
+                    detail: `${relativePath} keeps route/page models inside components. Standard page models and route-family content belong under src/data.`,
+                    path: relativePath,
+                });
+            }
+            if (relativePath.startsWith("src/components/templates/pages/")) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-page-module",
+                    detail: `${relativePath} is a route-owned page module inside components. Standard projects keep route files in src/app, page data in src/data, and reusable templates directly under src/components/templates.`,
+                    fix: "Move page-specific content and SEO records into src/data/site/pages, compose one-off static pages directly in the matching src/app route, and keep src/components/templates for dynamic route families or templates shared by multiple routes.",
+                    path: relativePath,
+                });
+            }
+            if (relativePath.startsWith("src/components/templates/staticPages/")) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-static-page",
+                    detail: `${relativePath} keeps a static page module inside components. Standard projects keep route ownership in src/app and page models in src/data.`,
+                    fix: "Move static page model data into src/data/site/pages and compose the one-off static page directly in the matching src/app route. Keep src/components/templates for dynamic route families or templates shared by multiple routes.",
+                    path: relativePath,
+                });
+            }
+            if (hasPageMetadataExport(source) || hasMetadataBuilderUsage(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-metadata-ownership",
+                    detail: `${relativePath} owns page metadata from a component module. Standard metadata values belong in src/data and Next.js metadata exports belong in src/app routes.`,
+                    path: relativePath,
+                });
+            }
+            if (hasMetadataExport(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-component-metadata-export",
+                    detail: `${relativePath} exports Next.js metadata from a component module. Metadata exports must stay in src/app route files.`,
+                    path: relativePath,
+                });
+            }
+            if (relativePath.startsWith("src/components/templates/") &&
+                hasUseClientDirective(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-client-template",
+                    detail: `${relativePath} is a client component template. Standard templates must be server components by default, with interactivity isolated to leaf components.`,
+                    path: relativePath,
+                });
+            }
+            if (relativePath.startsWith("src/components/templates/") &&
+                /\bmetaTitle\b|\bmetaDescription\b|\bmetaKeywords\b/.test(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-template-seo-props",
+                    detail: `${relativePath} still declares page metadata props on a reusable template component.`,
+                    path: relativePath,
+                });
+            }
+            if (relativePath.startsWith("src/components/ui/") &&
+                /\bSchemaScript\b/.test(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-generic-ui-schema-script",
+                    detail: `${relativePath} emits schema from a generic UI component. Standard JSON-LD emission belongs at the route/template boundary, not reusable UI widgets.`,
+                    path: relativePath,
+                });
+            }
+            if (relativePath === "src/components/contact/QuoteModalContext.tsx") {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-contact-modal-context",
+                    detail: "src/components/contact/QuoteModalContext.tsx is a project-local modal context wrapper outside the standard contact component entrypoint.",
+                    path: relativePath,
+                });
+            }
+            if (relativePath === "src/components/layout/ThemeProvider.tsx") {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-client-theme-provider",
+                    detail: "src/components/layout/ThemeProvider.tsx adds a site-wide client provider for static theme values.",
+                    path: relativePath,
+                });
+            }
+        }
+        for (const file of walkAllFiles(join(options.root, "src/lib/content"))) {
+            if (!/\.(?:ts|tsx|js|jsx)$/.test(file))
+                continue;
+            const relativePath = relative(options.root, file)
+                .split(/[/\\]/)
+                .join("/");
+            const source = readFileSync(file, "utf8");
+            if (relativePath.startsWith("src/lib/content/pageModels/")) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-content-page-model",
+                    detail: `${relativePath} keeps page models in src/lib/content. Standard page models and route-family content belong under src/data.`,
+                    path: relativePath,
+                });
+            }
+            if (/\.(?:tsx|jsx)$/.test(relativePath)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-content-jsx-file",
+                    detail: `${relativePath} is a JSX content helper. Standard src/lib/content modules must be pure TypeScript helpers, not rendering modules.`,
+                    path: relativePath,
+                });
+            }
+            if (hasDataValueComponentImport(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-content-component-import",
+                    detail: `${relativePath} imports component dependencies from the content helper layer.`,
+                    path: relativePath,
+                });
+            }
+            if (hasPageMetadataExport(source) ||
+                hasMetadataBuilderUsage(source) ||
+                hasMetadataExport(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-content-metadata-ownership",
+                    detail: `${relativePath} owns page metadata from src/lib/content. Standard metadata records belong in src/data and Next.js metadata exports belong in src/app routes.`,
+                    path: relativePath,
+                });
+            }
+            if (hasDataRenderFunction(source) || hasDataJsxRendering(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-content-rendering",
+                    detail: `${relativePath} owns rendering from src/lib/content. Standard content helpers must not expose React nodes, JSX, or render functions.`,
+                    path: relativePath,
+                });
+            }
+        }
+        for (const file of walkAllFiles(join(options.root, "src/app"))) {
+            if (!/\/page\.(?:ts|tsx|js|jsx)$/.test(file.split(/[/\\]/).join("/")))
+                continue;
+            const relativePath = relative(options.root, file)
+                .split(/[/\\]/)
+                .join("/");
+            const source = readFileSync(file, "utf8");
+            if (hasRoutePageModuleReexport(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-route-page-module-reexport",
+                    detail: `${relativePath} re-exports a page module from components or content helpers instead of owning the route boundary.`,
+                    path: relativePath,
+                });
+            }
+            const directComponentImports = [
+                ...source.matchAll(/from\s+['"](@\/components\/(?:sections|contact|ui)\/[^'"]+)['"]/g),
+            ].map((match) => match[1]);
+            if (appRouteFileIsDynamic(relativePath) && directComponentImports.length > 0) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-route-direct-component-composition",
+                    detail: `${relativePath} imports section, contact, or UI components directly: ${directComponentImports.join(", ")}.`,
+                    path: relativePath,
+                });
+            }
+            const staticMdxImports = [
+                ...source.matchAll(/from\s+['"](@\/content\/blog\/[^'"]+\.mdx)['"]/g),
+            ].map((match) => match[1]);
+            if (staticMdxImports.length > 0) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-static-mdx-route-import",
+                    detail: `${relativePath} imports MDX article files one-by-one: ${staticMdxImports.join(", ")}.`,
+                    path: relativePath,
+                });
+            }
+            if (/from\s+['"]@\/lib\/seo\/schema['"]/.test(source) &&
+                /\b(createSchema|createSchemaGraph|build[A-Z]\w*Schema|buildBreadcrumbListSchema)\b/.test(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-route-schema-primitives",
+                    detail: `${relativePath} imports low-level schema primitives from the route-facing schema barrel.`,
+                    path: relativePath,
+                });
+            }
+        }
+        const hasBlogRoute = existsSync(join(options.root, "src/app/blog")) ||
+            existsSync(join(options.root, "src/data/blog")) ||
+            existsSync(join(options.root, "src/data/blogPosts.ts"));
+        if (hasBlogRoute && !existsSync(join(options.root, "src/content/blog"))) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-blog-content-source",
+                detail: "Blog content is not owned under src/content/blog. Standard Brandlab projects keep article body content in MDX and metadata/page models in src/data/blog.",
+                path: "src/content/blog",
+            });
+        }
+        const metadataSourcePath = join(options.root, "src/lib/seo/metadata.ts");
+        const metadataSource = existsSync(metadataSourcePath)
+            ? readFileSync(metadataSourcePath, "utf8")
+            : "";
+        if (metadataSource &&
+            !/\bconst\s+\{[\s\S]*resolvedTitle[\s\S]*\.\.\.metadata[\s\S]*\}\s*=\s*buildSeoMetadata\s*\(/.test(metadataSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-metadata-wrapper-contract",
+                detail: "src/lib/seo/metadata.ts does not follow the standard buildSeoMetadata delegation wrapper pattern.",
+                path: "src/lib/seo/metadata.ts",
+            });
+        }
+        if (metadataSource &&
+            !/title\s*:\s*\{\s*absolute\s*:\s*resolvedTitle\s*\}/.test(metadataSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-metadata-absolute-title",
+                detail: "src/lib/seo/metadata.ts does not force the final resolved title into title.absolute.",
+                path: "src/lib/seo/metadata.ts",
+            });
+        }
+        for (const [code, pattern, detail] of [
+            [
+                "brandlab-architecture-metadata-business-config-brand",
+                /businessConfig\.company\.name/,
+                "src/lib/seo/metadata.ts does not source the Brandlab title brand from businessConfig.company.name.",
+            ],
+            [
+                "brandlab-architecture-metadata-path-validation",
+                /normalizePath\s*\(\s*pathname\s*,\s*\{\s*validate\s*:\s*true\s*\}\s*\)/,
+                "src/lib/seo/metadata.ts does not validate canonical pathnames before passing them into metadata/OG helpers.",
+            ],
+        ]) {
+            if (!metadataSource || pattern.test(metadataSource))
+                continue;
+            issues.push({
+                severity: "error",
+                code,
+                detail,
+                path: "src/lib/seo/metadata.ts",
+            });
+        }
+        if (/\bkeywords\?\s*:\s*string\s*\|\s*string\[\]/.test(metadataSource) ||
+            /\bkeywordList\b/.test(metadataSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-metadata-keyword-contract",
+                detail: "src/lib/seo/metadata.ts accepts comma-separated keyword strings or keeps a local keywordList compatibility conversion.",
+                path: "src/lib/seo/metadata.ts",
+            });
+        }
+        for (const helperName of [
+            "generateMetadata",
+            "generatePageMetadata",
+            "generateLocationMetadata",
+        ]) {
+            if (!new RegExp(`export\\s+function\\s+${helperName}\\b`).test(metadataSource))
+                continue;
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-legacy-metadata-helper",
+                detail: `src/lib/seo/metadata.ts exports ${helperName}, a legacy compatibility helper outside the standard buildMetadata wrapper contract.`,
+                path: "src/lib/seo/metadata.ts",
+            });
+        }
+        const breadcrumbsSourcePath = join(options.root, "src/lib/seo/breadcrumbs.ts");
+        const breadcrumbsSource = existsSync(breadcrumbsSourcePath)
+            ? readFileSync(breadcrumbsSourcePath, "utf8")
+            : "";
+        if (/export\s+function\s+generateBreadcrumbs\b/.test(breadcrumbsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-legacy-breadcrumb-helper",
+                detail: "src/lib/seo/breadcrumbs.ts exports generateBreadcrumbs, a legacy project-local helper name outside the Brandlab breadcrumb contract.",
+                path: "src/lib/seo/breadcrumbs.ts",
+            });
+        }
+        const routeLabelsSourcePath = join(options.root, "src/lib/seo/routeLabels.ts");
+        const routeLabelsSource = existsSync(routeLabelsSourcePath)
+            ? readFileSync(routeLabelsSourcePath, "utf8")
+            : "";
+        if (routeLabelsSource &&
+            !/export\s+function\s+getRouteLabel\b/.test(routeLabelsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-route-label-api",
+                detail: "src/lib/seo/routeLabels.ts does not expose the standard getRouteLabel(segment, { silent }) API.",
+                path: "src/lib/seo/routeLabels.ts",
+            });
+        }
+        if (routeLabelsSource &&
+            existsSync(join(options.root, "src/app/thank-you/page.tsx")) &&
+            !routeLabelsSource.includes("thank-you")) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-route-label-coverage",
+                detail: "src/lib/seo/routeLabels.ts is missing the thank-you static route label.",
+                path: "src/lib/seo/routeLabels.ts",
+            });
+        }
+        for (const file of walkAllFiles(join(options.root, "src/lib/seo/schema"))) {
+            if (!/\.(?:ts|tsx|js|jsx)$/.test(file))
+                continue;
+            const source = readFileSync(file, "utf8");
+            const relativePath = relative(options.root, file)
+                .split(/[/\\]/)
+                .join("/");
+            if (relativePath !== "src/lib/seo/schema/graph.ts" &&
+                /['"]@id['"]\s*:\s*`?\$\{?siteConfig\.url/.test(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-inline-schema-id",
+                    detail: `${relativePath} builds schema @id values inline from siteConfig.url. Standard schema IDs must use shared helper functions so @id anchors stay stable across projects.`,
+                    path: relativePath,
+                });
+            }
+            if (/\baggregateRating\b|\bAggregateRating\b|['"]Review['"]|\breviewRating\b|\breview\s*:/.test(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-self-serving-review-schema",
+                    detail: `${relativePath} emits Review or AggregateRating schema from a local service-business site. Google treats business-controlled LocalBusiness/Organization review markup as self-serving and ineligible for review snippets.`,
+                    fix: "Keep customer testimonials/reviews as visible page content only. Do not emit Review or AggregateRating JSON-LD for the client's own local business or services.",
+                    path: relativePath,
+                });
+            }
+            if (!/export\s+function\s+createSchema(?:Graph)?\b/.test(source))
+                continue;
+            if (source.includes("@brandlab-digital/site-core/schema"))
+                continue;
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-local-schema-graph-helper",
+                detail: `${relativePath} defines local createSchema/createSchemaGraph helpers. Standard projects must delegate schema context, graph filtering, and @id helpers to @brandlab-digital/site-core.`,
+                path: relativePath,
+            });
+        }
+        const seoIndexSourcePath = join(options.root, "src/lib/seo/index.ts");
+        const seoIndexSource = existsSync(seoIndexSourcePath)
+            ? readFileSync(seoIndexSourcePath, "utf8")
+            : "";
+        for (const requiredExport of [
+            "SchemaScript",
+            "schemas",
+            "sanitizeJsonLd",
+        ]) {
+            if (seoIndexSource.includes(requiredExport))
+                continue;
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-seo-barrel-contract",
+                detail: `src/lib/seo/index.ts does not expose ${requiredExport}. Standard projects should have the same SEO barrel surface for routes and tests.`,
+                path: "src/lib/seo/index.ts",
+            });
+        }
+        const schemaIndexPath = join(options.root, "src/lib/seo/schema/index.ts");
+        const schemaIndexSource = existsSync(schemaIndexPath)
+            ? readFileSync(schemaIndexPath, "utf8")
+            : "";
+        if (/export\s+\*\s+from\s+['"]\.\/(?:graph|marketing|serviceLocation|blog)['"]/.test(schemaIndexSource) ||
+            /export\s+\{[^}]*\b(?:createSchema|createSchemaGraph|build[A-Z]\w*Schema|buildBreadcrumbListSchema)\b[^}]*\}\s+from\s+['"]\.\/(?:graph|marketing|serviceLocation|blog)['"]/.test(schemaIndexSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-schema-barrel-primitives",
+                detail: "src/lib/seo/schema/index.ts exposes low-level schema primitives or builder modules through the route-facing schema barrel.",
+                path: "src/lib/seo/schema/index.ts",
+            });
+        }
+        const schemaScriptSourcePath = join(options.root, "src/lib/seo/schema/SchemaScript.tsx");
+        const schemaScriptSource = existsSync(schemaScriptSourcePath)
+            ? readFileSync(schemaScriptSourcePath, "utf8")
+            : "";
+        if (schemaScriptSource &&
+            !/export\s+\{[\s\S]*SchemaScript[\s\S]*\}\s+from\s+['"]@brandlab-digital\/site-next\/schema['"]/.test(schemaScriptSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-schema-script-wrapper-contract",
+                detail: "src/lib/seo/schema/SchemaScript.tsx wraps or renames the shared SchemaScript implementation instead of directly re-exporting it.",
+                path: "src/lib/seo/schema/SchemaScript.tsx",
+            });
+        }
+        const actionsPath = join(options.root, "src/lib/contact/actions.ts");
+        const actionsSource = existsSync(actionsPath)
+            ? readFileSync(actionsPath, "utf8")
+            : "";
+        const schemaPath = join(options.root, "src/lib/contact/schema.ts");
+        const schemaSource = existsSync(schemaPath)
+            ? readFileSync(schemaPath, "utf8")
+            : "";
+        const contactClientPath = join(options.root, "src/lib/contact/client.ts");
+        const contactClientSource = existsSync(contactClientPath)
+            ? readFileSync(contactClientPath, "utf8")
+            : "";
+        const contactComponentPath = join(options.root, "src/components/contact/ContactForm.tsx");
+        const contactComponentSource = existsSync(contactComponentPath)
+            ? readFileSync(contactComponentPath, "utf8")
+            : "";
+        const contactEmailPath = join(options.root, "src/lib/contact/ContactFormEmail.tsx");
+        const contactEmailSource = existsSync(contactEmailPath)
+            ? readFileSync(contactEmailPath, "utf8")
+            : "";
+        const serverEnvPath = join(options.root, "src/config/server-env.ts");
+        const serverEnvSource = existsSync(serverEnvPath)
+            ? readFileSync(serverEnvPath, "utf8")
+            : "";
+        for (const fileName of listImmediateFiles(join(options.root, "src/lib/contact"))) {
+            if (!/\.(?:ts|tsx|js|jsx)$/.test(fileName))
+                continue;
+            if (STANDARD_CONTACT_MODULE_FILES.has(fileName))
+                continue;
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-module-contract",
+                detail: `src/lib/contact/${fileName} is outside the standard contact module surface. Project-local compatibility modules hide client/server and delivery-contract drift.`,
+                path: `src/lib/contact/${fileName}`,
+            });
+        }
+        if (/useContactForm|submitContactForm|trackContactFormSubmission|initialContactFormState/.test(contactClientSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-client-state-wrapper",
+                detail: "src/lib/contact/client.ts owns form submission or analytics behavior instead of remaining a thin client-safe contact helper entrypoint.",
+                path: "src/lib/contact/client.ts",
+            });
+        }
+        if (/name\s*=\s*["']service["']|readFormString\s*\(\s*formData\s*,\s*["']service["']\s*\)|\bservice\s*:\s*z\./.test(contactComponentSource + schemaSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-service-field-drift",
+                detail: "Contact form code still exposes or accepts the legacy service hidden field instead of the standard serviceInterest field.",
+                path: "src/lib/contact/schema.ts",
+            });
+        }
+        const contactConstantsPath = join(options.root, "src/lib/contact/constants.ts");
+        const contactConstantsSource = existsSync(contactConstantsPath)
+            ? readFileSync(contactConstantsPath, "utf8")
+            : "";
+        if (/SERENITY_CONTACT_ATTACHMENT_POLICY|\b(?!DEFAULT_)[A-Z][A-Z0-9_]*_CONTACT_ATTACHMENT_POLICY\b/.test(actionsSource +
+            schemaSource +
+            contactComponentSource +
+            contactConstantsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-project-policy-alias",
+                detail: "Contact attachment policy is exported through a project-specific policy alias.",
+                path: "src/lib/contact/constants.ts",
+            });
+        }
+        if (/phone\s*:\s*40\b|max\s*\(\s*40\s*,\s*['"]Phone number is too long/.test(schemaSource + contactConstantsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-phone-limit",
+                detail: "Contact phone validation still allows the older 40-character phone field limit.",
+                path: "src/lib/contact/constants.ts",
+            });
+        }
+        if (/message\s*:\s*z\.[\s\S]*?\.optional\s*\(|message\s*:\s*z\.[\s\S]*?\.default\s*\(/.test(schemaSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-message-required",
+                detail: "Contact message validation is optional or defaults to an empty value.",
+                path: "src/lib/contact/schema.ts",
+            });
+        }
+        if (!/contactEmails\s*:\s*z\.array\s*\(\s*z\.string\s*\(\s*\)\.email\s*\(\s*\)\s*\)\.nonempty\s*\(\s*\)/.test(serverEnvSource) ||
+            !/contactEmail\s*:\s*contactEmails\s*\[\s*0\s*\]/.test(serverEnvSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-recipient-contract",
+                detail: "src/config/server-env.ts does not expose the standard contactEmails[] recipient list with a primary contactEmail alias.",
+                path: "src/config/server-env.ts",
+            });
+        }
+        for (const [pattern, detail] of [
+            [
+                /useActionState/,
+                "ContactForm must submit through useActionState so the Server Action contract is the only submission path.",
+            ],
+            [
+                /submitContactForm/,
+                "ContactForm must call the standard submitContactForm Server Action.",
+            ],
+            [
+                /useContactAttachments/,
+                "ContactForm must use the standard attachment hook.",
+            ],
+            [
+                /shouldTrackLead\s*!==\s*false/,
+                "ContactForm must suppress analytics for fake-success bot-trap responses.",
+            ],
+            [
+                /trackContactFormSubmission/,
+                "ContactForm must fire the canonical contact_form analytics event after real success.",
+            ],
+            [
+                /loadedAt/,
+                "ContactForm must submit the loadedAt timestamp used by the server-side time trap.",
+            ],
+        ]) {
+            if (pattern.test(contactComponentSource))
+                continue;
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-component-contract",
+                detail,
+                path: "src/components/contact/ContactForm.tsx",
+            });
+        }
+        for (const requirement of [
+            [
+                /ContactFormState/,
+                "Contact actions must use the shared ContactFormState-style result contract.",
+            ],
+            [
+                /export\s+async\s+function\s+submitContactForm\b/,
+                "Contact actions must export submitContactForm as the Server Action entrypoint.",
+            ],
+            [
+                /shouldTrackLead\s*:\s*false|getFakeContactSuccessResponse/,
+                "Contact actions must suppress lead tracking for fake bot-trap success.",
+            ],
+            [
+                /buildMailtoFallback/,
+                "Contact actions must provide a populated mailto fallback on delivery failure.",
+            ],
+            [
+                /checkRateLimit/,
+                "Contact actions must use the standard contact rate limiter.",
+            ],
+            [
+                /parseContactFormData/,
+                "Contact actions must parse and validate submitted form data through src/lib/contact/schema.ts.",
+            ],
+            [
+                /initialLandingPath/,
+                "Contact actions must include initial landing path in the notification and success result.",
+            ],
+            [
+                /initialLandingUrl/,
+                "Contact actions must include initial landing URL in the notification payload.",
+            ],
+            [
+                /initialReferrer\s*\|\|\s*input\.referrer|initialReferrer/,
+                "Contact actions must prefer initial referrer when resolving traffic source attribution.",
+            ],
+            [
+                /resolveAdClickIds/,
+                "Contact actions must capture Google Ads click IDs from query params or page URL.",
+            ],
+        ]) {
+            const [pattern, detail] = requirement;
+            if (pattern.test(actionsSource))
+                continue;
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-action-contract",
+                detail,
+                path: "src/lib/contact/actions.ts",
+            });
+        }
+        for (const requirement of [
+            [
+                /\bz\.object\s*\(/,
+                "Contact validation must be backed by a Zod object schema.",
+            ],
+            [
+                /isValidAustralianPhoneNumber/,
+                "Contact phone validation must use the shared Australian phone helper.",
+            ],
+            [
+                /fieldErrors/,
+                "Contact validation must return fieldErrors for visible fields.",
+            ],
+            [
+                /\bsuccess\s*:\s*true\b|\bsuccess\s*:\s*false\b/,
+                "parseContactFormData must use the shared success true/false parse result shape.",
+            ],
+            [
+                /contactFieldLimits/,
+                "Contact validation must apply the standard field-length limits.",
+            ],
+            [
+                /initialLandingPath/,
+                "Contact validation must preserve the initial landing path for attribution.",
+            ],
+            [
+                /initialLandingUrl/,
+                "Contact validation must preserve the initial landing URL for attribution.",
+            ],
+            [
+                /initialReferrer/,
+                "Contact validation must preserve the initial referrer for attribution.",
+            ],
+        ]) {
+            const [pattern, detail] = requirement;
+            if (pattern.test(schemaSource))
+                continue;
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-schema-contract",
+                detail,
+                path: "src/lib/contact/schema.ts",
+            });
+        }
+        if (/export\s+async\s+function\s+submitContactFormData\b/.test(actionsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-compat-action",
+                detail: "src/lib/contact/actions.ts exports submitContactFormData, an API-style compatibility action outside the standard Server Action contract.",
+                path: "src/lib/contact/actions.ts",
+            });
+        }
+        if (/to\s*:\s*serverEnv\.contactEmail\b/.test(actionsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-single-recipient-send",
+                detail: "src/lib/contact/actions.ts sends Resend notifications to serverEnv.contactEmail instead of the standard contactEmails[] recipient list.",
+                path: "src/lib/contact/actions.ts",
+            });
+        }
+        if (/mailto:\$\{serverEnv\.contactEmail\}/.test(actionsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-single-recipient-mailto",
+                detail: "src/lib/contact/actions.ts builds the fallback mailto URL from only serverEnv.contactEmail.",
+                path: "src/lib/contact/actions.ts",
+            });
+        }
+        if (/verifyRecaptcha|RECAPTCHA_SECRET_KEY|recaptchaToken/i.test(actionsSource + contactComponentSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-recaptcha-drift",
+                detail: "Contact form reCAPTCHA handling is implemented as project-local behavior instead of the shared contact contract.",
+                path: "src/lib/contact/actions.ts",
+            });
+        }
+        if (contactEmailSource &&
+            !/@react-email\/components/.test(contactEmailSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-email-react-email",
+                detail: "src/lib/contact/ContactFormEmail.tsx does not use the standard React Email component template.",
+                path: "src/lib/contact/ContactFormEmail.tsx",
+            });
+        }
+        if (/function\s+escapeHtml\b|buildContactFormEmailHtml\b/.test(contactEmailSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-email-string-html",
+                detail: "src/lib/contact/ContactFormEmail.tsx still owns string-built email HTML or manual escaping.",
+                path: "src/lib/contact/ContactFormEmail.tsx",
+            });
+        }
+        for (const requirement of CONTACT_EMAIL_CONTRACT_REQUIREMENTS) {
+            if (contactEmailSource && !requirement.pattern.test(contactEmailSource)) {
+                issues.push({
+                    severity: "error",
+                    code: requirement.code,
+                    detail: requirement.detail,
+                    path: "src/lib/contact/ContactFormEmail.tsx",
+                });
+            }
+        }
+        if (/message\s*:\s*error\s+instanceof\s+Error\s*&&\s*error\.message/.test(actionsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-raw-error-message",
+                detail: "src/lib/contact/actions.ts can expose raw delivery errors to the submitted form response.",
+                path: "src/lib/contact/actions.ts",
+            });
+        }
+        const analyticsIndexPath = join(options.root, "src/lib/analytics/index.tsx");
+        const analyticsIndexSource = existsSync(analyticsIndexPath)
+            ? readFileSync(analyticsIndexPath, "utf8")
+            : "";
+        if (analyticsIndexSource) {
+            for (const [code, pattern, detail] of [
+                [
+                    "brandlab-architecture-analytics-lead-service-group",
+                    /lead_service_group/,
+                    "Contact form analytics does not include the standard lead_service_group payload field.",
+                ],
+                [
+                    "brandlab-architecture-analytics-web-vital-delta",
+                    /metric_delta/,
+                    "Web vital analytics does not send metric_delta in the standard payload.",
+                ],
+                [
+                    "brandlab-architecture-analytics-navigation-type",
+                    /navigation_type/,
+                    "Web vital analytics does not send navigation_type in the standard payload.",
+                ],
+                [
+                    "brandlab-architecture-analytics-web-vital-label",
+                    /event_label\s*:\s*metric\.name/,
+                    "Web vital analytics does not use metric.name as the standard event_label.",
+                ],
+            ]) {
+                if (pattern.test(analyticsIndexSource))
+                    continue;
+                issues.push({
+                    severity: "error",
+                    code,
+                    detail,
+                    path: "src/lib/analytics/index.tsx",
+                });
+            }
+            if (/\bhasImages\b|\btransactionId\b|export\s+function\s+trackContactForm\b/.test(analyticsIndexSource)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-analytics-compat-fields",
+                    detail: "src/lib/analytics/index.tsx still contains legacy contact analytics field names or compatibility exports.",
+                    path: "src/lib/analytics/index.tsx",
+                });
+            }
+        }
+        const googleTagPath = join(options.root, "src/components/analytics/GoogleTag.tsx");
+        const googleTagSource = existsSync(googleTagPath)
+            ? readFileSync(googleTagPath, "utf8")
+            : "";
+        if (googleTagSource) {
+            if (!/normalizeGoogleAdsConversionId/.test(googleTagSource) ||
+                !/@brandlab-digital\/site-core\/analytics/.test(googleTagSource)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-google-tag-shared-ads-id",
+                    detail: "GoogleTag normalizes Google Ads conversion IDs locally instead of using the shared analytics helper.",
+                    path: "src/components/analytics/GoogleTag.tsx",
+                });
+            }
+            if (!/id\s*=\s*['"]gtag-init['"]/.test(googleTagSource)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-google-tag-script-id",
+                    detail: "GoogleTag does not use the standard gtag-init script id.",
+                    path: "src/components/analytics/GoogleTag.tsx",
+                });
+            }
+        }
+        const coreWebVitalsPath = join(options.root, "src/components/analytics/CoreWebVitalsReporter.tsx");
+        const coreWebVitalsSource = existsSync(coreWebVitalsPath)
+            ? readFileSync(coreWebVitalsPath, "utf8")
+            : "";
+        if (coreWebVitalsSource) {
+            for (const [pattern, detail] of [
+                [
+                    /usePathname/,
+                    "CoreWebVitalsReporter must include the current pathname in metric payloads.",
+                ],
+                [
+                    /delta\s*:/,
+                    "CoreWebVitalsReporter must pass metric.delta to trackWebVital.",
+                ],
+                [
+                    /navigationType\s*:/,
+                    "CoreWebVitalsReporter must pass metric.navigationType to trackWebVital.",
+                ],
+                [
+                    /pagePath\s*:/,
+                    "CoreWebVitalsReporter must pass pagePath to trackWebVital.",
+                ],
+            ]) {
+                if (pattern.test(coreWebVitalsSource))
+                    continue;
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-core-web-vitals-contract",
+                    detail,
+                    path: "src/components/analytics/CoreWebVitalsReporter.tsx",
+                });
+            }
+        }
+        const packageJsonPath = join(options.root, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+            if (packageJson.packageManager !== STANDARD_PACKAGE_MANAGER) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-package-manager-contract",
+                    detail: `package.json packageManager is "${packageJson.packageManager ?? "missing"}"; expected "${STANDARD_PACKAGE_MANAGER}".`,
+                    path: "package.json",
+                });
+            }
+            for (const [packageName, expectedVersion] of [
+                ["next", STANDARD_NEXT_BASELINE.nextVersion],
+                ["react", STANDARD_NEXT_BASELINE.reactVersion],
+                ["react-dom", STANDARD_NEXT_BASELINE.reactDomVersion],
+            ]) {
+                const installedVersion = getPackageVersion(packageJson, packageName);
+                if (installedVersion === expectedVersion && isExactVersionSpec(installedVersion))
+                    continue;
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-next-package-version",
+                    detail: `package.json installs ${packageName} as "${installedVersion ?? "missing"}"; expected exact "${expectedVersion}".`,
+                    path: "package.json",
+                });
+            }
+            if (packageJson.engines?.node !== STANDARD_NEXT_BASELINE.node) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-next-node-engine",
+                    detail: `package.json engines.node is "${packageJson.engines?.node ?? "missing"}"; expected "${STANDARD_NEXT_BASELINE.node}".`,
+                    path: "package.json",
+                });
+            }
+            const webpackScripts = Object.entries(packageJson.scripts ?? {})
+                .filter(([, script]) => typeof script === "string" && /--webpack/.test(script))
+                .map(([scriptName]) => scriptName);
+            if (webpackScripts.length > 0) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-next-webpack-script",
+                    detail: `package.json contains webpack fallback scripts: ${webpackScripts.join(", ")}.`,
+                    path: "package.json",
+                });
+            }
+            if (packageJson.scripts?.["analyze:bundle"] &&
+                packageJson.scripts["analyze:bundle"] !== STANDARD_NEXT_BASELINE.analyzeBundleScript) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-next-bundle-analysis-script",
+                    detail: `package.json analyze:bundle is "${packageJson.scripts["analyze:bundle"]}"; expected "${STANDARD_NEXT_BASELINE.analyzeBundleScript}".`,
+                    path: "package.json",
+                });
+            }
+        }
+        const tsconfigPath = join(options.root, "tsconfig.json");
+        if (existsSync(tsconfigPath)) {
+            const tsconfig = JSON.parse(readFileSync(tsconfigPath, "utf8"));
+            if (tsconfig.compilerOptions?.target !== STANDARD_TYPESCRIPT_TARGET) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-typescript-target",
+                    detail: `tsconfig.json compilerOptions.target is "${tsconfig.compilerOptions?.target ?? "missing"}"; expected "${STANDARD_TYPESCRIPT_TARGET}".`,
+                    path: "tsconfig.json",
+                });
+            }
+            if (tsconfig.compilerOptions?.tsBuildInfoFile !==
+                ".next/cache/tsconfig.tsbuildinfo") {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-typescript-build-info",
+                    detail: "tsconfig.json does not write incremental TypeScript build info under .next/cache.",
+                    path: "tsconfig.json",
+                });
+            }
+        }
+        const eslintConfigPath = join(options.root, "eslint.config.mjs");
+        if (!existsSync(eslintConfigPath)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-eslint-config-missing",
+                detail: "eslint.config.mjs is missing from the Brandlab standard tooling contract.",
+                path: "eslint.config.mjs",
+            });
+        }
+        else {
+            const eslintConfigSource = readFileSync(eslintConfigPath, "utf8");
+            for (const [code, pattern, detail] of [
+                [
+                    "brandlab-architecture-eslint-brandlab-plugin",
+                    /brandlab\.configs\.recommended/,
+                    "eslint.config.mjs does not enable @brandlab-digital/eslint-plugin recommended rules.",
+                ],
+                [
+                    "brandlab-architecture-eslint-hooks-rule",
+                    /['"]react-hooks\/rules-of-hooks['"]\s*:\s*['"]error['"]/,
+                    "eslint.config.mjs does not fail on React Rules of Hooks violations.",
+                ],
+                [
+                    "brandlab-architecture-eslint-hooks-deps",
+                    /['"]react-hooks\/exhaustive-deps['"]\s*:\s*['"]warn['"]/,
+                    "eslint.config.mjs does not warn on React hook dependency drift.",
+                ],
+                [
+                    "brandlab-architecture-eslint-next-link-rule",
+                    /['"]@next\/next\/no-html-link-for-pages['"]\s*:\s*['"]off['"]/,
+                    "eslint.config.mjs does not explicitly use the Brandlab no-html-link-for-pages setting.",
+                ],
+                [
+                    "brandlab-architecture-eslint-next-image-rule",
+                    /['"]@next\/next\/no-img-element['"]\s*:\s*['"]warn['"]/,
+                    "eslint.config.mjs does not explicitly warn on raw img elements.",
+                ],
+            ]) {
+                if (pattern.test(eslintConfigSource))
+                    continue;
+                issues.push({
+                    severity: "error",
+                    code,
+                    detail,
+                    path: "eslint.config.mjs",
+                });
+            }
+            for (const ignoredPattern of [
+                "*.config.js",
+                "*.config.mjs",
+                "*.config.ts",
+                "tsconfig.tsbuildinfo",
+            ]) {
+                if (!eslintConfigSource.includes(`'${ignoredPattern}'`) &&
+                    !eslintConfigSource.includes(`"${ignoredPattern}"`)) {
+                    continue;
+                }
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-eslint-ignore-contract",
+                    detail: `eslint.config.mjs ignores ${ignoredPattern}, which can hide standard tooling drift.`,
+                    path: "eslint.config.mjs",
+                });
+            }
+        }
+        const appSitemapPath = join(options.root, "src/app/sitemap.ts");
+        if (existsSync(appSitemapPath) &&
+            !/\bgetAllSitemapEntries\b/.test(readFileSync(appSitemapPath, "utf8"))) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-sitemap-entrypoint-contract",
+                detail: "src/app/sitemap.ts does not delegate to the standard getAllSitemapEntries sitemap aggregator.",
+                path: "src/app/sitemap.ts",
+            });
+        }
+        if (existsSync(join(options.root, "src/lib/seo/sitemaps/routes.ts"))) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-monolithic-sitemap-builder",
+                detail: "src/lib/seo/sitemaps/routes.ts is a monolithic sitemap builder. Standard projects keep sitemap ownership split by route family.",
+                path: "src/lib/seo/sitemaps/routes.ts",
+            });
+        }
+        const sitemapIndexPath = join(options.root, "src/lib/seo/sitemaps/index.ts");
+        const sitemapIndexSource = existsSync(sitemapIndexPath)
+            ? readFileSync(sitemapIndexPath, "utf8")
+            : "";
+        if (sitemapIndexSource &&
+            !/MetadataRoute\.Sitemap/.test(sitemapIndexSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-sitemap-metadata-route-type",
+                detail: "src/lib/seo/sitemaps/index.ts does not type the sitemap aggregator as MetadataRoute.Sitemap.",
+                path: "src/lib/seo/sitemaps/index.ts",
+            });
+        }
+        const sitemapConstantsPath = join(options.root, "src/lib/seo/sitemaps/constants.ts");
+        const sitemapConstantsSource = existsSync(sitemapConstantsPath)
+            ? readFileSync(sitemapConstantsPath, "utf8")
+            : "";
+        for (const requiredExport of [
+            "SITEMAP_PRIORITY",
+            "SITEMAP_FREQUENCY",
+            "STATIC_ROUTE_SITEMAP",
+        ]) {
+            if (sitemapConstantsSource.includes(requiredExport))
+                continue;
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-sitemap-local-constants",
+                detail: `src/lib/seo/sitemaps/constants.ts does not export ${requiredExport}.`,
+                path: "src/lib/seo/sitemaps/constants.ts",
+            });
+        }
+        for (const filePath of walkAllFiles(join(options.root, "src/lib/seo/sitemaps"))) {
+            if (!/[/\\]sitemap-[^/\\]+\.ts$/.test(filePath))
+                continue;
+            const source = readFileSync(filePath, "utf8");
+            const relativePath = relative(options.root, filePath)
+                .split(/[/\\]/)
+                .join("/");
+            if (!/MetadataRoute\.Sitemap/.test(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-sitemap-family-type",
+                    detail: `${relativePath} does not return MetadataRoute.Sitemap.`,
+                    path: relativePath,
+                });
+            }
+            if (/from\s+['"]@brandlab-digital\/site-core\/sitemaps['"]/.test(source)) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-sitemap-shared-constant-import",
+                    detail: `${relativePath} imports sitemap priority/frequency constants directly from the shared package.`,
+                    path: relativePath,
+                });
+            }
+        }
+        const instrumentationPath = join(options.root, "src/instrumentation-client.ts");
+        const instrumentationSource = existsSync(instrumentationPath)
+            ? readFileSync(instrumentationPath, "utf8")
+            : "";
+        if (!instrumentationSource) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-required-instrumentation-client",
+                detail: "src/instrumentation-client.ts is missing.",
+                path: "src/instrumentation-client.ts",
+            });
+        }
+        else {
+            for (const requirement of [
+                [
+                    /installPhoneClickListener\s+as\s+installBrandlabPhoneClickListener|installBrandlabPhoneClickListener/,
+                    "Phone click tracking should delegate to the shared installPhoneClickListener helper.",
+                ],
+                [
+                    /persistInitialLanding\s+as\s+persistBrandlabInitialLanding|persistBrandlabInitialLanding/,
+                    "Initial landing attribution should delegate to the shared persistInitialLanding helper.",
+                ],
+                [
+                    /siteConfig\.gaMeasurementId/,
+                    "Phone tracking installation should be gated by the configured GA measurement ID.",
+                ],
+                [
+                    /__brandlabPhoneCallTrackingInitialized/,
+                    "Phone tracking should use the standard global initialization flag.",
+                ],
+            ]) {
+                const [pattern, detail] = requirement;
+                if (pattern.test(instrumentationSource))
+                    continue;
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-instrumentation-contract",
+                    detail,
+                    path: "src/instrumentation-client.ts",
+                });
+            }
+        }
+        const nextConfigPath = join(options.root, "next.config.ts");
+        const nextConfigSource = existsSync(nextConfigPath)
+            ? readFileSync(nextConfigPath, "utf8")
+            : "";
+        const brandlabConfigPath = join(options.root, "brandlab.config.ts");
+        const brandlabConfigSource = existsSync(brandlabConfigPath)
+            ? readFileSync(brandlabConfigPath, "utf8")
+            : "";
+        const brandlabNextContract = parseBrandlabNextContract(brandlabConfigSource);
+        if (!brandlabNextContract) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-next-contract",
+                detail: "brandlab.config.ts does not declare the Brandlab Next Baseline 2026-07 next contract.",
+                path: "brandlab.config.ts",
+            });
+        }
+        else {
+            for (const [fieldName, expectedValue] of [
+                ["baseline", STANDARD_NEXT_BASELINE.baseline],
+                ["nextVersion", STANDARD_NEXT_BASELINE.nextVersion],
+                ["reactVersion", STANDARD_NEXT_BASELINE.reactVersion],
+                ["reactDomVersion", STANDARD_NEXT_BASELINE.reactDomVersion],
+                ["node", STANDARD_NEXT_BASELINE.node],
+                ["minimumNode", STANDARD_NEXT_BASELINE.minimumNode],
+                ["router", STANDARD_NEXT_BASELINE.router],
+                ["bundler", STANDARD_NEXT_BASELINE.bundler],
+            ]) {
+                if (brandlabNextContract[fieldName] === expectedValue)
+                    continue;
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-next-contract",
+                    detail: `brandlab.config.ts next.${fieldName} is "${brandlabNextContract[fieldName] ?? "missing"}"; expected "${expectedValue}".`,
+                    path: "brandlab.config.ts",
+                });
+            }
+            if (brandlabNextContract.cacheComponents !== STANDARD_NEXT_BASELINE.cacheComponents) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-next-cache-components",
+                    detail: "brandlab.config.ts enables cacheComponents outside the approved Brandlab pilot track.",
+                    path: "brandlab.config.ts",
+                });
+            }
+        }
+        const contactAttachmentsPath = join(options.root, "src/lib/contact/attachments.ts");
+        const contactAttachmentsSource = existsSync(contactAttachmentsPath)
+            ? readFileSync(contactAttachmentsPath, "utf8")
+            : "";
+        if (brandlabConfigSource.includes("contactAttachments") &&
+            !/serverActions\s*:\s*\{[\s\S]*bodySizeLimit\s*:\s*['"]20mb['"]/.test(nextConfigSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-next-server-action-body-limit",
+                detail: "next.config.ts does not set the standard 20mb Server Action body size for attachment-enabled contact forms.",
+                path: "next.config.ts",
+            });
+        }
+        if (brandlabConfigSource.includes("contactAttachments") &&
+            !/filenamePrefix\s*:\s*['"`][a-z0-9][a-z0-9-]{2,48}['"`]/.test(contactConstantsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-attachment-prefix",
+                detail: "Contact attachment policy does not define an explicit project-specific filenamePrefix.",
+                path: "src/lib/contact/constants.ts",
+            });
+        }
+        if (existsSync(join(options.root, "pages")) || existsSync(join(options.root, "src/pages"))) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-pages-router-directory",
+                detail: "Project contains pages/ or src/pages/. Brandlab Next Baseline is App Router only.",
+            });
+        }
+        for (const filePath of walkAllFiles(options.root)) {
+            if (!/\.(?:ts|tsx|js|jsx)$/.test(filePath))
+                continue;
+            const relativePath = relative(options.root, filePath).split(/[/\\]/).join("/");
+            if (relativePath.startsWith("node_modules/") ||
+                relativePath.startsWith(".next/") ||
+                relativePath.startsWith("dist/")) {
+                continue;
+            }
+            const source = readFileSync(filePath, "utf8");
+            const pagesRouterApiPatterns = [
+                ["next/head", /\bfrom\s+['"]next\/head['"]/],
+                ["getStaticProps", /\bgetStaticProps\b/],
+                ["getServerSideProps", /\bgetServerSideProps\b/],
+            ];
+            const pagesRouterApis = pagesRouterApiPatterns.filter(([, pattern]) => pattern.test(source));
+            if (pagesRouterApis.length > 0) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-pages-router-api",
+                    detail: `${relativePath} references Pages Router APIs: ${pagesRouterApis.map(([label]) => label).join(", ")}.`,
+                    path: relativePath,
+                });
+            }
+            const invalidQualities = [...new Set([...source.matchAll(/\bquality\s*=\s*\{?\s*(\d+)\s*\}?/g)]
+                    .map((match) => Number(match[1]))
+                    .filter((quality) => !STANDARD_NEXT_BASELINE.imageQualities.includes(quality)))].sort((a, b) => a - b);
+            if (invalidQualities.length > 0) {
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-next-image-quality",
+                    detail: `${relativePath} uses unsupported next/image quality values: ${invalidQualities.join(", ")}.`,
+                    path: relativePath,
+                });
+            }
+        }
+        if (/createContactAttachmentFilename\s*\(/.test(contactAttachmentsSource) &&
+            !/(prefix\s*:\s*contactAttachmentPolicy\.filenamePrefix|policy\s*:\s*contactAttachmentPolicy)/.test(contactAttachmentsSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-contact-attachment-filename",
+                detail: "Contact attachment filename generation does not use the project-specific attachment filename prefix.",
+                path: "src/lib/contact/attachments.ts",
+            });
+        }
+        if (/const\s+staticLegacyMappings\s*[:=]/.test(nextConfigSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-inline-redirect-registry",
+                detail: "next.config.ts owns a large inline legacy redirect registry.",
+                path: "next.config.ts",
+            });
+        }
+        if (/cacheComponents\s*:\s*true/.test(nextConfigSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-next-cache-components",
+                detail: "next.config.ts enables cacheComponents outside the approved Brandlab pilot track.",
+                path: "next.config.ts",
+            });
+        }
+        if (!/images\s*:\s*\{/.test(nextConfigSource)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-next-image-config",
+                detail: "next.config.ts must define an explicit images config.",
+                path: "next.config.ts",
+            });
+        }
+        else {
+            for (const [code, detail, pattern] of [
+                [
+                    "brandlab-architecture-next-image-qualities",
+                    "next.config.ts images.qualities must be [75, 90].",
+                    /qualities\s*:\s*\[\s*75\s*,\s*90\s*\]/,
+                ],
+                [
+                    "brandlab-architecture-next-image-cache-ttl",
+                    "next.config.ts images.minimumCacheTTL is missing.",
+                    /minimumCacheTTL\s*:/,
+                ],
+                [
+                    "brandlab-architecture-next-image-remote-patterns",
+                    "next.config.ts images.remotePatterns is missing.",
+                    /remotePatterns\s*:\s*\[/,
+                ],
+            ]) {
+                if (pattern.test(nextConfigSource))
+                    continue;
+                issues.push({
+                    severity: "error",
+                    code,
+                    detail,
+                    path: "next.config.ts",
+                });
+            }
+        }
+        const envExamplePath = join(options.root, ".env.example");
+        if (existsSync(envExamplePath) &&
+            LEGACY_ENV_ARTIFACT_PATTERNS.some((pattern) => pattern.test(readFileSync(envExamplePath, "utf8")))) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-legacy-env-artifact",
+                detail: ".env.example still contains legacy reCAPTCHA or SMTP variables from an older contact implementation.",
+                path: ".env.example",
+            });
+        }
+        const globalsCssPath = join(options.root, "src/app/globals.css");
+        if (existsSync(globalsCssPath) &&
+            LEGACY_CSS_ARTIFACT_PATTERNS.some((pattern) => pattern.test(readFileSync(globalsCssPath, "utf8")))) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-legacy-css-artifact",
+                detail: "src/app/globals.css still contains legacy reCAPTCHA CSS.",
+                path: "src/app/globals.css",
+            });
+        }
+        for (const root of CANONICAL_SOURCE_ROOTS) {
+            const absoluteRoot = join(options.root, root);
+            const files = existsSync(absoluteRoot) && statSync(absoluteRoot).isFile()
+                ? [absoluteRoot]
+                : walkAllFiles(absoluteRoot);
+            for (const file of files) {
+                if (!/\.(?:ts|tsx|js|jsx)$/.test(file))
+                    continue;
+                const source = readFileSync(file, "utf8");
+                if (!source.includes("companyInfo.website"))
+                    continue;
+                const relativePath = relative(options.root, file)
+                    .split(/[/\\]/)
+                    .join("/");
+                issues.push({
+                    severity: "error",
+                    code: "brandlab-architecture-canonical-source",
+                    detail: `${relativePath} uses companyInfo.website in an SEO, schema, or route surface. Canonical URLs must come from the env-backed site config.`,
+                    path: relativePath,
+                });
+            }
+        }
+    }
+    const familyCounts = new Map();
+    const templateImportRouteCounts = new Map();
+    for (const filePath of pageFiles) {
+        const family = appFamilyForPage(filePath);
+        const current = familyCounts.get(family) ?? {
+            staticCount: 0,
+            dynamicCount: 0,
+        };
+        if (filePath.includes("["))
+            current.dynamicCount += 1;
+        else
+            current.staticCount += 1;
+        familyCounts.set(family, current);
+        const source = readFileSync(join(options.root, filePath), "utf8");
+        const lineCount = source.split(/\r?\n/).length;
+        const routeOwnedContentChars = countRouteOwnedContentChars(source);
+        for (const templateImport of routeTemplateImportMatches(source)) {
+            const key = `${templateImport.modulePath}::${templateImport.localName}`;
+            const currentImport = templateImportRouteCounts.get(key) ?? {
+                modulePath: templateImport.modulePath,
+                routes: new Set(),
+            };
+            currentImport.routes.add(filePath);
+            templateImportRouteCounts.set(key, currentImport);
+        }
+        if (appRouteFileIsDynamic(filePath) && lineCount > largeRouteFileLineLimit) {
+            issues.push({
+                severity: "error",
+                code: "large-route-file",
+                detail: `Route file has ${lineCount} lines and appears to own page content instead of delegating to src/data/page models.`,
+                path: filePath,
+            });
+        }
+        if (appRouteFileIsDynamic(filePath) && routeOwnedContentChars > routeFileContentCharLimit) {
+            issues.push({
+                severity: "error",
+                code: "route-owned-page-copy",
+                detail: `Dynamic route file contains about ${routeOwnedContentChars} characters of customer-facing copy. Standard dynamic route families should orchestrate data and components, not own repeated page copy.`,
+                path: filePath,
+            });
+        }
+        if (appRouteFileIsDynamic(filePath) && CONTENT_ARRAY_PATTERN.test(source)) {
+            issues.push({
+                severity: "error",
+                code: "embedded-route-content-array",
+                detail: "Route file declares customer-facing FAQ, testimonial, feature, or process arrays instead of importing page data.",
+                path: filePath,
+            });
+        }
+        if (hasRawMetadataObjectExport(source)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-raw-route-metadata",
+                detail: `${filePath} exports a raw metadata object. Standard routes should use the shared metadata builder so titles, canonical URLs, robots, Open Graph, and Twitter values follow one contract.`,
+                path: filePath,
+            });
+        }
+        const copyMatches = appRouteFileIsDynamic(filePath)
+            ? routeOwnedCopyPropertyMatches(source)
+            : [];
+        if (copyMatches.length > 0) {
+            const propertyNames = [
+                ...new Set(copyMatches.map((match) => match.propertyName)),
+            ].sort();
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-route-owned-copy-property",
+                detail: `${filePath} owns customer-facing copy in route properties: ${propertyNames.join(", ")}.`,
+                path: filePath,
+            });
+        }
+    }
+    const pageFileSet = new Set(pageFiles);
+    for (const filePath of routeBoundaryFiles.filter((candidate) => !pageFileSet.has(candidate))) {
+        const source = readFileSync(join(options.root, filePath), "utf8");
+        if (hasRawMetadataObjectExport(source)) {
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-raw-route-metadata",
+                detail: `${filePath} exports a raw metadata object. Standard routes should use the shared metadata builder so titles, canonical URLs, robots, Open Graph, and Twitter values follow one contract.`,
+                path: filePath,
+            });
+        }
+        const copyMatches = routeOwnedCopyPropertyMatches(source);
+        if (copyMatches.length > 0) {
+            const propertyNames = [
+                ...new Set(copyMatches.map((match) => match.propertyName)),
+            ].sort();
+            issues.push({
+                severity: "error",
+                code: "brandlab-architecture-route-owned-copy-property",
+                detail: `${filePath} owns customer-facing copy in route properties: ${propertyNames.join(", ")}.`,
+                path: filePath,
+            });
+        }
+    }
+    for (const { modulePath, routes } of templateImportRouteCounts.values()) {
+        if (routes.size !== 1)
+            continue;
+        const [routePath] = [...routes];
+        if (appRouteFileIsDynamic(routePath))
+            continue;
+        issues.push({
+            severity: "error",
+            code: "brandlab-architecture-single-use-page-template",
+            detail: `${routePath} imports ${modulePath}, but that template is only used by one static route. Static one-off pages should compose page sections directly in src/app; keep src/components/templates for reusable dynamic route families or templates shared by multiple routes.`,
+            path: routePath,
+        });
     }
     const staticRouteFileLimit = architecture?.staticRouteFileLimit ?? DEFAULT_STATIC_ROUTE_FILE_LIMIT;
     for (const [family, counts] of familyCounts.entries()) {
-        if (counts.staticCount > staticRouteFileLimit && counts.dynamicCount === 0) {
+        if (counts.staticCount > staticRouteFileLimit &&
+            counts.dynamicCount === 0) {
             issues.push({
-                severity: architecture?.status === 'legacy-exception' ? 'legacy-accepted' : 'error',
-                code: 'brandlab-architecture-static-heavy-family',
+                severity: "error",
+                code: "brandlab-architecture-static-heavy-family",
                 detail: `${family} has ${counts.staticCount} static route files and no dynamic route boundary.`,
             });
         }
@@ -385,8 +2668,10 @@ export function evaluateBrandlabArchitecture(options) {
         profile: architecture?.profile ?? null,
         status: architecture?.status ?? null,
         pageFileCount: pageFiles.length,
-        staticPageFileCount: pageFiles.filter((filePath) => !filePath.includes('[')).length,
-        dynamicPageFileCount: pageFiles.filter((filePath) => filePath.includes('[')).length,
+        staticPageFileCount: pageFiles.filter((filePath) => !filePath.includes("["))
+            .length,
+        dynamicPageFileCount: pageFiles.filter((filePath) => filePath.includes("["))
+            .length,
         issues,
     };
 }