@brandlab-digital/conformance 1.0.0-rc.8 → 1.0.0

package/dist/project-config-v3.js

@@ -1,2876 +0,0 @@
-/**
- * Project Config v3 inspector for Brandlab 1.0.0-rc.2 and later releases that
- * explicitly declare project-config-v3.
- */
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { createHash } from "node:crypto";
-import { extname, join, relative } from "node:path";
-import * as ts from "typescript";
-export const BRANDLAB_CONFIG_V3_RULESET_ID = "project-config-v3@1.0.0-rc.2";
-export const BRANDLAB_CONFIG_V3_PROFILES = [
-    "next-local-service",
-    "next-root-level",
-    "next-static-legacy",
-    "legacy-php",
-];
-const ROUTE_FAMILIES = new Set([
-    "services",
-    "locations",
-    "service-locations",
-    "blog",
-    "projects",
-    "legal",
-]);
-const CANONICAL_ENTITY_ID_PATTERN = /^[a-z0-9]+(?:[&-][a-z0-9]+)*$/;
-const CANONICAL_ENTITY_ID_MAX_LENGTH = 100;
-const BLOG_ADAPTERS = new Set(["none", "mdx", "structured"]);
-const ATTACHMENT_MODES = new Set(["none", "images-optional", "images-required"]);
-const LOCATION_STRATEGIES = new Set([
-    "none",
-    "approved-service-area",
-    "physical-location",
-    "multi-location",
-]);
-const REVIEWS_PROVIDERS = new Set(["google-places", "project-owned"]);
-const ROOT_CONFIG_KEYS = new Set([
-    "projectId",
-    "profile",
-    "routes",
-    "capabilities",
-    "sitemap",
-    "searchCertification",
-    "exceptions",
-]);
-const FORBIDDEN_GLOBAL_KEYS = new Set([
-    "installedRelease",
-    "packageScope",
-    "packageVersion",
-    "nextVersion",
-    "reactVersion",
-    "reactDomVersion",
-    "nodeVersion",
-    "typescriptVersion",
-    "packageManager",
-    "leadEvents",
-    "attachmentLimits",
-    "previewIndexing",
-]);
-const SOURCE_EXTENSIONS = new Set([".js", ".jsx", ".mjs", ".ts", ".tsx"]);
-const SKIPPED_DIRECTORIES = new Set([
-    ".git",
-    ".next",
-    ".turbo",
-    "coverage",
-    "dist",
-    "generated",
-    "node_modules",
-]);
-const REQUIRED_KERNEL_IMPORTS = [
-    ["@brandlab-digital/site-next/analytics", "analytics"],
-    ["@brandlab-digital/site-next/ui", "accessibility"],
-];
-const STRICT_KERNEL_USAGES = [
-    {
-        moduleName: "@brandlab-digital/site-core/platform-contract",
-        surface: "platform-contract",
-        exports: ["defineBrandlabPlatformContract"],
-    },
-    {
-        moduleName: "@brandlab-digital/site-core/business",
-        surface: "business",
-        exports: ["defineBrandlabBusiness"],
-    },
-    {
-        moduleName: "@brandlab-digital/site-core/routes",
-        surface: "routes",
-        exports: ["defineRouteCatalog"],
-    },
-    {
-        moduleName: "@brandlab-digital/site-next/metadata",
-        surface: "metadata",
-        exports: ["createRouteMetadataBuilder"],
-        frameworkOutput: {
-            owner: "metadata",
-            ruleId: "brandlab-config-v3-shared-metadata-framework-output",
-        },
-    },
-    {
-        moduleName: "@brandlab-digital/site-core/schema",
-        surface: "schema-graph",
-        exports: ["buildSchemaGraph"],
-        frameworkOutput: {
-            owner: "render",
-            ruleId: "brandlab-config-v3-shared-schema-graph-framework-output",
-        },
-    },
-    {
-        moduleName: "@brandlab-digital/site-next/schema",
-        surface: "schema",
-        exports: ["SchemaScript"],
-        frameworkOutput: {
-            owner: "render",
-            ruleId: "brandlab-config-v3-shared-schema-framework-output",
-        },
-    },
-    {
-        moduleName: "@brandlab-digital/site-next/breadcrumbs",
-        surface: "breadcrumbs",
-        exports: ["createRouteBreadcrumbOutput"],
-        frameworkOutput: {
-            owner: "render",
-            ruleId: "brandlab-config-v3-shared-breadcrumbs-framework-output",
-        },
-    },
-    {
-        moduleName: "@brandlab-digital/site-core/sitemaps",
-        surface: "sitemap-catalog",
-        exports: ["buildSitemapEntries"],
-        frameworkOutput: {
-            owner: "sitemap",
-            ruleId: "brandlab-config-v3-shared-sitemap-catalog-framework-output",
-        },
-    },
-    {
-        moduleName: "@brandlab-digital/site-next/sitemaps",
-        surface: "sitemap",
-        exports: ["sitemapXmlResponse", "sitemapIndexXmlResponse"],
-        frameworkOutput: {
-            owner: "sitemap",
-            ruleId: "brandlab-config-v3-shared-sitemap-framework-output",
-        },
-    },
-    {
-        moduleName: "@brandlab-digital/site-next/robots",
-        surface: "robots",
-        exports: ["buildRobotsMetadata"],
-        frameworkOutput: {
-            owner: "robots",
-            ruleId: "brandlab-config-v3-shared-robots-framework-output",
-        },
-    },
-];
-const FORBIDDEN_CANDIDATE_EXPORTS = [
-    {
-        moduleName: "@brandlab-digital/site-next/metadata",
-        surface: "metadata",
-        exports: [
-            "buildNextMetadata",
-            "buildBrandlabNextMetadata",
-            "createNextMetadataBuilder",
-            "createBrandlabNextMetadataBuilder",
-        ],
-    },
-    {
-        moduleName: "@brandlab-digital/site-next/breadcrumbs",
-        surface: "breadcrumbs",
-        exports: ["BrandlabPathBreadcrumbs", "createBreadcrumbItems"],
-    },
-    {
-        moduleName: "@brandlab-digital/site-next/blog",
-        surface: "blog",
-        exports: [
-            "createBrandlabBlogAdapter",
-            "createMdxBlogAdapter",
-            "createStructuredBlogAdapter",
-        ],
-    },
-    {
-        moduleName: "@brandlab-digital/site-core/schema",
-        surface: "schema",
-        exports: ["createSchema", "createSchemaGraph", "buildFaqPageSchema"],
-    },
-];
-const PROTECTED_LOCAL_PATTERNS = [
-    {
-        ruleId: "brandlab-config-v3-local-contact-transport",
-        surface: "contact",
-        pattern: /\b(?:new\s+Resend|resend\.emails\.send)\b/,
-        expected: "Contact delivery is owned by @brandlab-digital/site-next/contact/server.",
-    },
-    {
-        ruleId: "brandlab-config-v3-local-contact-email",
-        surface: "contact",
-        pattern: /\b(?:class|function|const|let|var)\s+(?:ContactFormEmail|renderContactEmail)\b/,
-        expected: "Contact email rendering is owned by @brandlab-digital/site-next/contact/email.",
-    },
-    {
-        ruleId: "brandlab-config-v3-local-lead-event",
-        surface: "analytics",
-        pattern: /\bgtag\s*\([^)]*["'](?:contact_form|phone_call)["']/,
-        expected: "Canonical lead events are owned by @brandlab-digital/site-next/analytics.",
-    },
-    {
-        ruleId: "brandlab-config-v3-url-derived-breadcrumbs",
-        surface: "breadcrumbs",
-        severity: "warning",
-        pattern: /\b(?:BrandlabPathBreadcrumbs|createBreadcrumbItems)\b/,
-        expected: "Breadcrumb labels and hierarchy derive from the semantic route catalog.",
-    },
-];
-export function inspectBrandlabConfigV3(root) {
-    const issues = [];
-    const configPath = join(root, "brandlab.config.ts");
-    const usage = collectProjectImports(root, issues);
-    const { imports, executableImports, outputOwnedImports, executableExports, outputOwnedExports, frameworkOwnedExports, } = usage;
-    if (!existsSync(configPath)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-missing",
-            expected: "A constrained brandlab.config.ts using defineBrandlabProject().",
-            actual: "brandlab.config.ts is missing.",
-            remediation: "Add the variation-only typed project configuration.",
-            path: "brandlab.config.ts",
-        }));
-        return { ...usage, config: null, issues };
-    }
-    const sourceText = readFileSync(configPath, "utf8");
-    const source = ts.createSourceFile(configPath, sourceText, ts.ScriptTarget.ES2022, true, ts.ScriptKind.TS);
-    for (const diagnostic of getParseDiagnostics(source)) {
-        const location = diagnostic.start === undefined
-            ? undefined
-            : source.getLineAndCharacterOfPosition(diagnostic.start);
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-syntax",
-            expected: "Syntactically valid TypeScript configuration.",
-            actual: ts.flattenDiagnosticMessageText(diagnostic.messageText, " "),
-            remediation: "Correct the configuration syntax without executing project code.",
-            path: "brandlab.config.ts",
-            line: location ? location.line + 1 : undefined,
-        }));
-    }
-    const factoryNames = collectFactoryImportNames(source);
-    if (factoryNames.size === 0) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-factory-import",
-            expected: "defineBrandlabProject imported from @brandlab-digital/site-core/project.",
-            actual: "The supported project factory import was not found.",
-            remediation: "Import and call the shared project configuration factory.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    const assignment = source.statements.find(ts.isExportAssignment);
-    const expression = assignment ? unwrapExpression(assignment.expression) : null;
-    if (!expression ||
-        !ts.isCallExpression(expression) ||
-        !ts.isIdentifier(expression.expression) ||
-        !factoryNames.has(expression.expression.text) ||
-        expression.arguments.length !== 1) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-export",
-            expected: "One default export calling defineBrandlabProject() with one object literal.",
-            actual: "The default export does not match the constrained configuration contract.",
-            remediation: "Export the variation-only object directly through defineBrandlabProject().",
-            path: "brandlab.config.ts",
-        }));
-        return { ...usage, config: null, issues };
-    }
-    let value;
-    try {
-        value = literalValue(expression.arguments[0], source);
-    }
-    catch (error) {
-        const node = error instanceof ConfigLiteralError ? error.node : expression.arguments[0];
-        const location = source.getLineAndCharacterOfPosition(node.getStart(source));
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-literal-only",
-            expected: "A static object containing only literal values, arrays and nested objects.",
-            actual: error instanceof Error ? error.message : "The configuration is not inspectable.",
-            remediation: "Remove spreads, computed values, function calls and executable expressions.",
-            path: "brandlab.config.ts",
-            line: location.line + 1,
-        }));
-        return { ...usage, config: null, issues };
-    }
-    const config = validateConfigValue(value, issues);
-    if (config) {
-        addImportContractIssues(root, config, usage, issues);
-    }
-    addProtectedImplementationIssues(root, issues);
-    return {
-        config,
-        imports,
-        executableImports,
-        outputOwnedImports,
-        executableExports,
-        outputOwnedExports,
-        frameworkOwnedExports,
-        issues,
-    };
-}
-function collectFactoryImportNames(source) {
-    const names = new Set();
-    for (const statement of source.statements) {
-        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) {
-            continue;
-        }
-        if (statement.moduleSpecifier.text !== "@brandlab-digital/site-core/project")
-            continue;
-        const bindings = statement.importClause?.namedBindings;
-        if (!bindings || !ts.isNamedImports(bindings))
-            continue;
-        for (const element of bindings.elements) {
-            if ((element.propertyName ?? element.name).text === "defineBrandlabProject") {
-                names.add(element.name.text);
-            }
-        }
-    }
-    return names;
-}
-function unwrapExpression(expression) {
-    let current = expression;
-    while (ts.isParenthesizedExpression(current) ||
-        ts.isAsExpression(current) ||
-        ts.isSatisfiesExpression(current) ||
-        ts.isTypeAssertionExpression(current)) {
-        current = current.expression;
-    }
-    return current;
-}
-class ConfigLiteralError extends Error {
-    node;
-    constructor(message, node) {
-        super(message);
-        this.node = node;
-    }
-}
-function literalValue(node, source) {
-    const value = unwrapExpression(node);
-    if (ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value))
-        return value.text;
-    if (ts.isNumericLiteral(value))
-        return Number(value.text);
-    if (value.kind === ts.SyntaxKind.TrueKeyword)
-        return true;
-    if (value.kind === ts.SyntaxKind.FalseKeyword)
-        return false;
-    if (value.kind === ts.SyntaxKind.NullKeyword)
-        return null;
-    if (ts.isPrefixUnaryExpression(value) && value.operator === ts.SyntaxKind.MinusToken) {
-        const operand = literalValue(value.operand, source);
-        if (typeof operand === "number")
-            return -operand;
-    }
-    if (ts.isArrayLiteralExpression(value)) {
-        return value.elements.map((element) => {
-            if (ts.isSpreadElement(element)) {
-                throw new ConfigLiteralError("Array spreads are not allowed.", element);
-            }
-            return literalValue(element, source);
-        });
-    }
-    if (ts.isObjectLiteralExpression(value)) {
-        const output = {};
-        for (const property of value.properties) {
-            if (!ts.isPropertyAssignment(property)) {
-                throw new ConfigLiteralError("Only explicit property assignments are allowed.", property);
-            }
-            const name = propertyName(property.name);
-            if (name === null) {
-                throw new ConfigLiteralError("Computed property names are not allowed.", property.name);
-            }
-            if (Object.hasOwn(output, name)) {
-                throw new ConfigLiteralError(`Duplicate property "${name}" is not allowed.`, property.name);
-            }
-            output[name] = literalValue(property.initializer, source);
-        }
-        return output;
-    }
-    throw new ConfigLiteralError(`Unsupported executable expression: ${value.getText(source).slice(0, 80)}.`, value);
-}
-function propertyName(name) {
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
-        return name.text;
-    }
-    return null;
-}
-function validateConfigValue(value, issues) {
-    if (!isRecord(value)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-object",
-            expected: "A project variation object.",
-            actual: "The configuration value is not an object.",
-            remediation: "Pass one constrained object literal to defineBrandlabProject().",
-            path: "brandlab.config.ts",
-        }));
-        return null;
-    }
-    const validationStart = issues.length;
-    for (const key of FORBIDDEN_GLOBAL_KEYS) {
-        if (Object.hasOwn(value, key)) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-global-fact",
-                expected: "Project variation only; runtime and release facts come from lockfiles and manifests.",
-                actual: `Global fact "${key}" is repeated in project configuration.`,
-                remediation: `Remove ${key} from brandlab.config.ts.`,
-                path: "brandlab.config.ts",
-            }));
-        }
-    }
-    addUnknownKeyIssues(value, ROOT_CONFIG_KEYS, FORBIDDEN_GLOBAL_KEYS, "config", issues);
-    const projectId = typeof value.projectId === "string" ? value.projectId : "";
-    const profile = typeof value.profile === "string" ? value.profile : "";
-    const routes = isRecord(value.routes) ? value.routes : null;
-    const rawFamilies = routes && Array.isArray(routes.families) ? routes.families : [];
-    const families = rawFamilies.filter((entry) => typeof entry === "string");
-    const searchCertification = isRecord(value.searchCertification)
-        ? value.searchCertification
-        : null;
-    const representativeRoutes = searchCertification && isRecord(searchCertification.representativeRoutes)
-        ? searchCertification.representativeRoutes
-        : null;
-    if (projectId.length > CANONICAL_ENTITY_ID_MAX_LENGTH ||
-        !CANONICAL_ENTITY_ID_PATTERN.test(projectId)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-project-id",
-            expected: `A 1–${CANONICAL_ENTITY_ID_MAX_LENGTH} character canonical lowercase projectId using letters, numbers, ampersands or hyphens.`,
-            actual: projectId ? `Invalid projectId "${projectId}".` : "projectId is missing.",
-            remediation: "Use the canonical entity identifier.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    if (!BRANDLAB_CONFIG_V3_PROFILES.includes(profile)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-profile",
-            expected: `One supported profile: ${BRANDLAB_CONFIG_V3_PROFILES.join(", ")}.`,
-            actual: profile ? `Unsupported profile "${profile}".` : "profile is missing.",
-            remediation: "Select the structural profile that matches the project.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    if (!routes || !Array.isArray(routes.families) || families.length !== rawFamilies.length) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-routes",
-            expected: "routes.families as a literal string array.",
-            actual: "Route families are missing or invalid.",
-            remediation: "Declare only the route families the project owns.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    else {
-        addUnknownKeyIssues(routes, new Set(["families", "aliases"]), new Set(), "routes", issues);
-        const unsupportedFamily = families.find((family) => !ROUTE_FAMILIES.has(family));
-        if (unsupportedFamily) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-route-family",
-                expected: `Supported route families only: ${[...ROUTE_FAMILIES].join(", ")}.`,
-                actual: `Unsupported route family "${unsupportedFamily}".`,
-                remediation: "Use the closest supported route family or propose a versioned contract extension.",
-                path: "brandlab.config.ts",
-            }));
-        }
-        addDuplicateIssue(families, "brandlab-config-v3-route-family-duplicate", "routes.families", issues);
-        validateAliases(routes.aliases, issues);
-    }
-    if (!searchCertification) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-search-certification",
-            expected: "A searchCertification object containing representativeRoutes.",
-            actual: "searchCertification is missing or invalid.",
-            remediation: "Declare the inspectable representative route selection.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    else {
-        addUnknownKeyIssues(searchCertification, new Set(["representativeRoutes"]), new Set(), "searchCertification", issues);
-    }
-    if (!representativeRoutes || typeof representativeRoutes.home !== "string") {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-search-routes",
-            expected: "A literal home route under searchCertification.representativeRoutes.",
-            actual: "Representative Search Certification routes are incomplete.",
-            remediation: "Declare the smallest representative route set for this project.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    else {
-        addUnknownKeyIssues(representativeRoutes, new Set(["home", "contact", "service", "location", "blog"]), new Set(), "searchCertification.representativeRoutes", issues);
-        for (const [name, path] of Object.entries(representativeRoutes)) {
-            if (typeof path !== "string" || !isRootRelativePath(path)) {
-                issues.push(configIssue({
-                    ruleId: "brandlab-config-v3-search-route-path",
-                    expected: `${name} as a strict root-relative route without encoded separators, dot segments, query or hash.`,
-                    actual: `${name} is ${JSON.stringify(path)}.`,
-                    remediation: "Use a canonical route path from the typed route catalog.",
-                    path: "brandlab.config.ts",
-                }));
-            }
-        }
-        if (representativeRoutes.home !== "/") {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-search-home",
-                expected: 'searchCertification.representativeRoutes.home="/".',
-                actual: `home is ${JSON.stringify(representativeRoutes.home)}.`,
-                remediation: "Use the canonical root route for the representative homepage.",
-                path: "brandlab.config.ts",
-            }));
-        }
-        const familyRouteRequirements = [
-            { families: ["services"], route: "service" },
-            { families: ["locations", "service-locations"], route: "location" },
-            { families: ["blog"], route: "blog" },
-        ];
-        for (const requirement of familyRouteRequirements) {
-            const owningFamily = requirement.families.find((family) => families.includes(family));
-            if (owningFamily && typeof representativeRoutes[requirement.route] !== "string") {
-                issues.push(configIssue({
-                    ruleId: "brandlab-config-v3-search-family-route",
-                    surface: "search-certification",
-                    expected: `A ${requirement.route} representative route when routes.families includes ${owningFamily}.`,
-                    actual: `${owningFamily} is enabled without searchCertification.representativeRoutes.${requirement.route}.`,
-                    remediation: "Bind every enabled route family to a canonical representative Search Certification route.",
-                    path: "brandlab.config.ts",
-                }));
-            }
-        }
-    }
-    const capabilities = value.capabilities === undefined
-        ? {}
-        : isRecord(value.capabilities)
-            ? value.capabilities
-            : null;
-    if (capabilities === null) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-capabilities",
-            expected: "capabilities as an optional literal object.",
-            actual: "capabilities is not an object.",
-            remediation: "Declare only supported project capability variation.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    else {
-        validateCapabilities(capabilities, issues);
-    }
-    validateSitemap(value.sitemap, issues);
-    validateExceptions(value.exceptions, issues);
-    if (issues.slice(validationStart).some((issue) => issue.severity === "blocker"))
-        return null;
-    const safeCapabilities = capabilities ?? {};
-    const blog = isRecord(safeCapabilities.blog) ? safeCapabilities.blog : null;
-    const contact = isRecord(safeCapabilities.contact) ? safeCapabilities.contact : null;
-    const locations = isRecord(safeCapabilities.locations) ? safeCapabilities.locations : null;
-    const reviews = isRecord(safeCapabilities.reviews) ? safeCapabilities.reviews : null;
-    const reviewsProvider = typeof reviews?.provider === "string" ? reviews.provider : null;
-    if (reviewsProvider === "google-places" && !families.includes("legal")) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-google-places-legal-family",
-            expected: "The legal route family for public Terms and Privacy surfaces.",
-            actual: "Google Places reviews are enabled without routes.families including legal.",
-            remediation: "Add typed Terms and Privacy routes before enabling Google Places reviews.",
-            path: "brandlab.config.ts",
-        }));
-        return null;
-    }
-    return {
-        projectId,
-        profile: profile,
-        routes: { families },
-        searchCertification: {
-            representativeRoutes: Object.fromEntries(Object.entries(representativeRoutes ?? {}).filter((entry) => typeof entry[1] === "string")),
-        },
-        capabilities: {
-            blogAdapter: typeof blog?.adapter === "string" ? blog.adapter : null,
-            contactEnabled: contact !== null,
-            locationStrategy: typeof locations?.strategy === "string" ? locations.strategy : null,
-            reviewsProvider,
-        },
-    };
-}
-function validateAliases(value, issues) {
-    if (value === undefined)
-        return;
-    if (!Array.isArray(value)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-route-aliases",
-            expected: "routes.aliases as an optional literal array.",
-            actual: "routes.aliases is not an array.",
-            remediation: "Declare each historical alias as a typed from/to record.",
-            path: "brandlab.config.ts",
-        }));
-        return;
-    }
-    const fromPaths = [];
-    const toPaths = [];
-    value.forEach((alias, index) => {
-        if (!isRecord(alias)) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-route-alias",
-                expected: `routes.aliases[${index}] as an object.`,
-                actual: "The alias is not an object.",
-                remediation: "Declare from, to and optional 301 or 308 status.",
-                path: "brandlab.config.ts",
-            }));
-            return;
-        }
-        addUnknownKeyIssues(alias, new Set(["from", "to", "status"]), new Set(), `routes.aliases[${index}]`, issues);
-        const from = typeof alias.from === "string" ? alias.from : "";
-        const to = typeof alias.to === "string" ? alias.to : "";
-        if (!isRootRelativePath(from) || !isRootRelativePath(to)) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-route-alias-path",
-                expected: "Strict root-relative from/to alias paths.",
-                actual: `Alias ${index} uses from=${JSON.stringify(alias.from)} and to=${JSON.stringify(alias.to)}.`,
-                remediation: "Use canonical root-relative paths without encoded separators, dot segments, query or hash.",
-                path: "brandlab.config.ts",
-            }));
-        }
-        if (alias.status !== undefined && alias.status !== 301 && alias.status !== 308) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-route-alias-status",
-                expected: "Alias status 301 or 308 when present.",
-                actual: `Alias ${index} uses ${JSON.stringify(alias.status)}.`,
-                remediation: "Choose the approved permanent redirect status.",
-                path: "brandlab.config.ts",
-            }));
-        }
-        if (from && from === to) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-route-alias-self",
-                expected: "An alias whose source differs from its destination.",
-                actual: `Alias ${index} redirects ${from} to itself.`,
-                remediation: "Remove the self-redirect.",
-                path: "brandlab.config.ts",
-            }));
-        }
-        if (from)
-            fromPaths.push(from);
-        if (to)
-            toPaths.push(to);
-    });
-    addDuplicateIssue(fromPaths, "brandlab-config-v3-route-alias-duplicate", "routes.aliases.from", issues);
-    const chain = fromPaths.find((from) => toPaths.includes(from));
-    if (chain) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-route-alias-chain",
-            expected: "Direct aliases without redirect chains or cycles.",
-            actual: `Alias source ${chain} is also an alias destination.`,
-            remediation: "Point every historical alias directly to its final canonical route.",
-            path: "brandlab.config.ts",
-        }));
-    }
-}
-function validateCapabilities(capabilities, issues) {
-    addUnknownKeyIssues(capabilities, new Set(["blog", "contact", "locations", "reviews"]), new Set(), "capabilities", issues);
-    if (capabilities.blog !== undefined) {
-        if (!isRecord(capabilities.blog)) {
-            addShapeIssue("blog", issues);
-        }
-        else {
-            addUnknownKeyIssues(capabilities.blog, new Set(["adapter"]), new Set(), "capabilities.blog", issues);
-            if (typeof capabilities.blog.adapter !== "string" || !BLOG_ADAPTERS.has(capabilities.blog.adapter)) {
-                issues.push(configIssue({
-                    ruleId: "brandlab-config-v3-blog-adapter",
-                    expected: `One blog adapter: ${[...BLOG_ADAPTERS].join(", ")}.`,
-                    actual: `blog.adapter is ${JSON.stringify(capabilities.blog.adapter)}.`,
-                    remediation: "Select the adapter matching the project-owned content source.",
-                    path: "brandlab.config.ts",
-                }));
-            }
-        }
-    }
-    if (capabilities.contact !== undefined) {
-        if (!isRecord(capabilities.contact)) {
-            addShapeIssue("contact", issues);
-        }
-        else {
-            addUnknownKeyIssues(capabilities.contact, new Set(["fieldProfile", "attachments"]), new Set(), "capabilities.contact", issues);
-            if (typeof capabilities.contact.fieldProfile !== "string" ||
-                !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(capabilities.contact.fieldProfile)) {
-                issues.push(configIssue({
-                    ruleId: "brandlab-config-v3-contact-field-profile",
-                    expected: "A non-empty lowercase kebab-case contact fieldProfile.",
-                    actual: `contact.fieldProfile is ${JSON.stringify(capabilities.contact.fieldProfile)}.`,
-                    remediation: "Use the approved declarative field-profile identifier.",
-                    path: "brandlab.config.ts",
-                }));
-            }
-            if (typeof capabilities.contact.attachments !== "string" ||
-                !ATTACHMENT_MODES.has(capabilities.contact.attachments)) {
-                issues.push(configIssue({
-                    ruleId: "brandlab-config-v3-contact-attachments",
-                    expected: `One attachment mode: ${[...ATTACHMENT_MODES].join(", ")}.`,
-                    actual: `contact.attachments is ${JSON.stringify(capabilities.contact.attachments)}.`,
-                    remediation: "Use an approved shared attachment policy.",
-                    path: "brandlab.config.ts",
-                }));
-            }
-        }
-    }
-    if (capabilities.locations !== undefined) {
-        if (!isRecord(capabilities.locations)) {
-            addShapeIssue("locations", issues);
-        }
-        else {
-            addUnknownKeyIssues(capabilities.locations, new Set(["strategy"]), new Set(), "capabilities.locations", issues);
-            if (typeof capabilities.locations.strategy !== "string" ||
-                !LOCATION_STRATEGIES.has(capabilities.locations.strategy)) {
-                issues.push(configIssue({
-                    ruleId: "brandlab-config-v3-location-strategy",
-                    expected: `One location strategy: ${[...LOCATION_STRATEGIES].join(", ")}.`,
-                    actual: `locations.strategy is ${JSON.stringify(capabilities.locations.strategy)}.`,
-                    remediation: "Use the verified business-location model.",
-                    path: "brandlab.config.ts",
-                }));
-            }
-        }
-    }
-    if (capabilities.reviews !== undefined) {
-        if (!isRecord(capabilities.reviews)) {
-            addShapeIssue("reviews", issues);
-        }
-        else {
-            addUnknownKeyIssues(capabilities.reviews, new Set(["provider"]), new Set(), "capabilities.reviews", issues);
-            if (typeof capabilities.reviews.provider !== "string" ||
-                !REVIEWS_PROVIDERS.has(capabilities.reviews.provider)) {
-                issues.push(configIssue({
-                    ruleId: "brandlab-config-v3-reviews-provider",
-                    expected: `One reviews provider: ${[...REVIEWS_PROVIDERS].join(", ")}.`,
-                    actual: `reviews.provider is ${JSON.stringify(capabilities.reviews.provider)}.`,
-                    remediation: "Select the shared Google Places provider or verified project-owned records.",
-                    path: "brandlab.config.ts",
-                }));
-            }
-        }
-    }
-}
-function addShapeIssue(surface, issues) {
-    issues.push(configIssue({
-        ruleId: `brandlab-config-v3-${surface}-shape`,
-        expected: `capabilities.${surface} as a supported literal object.`,
-        actual: `capabilities.${surface} is not an object.`,
-        remediation: "Use the documented variation-only capability shape.",
-        path: "brandlab.config.ts",
-    }));
-}
-function validateSitemap(value, issues) {
-    if (value === undefined)
-        return;
-    if (!isRecord(value)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-sitemap",
-            expected: 'sitemap as { mode: "single" } or a documented split configuration.',
-            actual: "sitemap is not an object.",
-            remediation: "Use the shared sitemap variation contract.",
-            path: "brandlab.config.ts",
-        }));
-        return;
-    }
-    if (value.mode === "single") {
-        addUnknownKeyIssues(value, new Set(["mode"]), new Set(), "sitemap", issues);
-        return;
-    }
-    if (value.mode !== "split") {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-sitemap-mode",
-            expected: 'sitemap.mode as "single" or "split".',
-            actual: `sitemap.mode is ${JSON.stringify(value.mode)}.`,
-            remediation: "Select a supported sitemap mode.",
-            path: "brandlab.config.ts",
-        }));
-        return;
-    }
-    addUnknownKeyIssues(value, new Set(["mode", "families", "reason"]), new Set(), "sitemap", issues);
-    const families = Array.isArray(value.families)
-        ? value.families.filter((entry) => typeof entry === "string")
-        : [];
-    if (!Array.isArray(value.families) || families.length === 0 || families.length !== value.families.length) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-sitemap-families",
-            expected: "At least one literal split-sitemap root-relative family path.",
-            actual: "sitemap.families is missing, empty or invalid.",
-            remediation: "Declare the approved split boundaries explicitly.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    else {
-        addDuplicateIssue(families, "brandlab-config-v3-sitemap-family-duplicate", "sitemap.families", issues);
-        if (families.some((path) => !isRootRelativePath(path))) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-sitemap-family-path",
-                expected: "Strict root-relative sitemap family paths.",
-                actual: "A split-sitemap family path is invalid.",
-                remediation: "Use canonical route-family boundaries without query, hash or encoded separators.",
-                path: "brandlab.config.ts",
-            }));
-        }
-    }
-    if (typeof value.reason !== "string" || !value.reason.trim()) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-sitemap-reason",
-            expected: "A non-empty reason for split sitemap variation.",
-            actual: "sitemap.reason is missing or empty.",
-            remediation: "Explain the evidence-backed split requirement.",
-            path: "brandlab.config.ts",
-        }));
-    }
-}
-function validateExceptions(value, issues) {
-    if (value === undefined)
-        return;
-    if (!Array.isArray(value)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-exceptions",
-            expected: "exceptions as an optional literal array.",
-            actual: "exceptions is not an array.",
-            remediation: "Use machine-readable exception records only.",
-            path: "brandlab.config.ts",
-        }));
-        return;
-    }
-    const ruleIds = [];
-    value.forEach((exception, index) => {
-        if (!isRecord(exception)) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-exception-shape",
-                expected: `exceptions[${index}] as a complete record.`,
-                actual: "The exception is not an object.",
-                remediation: "Declare ruleId, rationale, owner, evidence, reviewTrigger and optional expiresAt.",
-                path: "brandlab.config.ts",
-            }));
-            return;
-        }
-        addUnknownKeyIssues(exception, new Set(["ruleId", "rationale", "owner", "evidence", "expiresAt", "reviewTrigger"]), new Set(), `exceptions[${index}]`, issues);
-        for (const field of ["ruleId", "rationale", "evidence", "reviewTrigger"]) {
-            if (typeof exception[field] !== "string" || !exception[field].trim()) {
-                issues.push(configIssue({
-                    ruleId: "brandlab-config-v3-exception-required",
-                    expected: `exceptions[${index}].${field} as a non-empty string.`,
-                    actual: `${field} is missing or empty.`,
-                    remediation: "Complete the owned, evidenced, reviewable exception record.",
-                    path: "brandlab.config.ts",
-                }));
-            }
-        }
-        if (exception.owner !== "Romie") {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-exception-owner",
-                expected: 'Exception owner "Romie".',
-                actual: `owner is ${JSON.stringify(exception.owner)}.`,
-                remediation: "Assign the owner explicitly; exceptions never approve themselves.",
-                path: "brandlab.config.ts",
-            }));
-        }
-        if (exception.expiresAt !== undefined &&
-            (typeof exception.expiresAt !== "string" || !isIsoDate(exception.expiresAt))) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-exception-expiry",
-                expected: "expiresAt as an ISO date or timestamp when present.",
-                actual: `expiresAt is ${JSON.stringify(exception.expiresAt)}.`,
-                remediation: "Use a reviewable ISO expiry or omit it and retain the explicit review trigger.",
-                path: "brandlab.config.ts",
-            }));
-        }
-        if (typeof exception.ruleId === "string" && exception.ruleId)
-            ruleIds.push(exception.ruleId);
-    });
-    addDuplicateIssue(ruleIds, "brandlab-config-v3-exception-duplicate", "exceptions.ruleId", issues);
-}
-function addUnknownKeyIssues(value, allowed, separatelyReported, field, issues) {
-    for (const key of Object.keys(value)) {
-        if (allowed.has(key) || separatelyReported.has(key))
-            continue;
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-unknown-key",
-            expected: `Only documented variation keys under ${field}.`,
-            actual: `Unknown key "${field}.${key}".`,
-            remediation: "Remove the unversioned key or add it through a reviewed contract release.",
-            path: "brandlab.config.ts",
-        }));
-    }
-}
-function addDuplicateIssue(values, ruleId, field, issues) {
-    const duplicate = values.find((value, index) => values.indexOf(value) !== index);
-    if (!duplicate)
-        return;
-    issues.push(configIssue({
-        ruleId,
-        expected: `Unique ${field} values.`,
-        actual: `${field} contains duplicate "${duplicate}".`,
-        remediation: "Remove the duplicate variation.",
-        path: "brandlab.config.ts",
-    }));
-}
-function isRootRelativePath(value) {
-    const trimmed = value.trim();
-    return Boolean(trimmed) &&
-        trimmed.startsWith("/") &&
-        !trimmed.startsWith("//") &&
-        !trimmed.includes("\\") &&
-        !/%(?:2f|5c)/i.test(trimmed) &&
-        !/[\u0000-\u001f\u007f]/.test(trimmed) &&
-        !trimmed.includes("?") &&
-        !trimmed.includes("#") &&
-        !trimmed.split("/").some((segment) => segment === "." || segment === "..");
-}
-function isIsoDate(value) {
-    if (!/^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)?$/.test(value))
-        return false;
-    return !Number.isNaN(Date.parse(value));
-}
-function addImportContractIssues(root, config, usage, issues) {
-    if (config.profile === "legacy-php") {
-        const nextEvidence = detectNextPackageBackedEvidence(root, usage);
-        if (nextEvidence.length === 0)
-            return;
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-profile-stack-mismatch",
-            surface: "architecture",
-            expected: "A next-* profile for a package-backed Next.js project.",
-            actual: `profile=\"legacy-php\" conflicts with ${nextEvidence.slice(0, 3).join(", ")}.`,
-            remediation: "Select the matching Next.js architecture profile; legacy-php cannot suppress shared-kernel enforcement.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    for (const [moduleName, surface] of REQUIRED_KERNEL_IMPORTS) {
-        requireModuleExecution(moduleName, surface, usage, issues);
-    }
-    for (const requirement of STRICT_KERNEL_USAGES) {
-        requireStrictUsage(requirement, usage, issues);
-    }
-    requireStrictUsage({
-        moduleName: "@brandlab-digital/site-next/headers",
-        surface: "headers",
-        exports: ["buildBrandlabHeaderRules"],
-    }, usage, issues);
-    if (config.routes.families.includes("locations") ||
-        config.routes.families.includes("service-locations")) {
-        requireStrictUsage({
-            moduleName: "@brandlab-digital/site-core/locations",
-            surface: "location-proof",
-            exports: ["defineLocationRouteQuality"],
-        }, usage, issues);
-    }
-    const contactEvidence = detectContactSurfaceEvidence(root, usage);
-    const contactRequired = config.capabilities.contactEnabled || contactEvidence.length > 0;
-    if (!config.capabilities.contactEnabled && contactEvidence.length > 0) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-contact-capability-required",
-            surface: "contact",
-            expected: "capabilities.contact whenever a contact route or contact implementation exists.",
-            actual: `Contact capability is omitted despite ${contactEvidence.slice(0, 3).join(", ")}.`,
-            remediation: "Declare the contact field profile and attachment policy, then bind the shared production and client runtimes.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    if (contactEvidence.length > 0 &&
-        typeof config.searchCertification.representativeRoutes.contact !== "string") {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-search-contact-route",
-            surface: "search-certification",
-            expected: "searchCertification.representativeRoutes.contact for a detected contact route or runtime.",
-            actual: `Contact implementation exists without a representative contact route (${contactEvidence[0]}).`,
-            remediation: "Bind the canonical contact page into Search Certification.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    if (contactRequired) {
-        requireStrictUsage({
-            moduleName: "@brandlab-digital/site-next/contact/production",
-            surface: "contact-production",
-            exports: ["createBrandlabProductionContactRuntime"],
-        }, usage, issues);
-        requireStrictUsage({
-            moduleName: "@brandlab-digital/site-next/contact/client",
-            surface: "contact-client",
-            exports: ["createContactHttpSubmissionController"],
-        }, usage, issues);
-    }
-    if (config.capabilities.blogAdapter && config.capabilities.blogAdapter !== "none") {
-        const adapterExport = config.capabilities.blogAdapter === "mdx"
-            ? "createRouteAwareMdxBlogAdapter"
-            : "createRouteAwareStructuredBlogAdapter";
-        requireStrictUsage({
-            moduleName: "@brandlab-digital/site-next/blog",
-            surface: "blog",
-            exports: [adapterExport],
-        }, usage, issues);
-    }
-    if (config.capabilities.reviewsProvider === "google-places") {
-        requireStrictUsage({
-            moduleName: "@brandlab-digital/site-next/google-reviews",
-            surface: "google-reviews-route",
-            exports: ["createGooglePlaceReviewsRouteResponse"],
-        }, usage, issues);
-        requireStrictUsage({
-            moduleName: "@brandlab-digital/site-next/google-reviews",
-            surface: "google-reviews-display",
-            exports: ["GooglePlaceReviews"],
-        }, usage, issues);
-    }
-    else if (config.capabilities.reviewsProvider === "project-owned") {
-        requireStrictUsage({
-            moduleName: "@brandlab-digital/site-next/reviews",
-            surface: "project-reviews",
-            exports: ["preparePublicReviews"],
-        }, usage, issues);
-    }
-    else if (usage.imports.has("@brandlab-digital/site-next/google-reviews")) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v3-google-reviews-capability",
-            surface: "google-reviews",
-            expected: 'capabilities.reviews.provider="google-places".',
-            actual: "Google Places runtime is imported without a declared reviews capability.",
-            remediation: "Declare the provider and legal surfaces or remove the Google Places runtime.",
-        }));
-    }
-    for (const forbidden of FORBIDDEN_CANDIDATE_EXPORTS) {
-        const called = usage.executableExports.get(forbidden.moduleName) ?? new Set();
-        for (const exportName of forbidden.exports) {
-            if (!called.has(exportName))
-                continue;
-            issues.push(configIssue({
-                ruleId: `brandlab-config-v3-compat-${forbidden.surface}`,
-                surface: forbidden.surface,
-                expected: "Only route-aware, proof-safe candidate APIs.",
-                actual: `${forbidden.moduleName}.${exportName} executes a compatibility or retired API.`,
-                remediation: "Replace the compatibility call with the strict candidate contract.",
-            }));
-        }
-    }
-}
-function detectNextPackageBackedEvidence(root, usage) {
-    const evidence = new Set();
-    const packagePath = join(root, "package.json");
-    if (existsSync(packagePath)) {
-        try {
-            const packageJson = JSON.parse(readFileSync(packagePath, "utf8"));
-            const dependencyNames = [
-                packageJson.dependencies,
-                packageJson.devDependencies,
-                packageJson.optionalDependencies,
-                packageJson.peerDependencies,
-            ].flatMap((value) => isRecord(value) ? Object.keys(value) : []);
-            if (dependencyNames.includes("next"))
-                evidence.add("package.json dependency next");
-            if (dependencyNames.some((name) => name.startsWith("@brandlab-digital/site-next"))) {
-                evidence.add("package.json Brandlab Next package");
-            }
-        }
-        catch {
-            // Package-shape diagnostics belong to the project evaluator. Other static
-            // Next evidence below still prevents profile-based suppression.
-        }
-    }
-    if (usage.imports.has("next") || [...usage.imports].some((name) => name.startsWith("next/"))) {
-        evidence.add("Next.js runtime import");
-    }
-    if ([...usage.imports].some((name) => name.startsWith("@brandlab-digital/site-next"))) {
-        evidence.add("Brandlab Next runtime import");
-    }
-    for (const name of ["next.config.ts", "next.config.mjs", "next.config.js", "next.config.cjs"]) {
-        if (existsSync(join(root, name)))
-            evidence.add(name);
-    }
-    const nextRoute = walkProjectRuntimeFiles(root)
-        .map((file) => normalizePath(relative(root, file)))
-        .find((path) => /^(?:src\/)?(?:app|pages)\//.test(path));
-    if (nextRoute)
-        evidence.add(`Next.js route ${nextRoute}`);
-    return [...evidence].sort();
-}
-function detectContactSurfaceEvidence(root, usage) {
-    const evidence = new Set();
-    for (const moduleName of usage.imports) {
-        if (moduleName.startsWith("@brandlab-digital/site-next/contact/")) {
-            evidence.add(`shared contact import ${moduleName}`);
-        }
-    }
-    for (const file of walkProjectRuntimeFiles(root)) {
-        const relativePath = normalizePath(relative(root, file));
-        if (/^(?:src\/)?(?:app|pages)\/(?:api\/)?contact(?:\/|\.|$)/i.test(relativePath) ||
-            /(?:^|\/)(?:components?|config|hooks?|lib)\/[^/]*contact[^/]*\.[cm]?[jt]sx?$/i.test(relativePath)) {
-            evidence.add(`contact runtime path ${relativePath}`);
-            continue;
-        }
-        const source = readFileSync(file, "utf8");
-        if (/\b(?:ContactForm|submitContact(?:Form|Enquiry|Request)?|handleContact(?:Form|Submission|Request)|createContact(?:Form|Runtime|Route|Submission)|contactRouteHandler|sendContact(?:Email|Enquiry|Request))\b/.test(source)) {
-            evidence.add(`contact implementation ${relativePath}`);
-        }
-    }
-    return [...evidence].sort();
-}
-function requireModuleExecution(moduleName, surface, usage, issues) {
-    if (!usage.imports.has(moduleName)) {
-        issues.push(configIssue({
-            ruleId: `brandlab-config-v3-shared-${surface}`,
-            surface,
-            expected: `An import from ${moduleName}.`,
-            actual: "No project source file consumes the shared executable contract.",
-            remediation: `Replace the local ${surface} implementation with ${moduleName}.`,
-        }));
-    }
-    else if (!usage.executableImports.has(moduleName)) {
-        issues.push(configIssue({
-            ruleId: `brandlab-config-v3-shared-${surface}-unused`,
-            surface,
-            expected: `An executable call or rendered component from ${moduleName}.`,
-            actual: `${moduleName} is only imported or re-exported.`,
-            remediation: `Wire the shared ${surface} contract into the runtime path.`,
-        }));
-    }
-}
-function requireStrictUsage(requirement, usage, issues) {
-    if (!usage.imports.has(requirement.moduleName)) {
-        issues.push(configIssue({
-            ruleId: `brandlab-config-v3-shared-${requirement.surface}`,
-            surface: requirement.surface,
-            expected: `${requirement.moduleName} using ${requirement.exports.join(" or ")}.`,
-            actual: "The required candidate contract is not imported.",
-            remediation: "Consume the strict shared candidate contract in the owning runtime path.",
-        }));
-        return;
-    }
-    const executable = usage.executableExports.get(requirement.moduleName) ?? new Set();
-    const outputOwned = usage.outputOwnedExports.get(requirement.moduleName) ?? new Set();
-    const frameworkOwned = usage.frameworkOwnedExports.get(requirement.moduleName) ?? new Set();
-    const calledExport = requirement.exports.find((exportName) => executable.has(exportName));
-    if (!calledExport) {
-        issues.push(configIssue({
-            ruleId: `brandlab-config-v3-shared-${requirement.surface}-strict-api`,
-            surface: requirement.surface,
-            expected: `An executable ${requirement.exports.join(" or ")} call.`,
-            actual: `${requirement.moduleName} is called only through an unsupported or generic export.`,
-            remediation: "Use the exact route-aware or production candidate API.",
-        }));
-        return;
-    }
-    if (!requirement.exports.some((exportName) => outputOwned.has(exportName))) {
-        issues.push(configIssue({
-            ruleId: `brandlab-config-v3-shared-${requirement.surface}-unowned-output`,
-            surface: requirement.surface,
-            expected: "The strict shared result reaches an exported binding, rendered or returned route output, or another owned contract.",
-            actual: `${calledExport} executes without a statically reachable runtime output.`,
-            remediation: "Wire the shared result into an exported runtime path instead of a dead assignment or disconnected compliance call.",
-        }));
-        return;
-    }
-    if (requirement.frameworkOutput &&
-        !requirement.exports.some((exportName) => frameworkOwned.has(exportName))) {
-        issues.push(configIssue({
-            ruleId: requirement.frameworkOutput.ruleId,
-            surface: requirement.surface,
-            expected: frameworkOwnerExpectation(requirement.frameworkOutput.owner),
-            actual: `${calledExport} reaches an exported value, but not an owning Next.js framework entrypoint.`,
-            remediation: frameworkOwnerRemediation(requirement.frameworkOutput.owner),
-        }));
-    }
-}
-function frameworkOwnerExpectation(owner) {
-    if (owner === "metadata") {
-        return "The strict metadata builder reaches metadata or generateMetadata in an App Router page or layout entrypoint.";
-    }
-    if (owner === "render") {
-        return "The strict schema or breadcrumb output reaches the default rendered output of an App Router page, layout or template.";
-    }
-    if (owner === "sitemap") {
-        return "The strict sitemap output reaches the default App Router sitemap entrypoint or GET response of a sitemap XML route.";
-    }
-    return "The strict robots output reaches the default App Router robots entrypoint.";
-}
-function frameworkOwnerRemediation(owner) {
-    if (owner === "metadata") {
-        return "Return the shared metadata result from generateMetadata or export it as metadata in the owning page or layout.";
-    }
-    if (owner === "render") {
-        return "Render the shared schema or breadcrumb result from the owning page, layout or template; arbitrary exported decoys do not count.";
-    }
-    if (owner === "sitemap") {
-        return "Return the shared sitemap result from app/sitemap or a canonical sitemap XML GET route.";
-    }
-    return "Return the shared robots result from app/robots.";
-}
-function nextFrameworkOwnerForImport(moduleName, exportName) {
-    if (!exportName)
-        return null;
-    if (moduleName === "@brandlab-digital/site-next/metadata" &&
-        exportName === "createRouteMetadataBuilder")
-        return "metadata";
-    if ((moduleName === "@brandlab-digital/site-core/schema" &&
-        exportName === "buildSchemaGraph") ||
-        (moduleName === "@brandlab-digital/site-next/schema" &&
-            exportName === "SchemaScript") ||
-        (moduleName === "@brandlab-digital/site-next/breadcrumbs" &&
-            exportName === "createRouteBreadcrumbOutput"))
-        return "render";
-    if ((moduleName === "@brandlab-digital/site-core/sitemaps" &&
-        exportName === "buildSitemapEntries") ||
-        (moduleName === "@brandlab-digital/site-next/sitemaps" &&
-            ["sitemapXmlResponse", "sitemapIndexXmlResponse"].includes(exportName)))
-        return "sitemap";
-    if (moduleName === "@brandlab-digital/site-next/robots" &&
-        exportName === "buildRobotsMetadata")
-        return "robots";
-    return null;
-}
-function createNextFrameworkOwnershipInspectors(source, relativePath, getProvenanceKey) {
-    const isAppSource = /^(?:src\/)?app\//.test(relativePath);
-    const isMetadataEntry = isAppSource && /\/(?:page|layout)\.[cm]?[jt]sx?$/.test(relativePath);
-    const isRenderedEntry = isAppSource && /\/(?:page|layout|template)\.[cm]?[jt]sx?$/.test(relativePath);
-    const isSitemapEntry = isAppSource && /\/sitemap\.[cm]?[jt]s$/.test(relativePath);
-    const isSitemapRoute = isAppSource &&
-        /\/(?:sitemap\.xml|sitemaps\/[^/]+\.xml)\/route\.[cm]?[jt]s$/.test(relativePath);
-    const isRobotsEntry = isAppSource && /\/robots\.[cm]?[jt]s$/.test(relativePath);
-    const neverOwned = () => false;
-    return {
-        metadata: isMetadataEntry
-            ? createOutputOwnershipInspector(source, ({ kind, name }) => kind === "named" && ["metadata", "generateMetadata"].includes(name), getProvenanceKey)
-            : neverOwned,
-        render: isRenderedEntry
-            ? createOutputOwnershipInspector(source, ({ kind }) => kind === "default", getProvenanceKey)
-            : neverOwned,
-        sitemap: isSitemapEntry
-            ? createOutputOwnershipInspector(source, ({ kind }) => kind === "default", getProvenanceKey)
-            : isSitemapRoute
-                ? createOutputOwnershipInspector(source, ({ kind, name }) => kind === "named" && name === "GET", getProvenanceKey)
-                : neverOwned,
-        robots: isRobotsEntry
-            ? createOutputOwnershipInspector(source, ({ kind }) => kind === "default", getProvenanceKey)
-            : neverOwned,
-    };
-}
-function collectProjectImports(root, issues) {
-    const imports = new Set();
-    const executableImports = new Set();
-    const outputOwnedImports = new Set();
-    const executableExports = new Map();
-    const outputOwnedExports = new Map();
-    const frameworkOwnedExports = new Map();
-    for (const file of walkProjectRuntimeFiles(root)) {
-        const relativePath = normalizePath(relative(root, file));
-        const sourceText = readFileSync(file, "utf8");
-        const source = ts.createSourceFile(file, sourceText, ts.ScriptTarget.ES2022, true, file.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
-        const localImportBindings = new Map();
-        for (const statement of source.statements) {
-            if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
-                const moduleName = statement.moduleSpecifier.text;
-                imports.add(moduleName);
-                const clause = statement.importClause;
-                if (clause && !clause.isTypeOnly) {
-                    if (clause.name) {
-                        localImportBindings.set(clause.name.text, {
-                            moduleName,
-                            exportName: "default",
-                            namespace: false,
-                        });
-                    }
-                    const bindings = clause.namedBindings;
-                    if (bindings && ts.isNamespaceImport(bindings)) {
-                        localImportBindings.set(bindings.name.text, {
-                            moduleName,
-                            exportName: null,
-                            namespace: true,
-                        });
-                    }
-                    else if (bindings && ts.isNamedImports(bindings)) {
-                        for (const element of bindings.elements) {
-                            if (!element.isTypeOnly) {
-                                localImportBindings.set(element.name.text, {
-                                    moduleName,
-                                    exportName: (element.propertyName ?? element.name).text,
-                                    namespace: false,
-                                });
-                            }
-                        }
-                    }
-                }
-            }
-            if (ts.isExportDeclaration(statement) &&
-                statement.moduleSpecifier &&
-                ts.isStringLiteral(statement.moduleSpecifier)) {
-                imports.add(statement.moduleSpecifier.text);
-            }
-        }
-        const isShadowedImportReference = createLexicalShadowInspector(source);
-        const resolveImport = (expression) => {
-            if (ts.isIdentifier(expression)) {
-                const binding = localImportBindings.get(expression.text);
-                return binding && !isShadowedImportReference(expression, source)
-                    ? binding
-                    : undefined;
-            }
-            if ((ts.isPropertyAccessExpression(expression) || ts.isPropertyAccessChain(expression)) &&
-                ts.isIdentifier(expression.expression)) {
-                const binding = localImportBindings.get(expression.expression.text);
-                if (binding?.namespace &&
-                    !isShadowedImportReference(expression.expression, source)) {
-                    return { ...binding, exportName: expression.name.text };
-                }
-            }
-            if (ts.isElementAccessExpression(expression) &&
-                ts.isIdentifier(expression.expression) &&
-                expression.argumentExpression &&
-                ts.isStringLiteral(expression.argumentExpression)) {
-                const binding = localImportBindings.get(expression.expression.text);
-                if (binding?.namespace &&
-                    !isShadowedImportReference(expression.expression, source)) {
-                    return { ...binding, exportName: expression.argumentExpression.text };
-                }
-            }
-            return undefined;
-        };
-        const addExportUsage = (target, moduleName, exportName) => {
-            if (!exportName)
-                return;
-            const names = target.get(moduleName) ?? new Set();
-            names.add(exportName);
-            target.set(moduleName, names);
-        };
-        const getProvenanceKey = (expression) => {
-            const binding = resolveImport(expression);
-            return binding?.exportName && binding.moduleName.startsWith("@brandlab-digital/")
-                ? `${binding.moduleName}#${binding.exportName}`
-                : null;
-        };
-        const isOutputOwned = createOutputOwnershipInspector(source, () => true, getProvenanceKey);
-        const isContactClientRuntimeOwned = createContactClientRuntimeOwnershipInspector(source, isOutputOwned);
-        const frameworkOwnership = createNextFrameworkOwnershipInspectors(source, relativePath, getProvenanceKey);
-        const markExecutableImport = (expression, node) => {
-            const binding = resolveImport(expression);
-            if (!binding)
-                return;
-            executableImports.add(binding.moduleName);
-            addExportUsage(executableExports, binding.moduleName, binding.exportName);
-            const isSharedContactClientController = binding.moduleName === "@brandlab-digital/site-next/contact/client" &&
-                binding.exportName === "createContactHttpSubmissionController";
-            if (isOutputOwned(node) ||
-                (isSharedContactClientController && isContactClientRuntimeOwned(node))) {
-                outputOwnedImports.add(binding.moduleName);
-                addExportUsage(outputOwnedExports, binding.moduleName, binding.exportName);
-            }
-            const frameworkOwner = nextFrameworkOwnerForImport(binding.moduleName, binding.exportName);
-            if (frameworkOwner && frameworkOwnership[frameworkOwner](node)) {
-                addExportUsage(frameworkOwnedExports, binding.moduleName, binding.exportName);
-            }
-        };
-        const visit = (node) => {
-            if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
-                const binding = resolveImport(node.expression);
-                if (ts.isCallExpression(node) &&
-                    binding?.moduleName === "@brandlab-digital/site-core/locations" &&
-                    binding.exportName === "defineLocationRouteQuality" &&
-                    node.arguments.length !== 2) {
-                    const location = source.getLineAndCharacterOfPosition(node.getStart(source));
-                    issues.push(configIssue({
-                        ruleId: "brandlab-config-v3-location-proof-binding",
-                        surface: "location-proof",
-                        expected: "defineLocationRouteQuality(input, business.proof) with a verified, explicit proof fact.",
-                        actual: `The location-quality call received ${node.arguments.length} argument(s).`,
-                        remediation: "Bind location proof IDs to the canonical business.proof fact; use unknown or not-applicable with an empty proofAssetIds list when proof is unavailable.",
-                        path: relativePath,
-                        line: location.line + 1,
-                    }));
-                }
-                markExecutableImport(node.expression, node);
-            }
-            else if (ts.isTaggedTemplateExpression(node)) {
-                markExecutableImport(node.tag, node);
-            }
-            else if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
-                markExecutableImport(node.tagName, node);
-            }
-            ts.forEachChild(node, visit);
-        };
-        ts.forEachChild(source, visit);
-        if (getParseDiagnostics(source).length > 0) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v3-source-syntax",
-                surface: "architecture",
-                expected: "Statically parseable project source.",
-                actual: `${relativePath} contains a syntax error.`,
-                remediation: "Correct source syntax before conformance evaluation.",
-                path: relativePath,
-            }));
-        }
-    }
-    return {
-        imports,
-        executableImports,
-        outputOwnedImports,
-        executableExports,
-        outputOwnedExports,
-        frameworkOwnedExports,
-    };
-}
-/**
- * Returns whether an identifier is shadowed by a runtime value declaration
- * between its use site and an owning boundary. Imports are intentionally not
- * indexed: the caller already owns the exact import binding being proved.
- */
-function createLexicalShadowInspector(source) {
-    const namesByScope = new Map();
-    const addName = (scope, name) => {
-        const names = namesByScope.get(scope) ?? new Set();
-        names.add(name);
-        namesByScope.set(scope, names);
-    };
-    const addBindingName = (name, scope) => {
-        if (ts.isIdentifier(name)) {
-            addName(scope, name.text);
-            return;
-        }
-        for (const element of name.elements) {
-            if (ts.isBindingElement(element))
-                addBindingName(element.name, scope);
-        }
-    };
-    const collect = (node) => {
-        if (ts.isVariableDeclaration(node) && !ts.isCatchClause(node.parent)) {
-            addBindingName(node.name, variableDeclarationScope(node, source));
-        }
-        else if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) &&
-            node.name) {
-            addName(nearestLexicalScope(node, source), node.name.text);
-        }
-        else if ((ts.isFunctionExpression(node) || ts.isClassExpression(node)) &&
-            node.name) {
-            addName(node, node.name.text);
-        }
-        else if (ts.isParameter(node)) {
-            const owner = nearestFunctionLike(node);
-            const scope = owner?.body && ts.isBlock(owner.body) ? owner.body : owner ?? source;
-            addBindingName(node.name, scope);
-        }
-        else if (ts.isCatchClause(node) && node.variableDeclaration) {
-            addBindingName(node.variableDeclaration.name, node.block);
-        }
-        ts.forEachChild(node, collect);
-    };
-    collect(source);
-    return (identifier, stopAt) => {
-        let current = identifier.parent;
-        while (current) {
-            if (namesByScope.get(current)?.has(identifier.text))
-                return true;
-            if (current === stopAt)
-                return false;
-            current = current.parent;
-        }
-        return false;
-    };
-}
-/**
- * Finds values that statically flow into an exported module result or a return
- * value of an exported runtime entry point. Merely assigning a candidate call
- * to a local variable (or writing `void candidate`) is deliberately not a
- * runtime-output proof.
- */
-function createOutputOwnershipInspector(source, includeExport = () => true, getProvenanceKey = () => null) {
-    const bindingsByScope = new Map();
-    const outputRegions = new Set();
-    const pendingBindings = [];
-    const visitedBindingUses = new Map();
-    const writesByBinding = new Map();
-    const addBinding = (binding, name) => {
-        const scopeBindings = bindingsByScope.get(binding.scope) ?? new Map();
-        if (!scopeBindings.has(name))
-            scopeBindings.set(name, binding);
-        bindingsByScope.set(binding.scope, scopeBindings);
-    };
-    const collectBindings = (node) => {
-        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
-            addBinding({ declaration: node, scope: variableDeclarationScope(node, source) }, node.name.text);
-        }
-        else if (ts.isFunctionDeclaration(node) && node.name) {
-            addBinding({ declaration: node, scope: nearestLexicalScope(node, source) }, node.name.text);
-        }
-        else if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
-            const owner = nearestFunctionLike(node);
-            const scope = owner && owner.body && ts.isBlock(owner.body) ? owner.body : owner ?? source;
-            addBinding({ declaration: node, scope }, node.name.text);
-        }
-        ts.forEachChild(node, collectBindings);
-    };
-    collectBindings(source);
-    const resolveAt = (identifier) => {
-        let current = identifier.parent;
-        while (current) {
-            const binding = bindingsByScope.get(current)?.get(identifier.text);
-            if (binding)
-                return binding;
-            current = current.parent;
-        }
-        return undefined;
-    };
-    const resolveTopLevel = (name) => bindingsByScope.get(source)?.get(name);
-    const addWrite = (binding, node, value) => {
-        if (!binding)
-            return;
-        const writes = writesByBinding.get(binding) ?? [];
-        writes.push({
-            node,
-            value,
-            executionContext: nearestFunctionLike(node) ?? source,
-        });
-        writesByBinding.set(binding, writes);
-    };
-    const collectWrites = (node) => {
-        if (ts.isBinaryExpression(node) &&
-            node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-            node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) {
-            const target = unwrapExpression(node.left);
-            if (ts.isIdentifier(target)) {
-                addWrite(resolveAt(target), node, node.operatorToken.kind === ts.SyntaxKind.EqualsToken ? node.right : null);
-            }
-        }
-        else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
-            (node.operator === ts.SyntaxKind.PlusPlusToken ||
-                node.operator === ts.SyntaxKind.MinusMinusToken)) {
-            const target = unwrapExpression(node.operand);
-            if (ts.isIdentifier(target))
-                addWrite(resolveAt(target), node, null);
-        }
-        ts.forEachChild(node, collectWrites);
-    };
-    collectWrites(source);
-    const enqueue = (binding, executeFunction = false, useNode = source, allowedProvenanceKeys = null) => {
-        if (!binding)
-            return;
-        pendingBindings.push({ binding, executeFunction, useNode, allowedProvenanceKeys });
-    };
-    const provenanceKeyForNode = (node) => {
-        if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
-            return getProvenanceKey(node.expression);
-        }
-        if (ts.isTaggedTemplateExpression(node))
-            return getProvenanceKey(node.tag);
-        if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
-            return getProvenanceKey(node.tagName);
-        }
-        return null;
-    };
-    const intersectProvenanceKeys = (left, right, allowed = null) => {
-        const intersection = new Set();
-        for (const key of left) {
-            if (right.has(key) && (!allowed || allowed.has(key)))
-                intersection.add(key);
-        }
-        return intersection;
-    };
-    const collectProvenanceKeys = (node) => {
-        const keys = new Set();
-        const visit = (child) => {
-            if (ts.isTypeNode(child))
-                return;
-            const value = ts.isExpression(child) ? unwrapExpression(child) : child;
-            const key = provenanceKeyForNode(value);
-            if (key)
-                keys.add(key);
-            if (ts.isVoidExpression(value))
-                return;
-            if (ts.isConditionalExpression(value)) {
-                const condition = staticTruthiness(value.condition);
-                if (condition === true)
-                    visit(value.whenTrue);
-                else if (condition === false)
-                    visit(value.whenFalse);
-                else {
-                    const common = intersectProvenanceKeys(collectProvenanceKeys(value.whenTrue), collectProvenanceKeys(value.whenFalse));
-                    for (const sharedKey of common)
-                        keys.add(sharedKey);
-                }
-                return;
-            }
-            if (ts.isBinaryExpression(value)) {
-                if (value.operatorToken.kind === ts.SyntaxKind.CommaToken) {
-                    visit(value.right);
-                    return;
-                }
-                if (value.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
-                    const left = staticTruthiness(value.left);
-                    if (left === false)
-                        visit(value.left);
-                    else if (left === true)
-                        visit(value.right);
-                    else {
-                        const common = intersectProvenanceKeys(collectProvenanceKeys(value.left), collectProvenanceKeys(value.right));
-                        for (const sharedKey of common)
-                            keys.add(sharedKey);
-                    }
-                    return;
-                }
-                if (value.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-                    const left = staticTruthiness(value.left);
-                    if (left === true)
-                        visit(value.left);
-                    else if (left === false)
-                        visit(value.right);
-                    else {
-                        const common = intersectProvenanceKeys(collectProvenanceKeys(value.left), collectProvenanceKeys(value.right));
-                        for (const sharedKey of common)
-                            keys.add(sharedKey);
-                    }
-                    return;
-                }
-                if (value.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
-                    const left = staticNullishness(value.left);
-                    if (left === false)
-                        visit(value.left);
-                    else if (left === true)
-                        visit(value.right);
-                    else {
-                        const common = intersectProvenanceKeys(collectProvenanceKeys(value.left), collectProvenanceKeys(value.right));
-                        for (const sharedKey of common)
-                            keys.add(sharedKey);
-                    }
-                    return;
-                }
-            }
-            if (ts.isArrowFunction(value) || ts.isFunctionExpression(value))
-                return;
-            ts.forEachChild(value, visit);
-        };
-        visit(node);
-        return keys;
-    };
-    const addOutputRegion = (node, executeFunction = false, allowedProvenanceKeys = null) => {
-        const visit = (child, executeNestedFunction = false) => {
-            if (ts.isTypeNode(child))
-                return;
-            const value = ts.isExpression(child) ? unwrapExpression(child) : child;
-            const provenanceKey = provenanceKeyForNode(value);
-            if (!provenanceKey ||
-                !allowedProvenanceKeys ||
-                allowedProvenanceKeys.has(provenanceKey))
-                outputRegions.add(value);
-            if (ts.isIdentifier(value) && isRuntimeIdentifierReference(value)) {
-                enqueue(resolveAt(value), executeNestedFunction, value, allowedProvenanceKeys);
-            }
-            if (ts.isVoidExpression(value))
-                return;
-            if (ts.isConditionalExpression(value)) {
-                const condition = staticTruthiness(value.condition);
-                if (condition === true)
-                    visit(value.whenTrue);
-                else if (condition === false)
-                    visit(value.whenFalse);
-                else {
-                    const common = intersectProvenanceKeys(collectProvenanceKeys(value.whenTrue), collectProvenanceKeys(value.whenFalse), allowedProvenanceKeys);
-                    addOutputRegion(value.whenTrue, executeNestedFunction, common);
-                    addOutputRegion(value.whenFalse, executeNestedFunction, common);
-                }
-                return;
-            }
-            if (ts.isBinaryExpression(value)) {
-                if (value.operatorToken.kind === ts.SyntaxKind.CommaToken) {
-                    visit(value.right);
-                    return;
-                }
-                if (value.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
-                    const left = staticTruthiness(value.left);
-                    if (left === false)
-                        visit(value.left);
-                    else if (left === true)
-                        visit(value.right);
-                    else {
-                        const common = intersectProvenanceKeys(collectProvenanceKeys(value.left), collectProvenanceKeys(value.right), allowedProvenanceKeys);
-                        addOutputRegion(value.left, executeNestedFunction, common);
-                        addOutputRegion(value.right, executeNestedFunction, common);
-                    }
-                    return;
-                }
-                if (value.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-                    const left = staticTruthiness(value.left);
-                    if (left === true)
-                        visit(value.left);
-                    else if (left === false)
-                        visit(value.right);
-                    else {
-                        const common = intersectProvenanceKeys(collectProvenanceKeys(value.left), collectProvenanceKeys(value.right), allowedProvenanceKeys);
-                        addOutputRegion(value.left, executeNestedFunction, common);
-                        addOutputRegion(value.right, executeNestedFunction, common);
-                    }
-                    return;
-                }
-                if (value.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
-                    const left = staticNullishness(value.left);
-                    if (left === false)
-                        visit(value.left);
-                    else if (left === true)
-                        visit(value.right);
-                    else {
-                        const common = intersectProvenanceKeys(collectProvenanceKeys(value.left), collectProvenanceKeys(value.right), allowedProvenanceKeys);
-                        addOutputRegion(value.left, executeNestedFunction, common);
-                        addOutputRegion(value.right, executeNestedFunction, common);
-                    }
-                    return;
-                }
-            }
-            if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) {
-                if (executeNestedFunction) {
-                    for (const output of collectFunctionOutputValues(value))
-                        visit(output);
-                }
-                return;
-            }
-            if (ts.isObjectLiteralExpression(value)) {
-                for (const property of value.properties) {
-                    if (ts.isPropertyAssignment(property)) {
-                        visit(property.initializer, executeNestedFunction);
-                    }
-                    else if (ts.isShorthandPropertyAssignment(property))
-                        visit(property.name);
-                    else if (ts.isSpreadAssignment(property))
-                        visit(property.expression);
-                    else if (ts.isMethodDeclaration(property) ||
-                        ts.isGetAccessorDeclaration(property) ||
-                        ts.isSetAccessorDeclaration(property)) {
-                        if (executeNestedFunction) {
-                            for (const output of collectFunctionOutputValues(property))
-                                visit(output);
-                        }
-                    }
-                }
-                return;
-            }
-            if (ts.isFunctionDeclaration(value)) {
-                if (executeNestedFunction) {
-                    for (const output of collectFunctionOutputValues(value))
-                        visit(output);
-                }
-                return;
-            }
-            if (ts.isCallExpression(value) || ts.isNewExpression(value)) {
-                visit(value.expression, true);
-                for (const argument of value.arguments ?? [])
-                    visit(argument);
-                return;
-            }
-            if (ts.isTaggedTemplateExpression(value)) {
-                visit(value.tag, true);
-                visit(value.template);
-                return;
-            }
-            if (ts.isJsxOpeningElement(value) || ts.isJsxSelfClosingElement(value)) {
-                visit(value.tagName, true);
-                visit(value.attributes);
-                return;
-            }
-            ts.forEachChild(value, visit);
-        };
-        visit(node, executeFunction);
-    };
-    const addOutputValue = (node) => addOutputRegion(node, true);
-    for (const statement of source.statements) {
-        if (ts.isVariableStatement(statement) && hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
-            for (const declaration of statement.declarationList.declarations) {
-                if (ts.isIdentifier(declaration.name) &&
-                    includeExport({ kind: "named", name: declaration.name.text })) {
-                    enqueue(resolveTopLevel(declaration.name.text), true, source);
-                }
-            }
-        }
-        else if (ts.isFunctionDeclaration(statement) &&
-            hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
-            const isDefault = hasModifier(statement, ts.SyntaxKind.DefaultKeyword);
-            const descriptor = {
-                kind: isDefault ? "default" : "named",
-                name: isDefault ? "default" : statement.name?.text ?? "anonymous",
-            };
-            if (includeExport(descriptor)) {
-                if (statement.name)
-                    enqueue(resolveTopLevel(statement.name.text), true, source);
-                else
-                    for (const output of collectFunctionOutputValues(statement))
-                        addOutputRegion(output);
-            }
-        }
-        else if (ts.isExportAssignment(statement)) {
-            if (includeExport({ kind: "default", name: "default" })) {
-                const expression = unwrapExpression(statement.expression);
-                if (ts.isIdentifier(expression))
-                    enqueue(resolveTopLevel(expression.text), true, source);
-                else
-                    addOutputValue(expression);
-            }
-        }
-        else if (ts.isExportDeclaration(statement) &&
-            !statement.moduleSpecifier &&
-            statement.exportClause &&
-            ts.isNamedExports(statement.exportClause)) {
-            for (const element of statement.exportClause.elements) {
-                const exportedName = element.name.text;
-                if (includeExport({
-                    kind: exportedName === "default" ? "default" : "named",
-                    name: exportedName,
-                })) {
-                    enqueue(resolveTopLevel((element.propertyName ?? element.name).text), true, source);
-                }
-            }
-        }
-    }
-    while (pendingBindings.length > 0) {
-        const { binding, executeFunction, useNode, allowedProvenanceKeys, } = pendingBindings.shift();
-        const usePosition = useNode === source ? source.end : useNode.getStart(source);
-        const useContext = nearestFunctionLike(useNode) ?? source;
-        const allowedKey = allowedProvenanceKeys
-            ? [...allowedProvenanceKeys].sort().join(",")
-            : "*";
-        const visitKey = `${executeFunction ? 1 : 0}:${usePosition}:${useContext.pos}:${allowedKey}`;
-        const visitedUses = visitedBindingUses.get(binding) ?? new Set();
-        if (visitedUses.has(visitKey))
-            continue;
-        visitedUses.add(visitKey);
-        visitedBindingUses.set(binding, visitedUses);
-        const declarationContext = nearestFunctionLike(binding.declaration) ?? source;
-        const relevantWrites = (writesByBinding.get(binding) ?? []).filter((write) => write.node.getStart(source) < usePosition &&
-            isStaticallyReachableExecutionNode(write.node, write.executionContext) &&
-            (write.executionContext === useContext || write.executionContext === declarationContext));
-        const declarationAfterUse = ts.isVariableDeclaration(binding.declaration) &&
-            binding.declaration.getStart(source) > usePosition;
-        const initialDefinitions = declarationAfterUse
-            ? []
-            : bindingRuntimeOutputValues(binding.declaration);
-        const declarationContextForReachability = nearestFunctionLike(binding.declaration) ?? source;
-        const conditionallyInitialized = ts.isVariableDeclaration(binding.declaration) &&
-            initialDefinitions.length > 0 &&
-            isConditionallyExecutedNode(binding.declaration, declarationContextForReachability);
-        const definitions = conditionallyInitialized
-            ? [null, ...initialDefinitions]
-            : initialDefinitions.length > 0
-                ? [...initialDefinitions]
-                : [null];
-        for (const write of relevantWrites.sort((left, right) => left.node.getStart(source) - right.node.getStart(source))) {
-            if (isConditionallyExecutedNode(write.node, write.executionContext)) {
-                definitions.push(write.value);
-            }
-            else {
-                definitions.splice(0, definitions.length, write.value);
-            }
-        }
-        let definitionKeys = allowedProvenanceKeys;
-        if (definitions.length > 1) {
-            const keySets = definitions.map((definition) => definition ? collectProvenanceKeys(definition) : new Set());
-            const intersection = new Set(keySets[0]);
-            for (const key of intersection) {
-                if (!keySets.slice(1).every((keys) => keys.has(key)))
-                    intersection.delete(key);
-            }
-            if (allowedProvenanceKeys) {
-                for (const key of intersection) {
-                    if (!allowedProvenanceKeys.has(key))
-                        intersection.delete(key);
-                }
-            }
-            if (intersection.size === 0)
-                continue;
-            definitionKeys = intersection;
-        }
-        for (const output of definitions) {
-            if (output)
-                addOutputRegion(output, executeFunction, definitionKeys);
-        }
-    }
-    return (node) => outputRegions.has(node);
-}
-function createContactClientRuntimeOwnershipInspector(source, isOutputOwned) {
-    const reactUseMemo = collectReactUseMemoImports(source);
-    return (candidate) => {
-        if (!ts.isCallExpression(candidate))
-            return false;
-        const memoCallback = nearestFunctionLike(candidate);
-        if (!memoCallback ||
-            !collectFunctionOutputValues(memoCallback).some((output) => ts.isExpression(output) && unwrapExpression(output) === candidate))
-            return false;
-        const callbackValue = outerExpressionWrapper(memoCallback);
-        const memoCall = callbackValue.parent;
-        if (!ts.isCallExpression(memoCall) ||
-            memoCall.arguments.length < 1 ||
-            unwrapExpression(memoCall.arguments[0]) !== memoCallback ||
-            !isReactUseMemoCallee(memoCall.expression, reactUseMemo))
-            return false;
-        const memoValue = outerExpressionWrapper(memoCall);
-        const controllerDeclaration = memoValue.parent;
-        if (!ts.isVariableDeclaration(controllerDeclaration) ||
-            !ts.isIdentifier(controllerDeclaration.name) ||
-            !controllerDeclaration.initializer ||
-            unwrapExpression(controllerDeclaration.initializer) !== memoCall)
-            return false;
-        const component = nearestFunctionLike(controllerDeclaration);
-        if (!component?.body)
-            return false;
-        return returnedFormHandlerUsesController(component, controllerDeclaration, controllerDeclaration.name.text, isOutputOwned);
-    };
-}
-function collectReactUseMemoImports(source) {
-    const named = new Set();
-    const namespaces = new Set();
-    for (const statement of source.statements) {
-        if (!ts.isImportDeclaration(statement) ||
-            !ts.isStringLiteral(statement.moduleSpecifier) ||
-            statement.moduleSpecifier.text !== "react" ||
-            !statement.importClause ||
-            statement.importClause.isTypeOnly)
-            continue;
-        if (statement.importClause.name)
-            namespaces.add(statement.importClause.name.text);
-        const bindings = statement.importClause.namedBindings;
-        if (bindings && ts.isNamespaceImport(bindings)) {
-            namespaces.add(bindings.name.text);
-        }
-        else if (bindings && ts.isNamedImports(bindings)) {
-            for (const element of bindings.elements) {
-                if (!element.isTypeOnly &&
-                    (element.propertyName ?? element.name).text === "useMemo")
-                    named.add(element.name.text);
-            }
-        }
-    }
-    return {
-        named,
-        namespaces,
-        isShadowed: createLexicalShadowInspector(source),
-    };
-}
-function isReactUseMemoCallee(expression, imports) {
-    const callee = unwrapExpression(expression);
-    if (ts.isIdentifier(callee)) {
-        return imports.named.has(callee.text) && !imports.isShadowed(callee, callee.getSourceFile());
-    }
-    if (ts.isPropertyAccessExpression(callee) &&
-        ts.isIdentifier(callee.expression) &&
-        imports.namespaces.has(callee.expression.text) &&
-        !imports.isShadowed(callee.expression, callee.getSourceFile()))
-        return callee.name.text === "useMemo";
-    return Boolean(ts.isElementAccessExpression(callee) &&
-        ts.isIdentifier(callee.expression) &&
-        imports.namespaces.has(callee.expression.text) &&
-        !imports.isShadowed(callee.expression, callee.getSourceFile()) &&
-        callee.argumentExpression &&
-        ts.isStringLiteral(callee.argumentExpression) &&
-        callee.argumentExpression.text === "useMemo");
-}
-function outerExpressionWrapper(node) {
-    let current = node;
-    while (current.parent &&
-        (ts.isParenthesizedExpression(current.parent) ||
-            ts.isAsExpression(current.parent) ||
-            ts.isSatisfiesExpression(current.parent) ||
-            ts.isTypeAssertionExpression(current.parent)) &&
-        current.parent.expression === current)
-        current = current.parent;
-    return current;
-}
-function isStaticallyReachableExecutionNode(node, boundary) {
-    let current = node;
-    while (current !== boundary && current.parent) {
-        const parent = current.parent;
-        if (ts.isIfStatement(parent)) {
-            const condition = staticTruthiness(parent.expression);
-            if (current === parent.thenStatement && condition === false)
-                return false;
-            if (current === parent.elseStatement && condition === true)
-                return false;
-        }
-        else if (ts.isConditionalExpression(parent)) {
-            const condition = staticTruthiness(parent.condition);
-            if (current === parent.whenTrue && condition === false)
-                return false;
-            if (current === parent.whenFalse && condition === true)
-                return false;
-        }
-        else if (ts.isBinaryExpression(parent) && current === parent.right) {
-            if (parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken &&
-                staticTruthiness(parent.left) === false)
-                return false;
-            if (parent.operatorToken.kind === ts.SyntaxKind.BarBarToken &&
-                staticTruthiness(parent.left) === true)
-                return false;
-            if (parent.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken &&
-                staticNullishness(parent.left) === false)
-                return false;
-        }
-        else if ((ts.isWhileStatement(parent) || ts.isForStatement(parent)) &&
-            current === parent.statement) {
-            const condition = ts.isWhileStatement(parent) ? parent.expression : parent.condition;
-            if (condition && staticTruthiness(condition) === false)
-                return false;
-        }
-        else if (ts.isSwitchStatement(parent) && current === parent.caseBlock) {
-            const entryAnalysis = analyzeStaticSwitchEntries(parent);
-            if (entryAnalysis) {
-                const clauseIndex = parent.caseBlock.clauses.findIndex((clause) => node.pos >= clause.pos && node.end <= clause.end);
-                if (!switchClauseIsReachable(parent, clauseIndex, entryAnalysis.entryIndices))
-                    return false;
-            }
-        }
-        else if (ts.isBlock(parent) || ts.isSourceFile(parent)) {
-            const statements = parent.statements;
-            const index = statements.findIndex((statement) => statement === current);
-            if (index >= 0 &&
-                !collectReachableStatementListOutputs(statements.slice(0, index)).canContinue)
-                return false;
-        }
-        current = parent;
-    }
-    return current === boundary;
-}
-function analyzeStaticSwitchEntries(statement) {
-    const discriminant = staticPrimitiveValue(statement.expression);
-    if (!discriminant.known)
-        return undefined;
-    const entryIndices = [];
-    let defaultIndex = -1;
-    let exactMatch = false;
-    for (let index = 0; index < statement.caseBlock.clauses.length; index += 1) {
-        const clause = statement.caseBlock.clauses[index];
-        if (ts.isDefaultClause(clause)) {
-            defaultIndex = index;
-            continue;
-        }
-        const candidate = staticPrimitiveValue(clause.expression);
-        if (!candidate.known) {
-            entryIndices.push(index);
-            continue;
-        }
-        if (candidate.value === discriminant.value) {
-            entryIndices.push(index);
-            exactMatch = true;
-            break;
-        }
-    }
-    if (!exactMatch && defaultIndex >= 0)
-        entryIndices.push(defaultIndex);
-    return {
-        entryIndices: [...new Set(entryIndices)].sort((left, right) => left - right),
-        noMatchPossible: !exactMatch && defaultIndex < 0,
-    };
-}
-function switchClauseIsReachable(statement, clauseIndex, entryIndices) {
-    if (clauseIndex < 0)
-        return false;
-    return entryIndices.some((entryIndex) => {
-        if (entryIndex > clauseIndex)
-            return false;
-        for (let index = entryIndex; index < clauseIndex; index += 1) {
-            if (!switchClauseCanFallThrough(statement.caseBlock.clauses[index], statement)) {
-                return false;
-            }
-        }
-        return true;
-    });
-}
-function switchClauseCanFallThrough(clause, targetSwitch) {
-    for (const statement of clause.statements) {
-        if (statementGuaranteesSwitchExit(statement, targetSwitch))
-            return false;
-    }
-    return true;
-}
-function statementGuaranteesSwitchExit(statement, targetSwitch) {
-    if (ts.isReturnStatement(statement) || ts.isThrowStatement(statement))
-        return true;
-    if (ts.isBreakStatement(statement))
-        return breakExitsSwitch(statement, targetSwitch);
-    if (ts.isBlock(statement)) {
-        return statement.statements.some((nested) => statementGuaranteesSwitchExit(nested, targetSwitch));
-    }
-    if (ts.isLabeledStatement(statement)) {
-        return statementGuaranteesSwitchExit(statement.statement, targetSwitch);
-    }
-    if (ts.isIfStatement(statement)) {
-        const condition = staticTruthiness(statement.expression);
-        if (condition === true) {
-            return statementGuaranteesSwitchExit(statement.thenStatement, targetSwitch);
-        }
-        if (condition === false) {
-            return Boolean(statement.elseStatement &&
-                statementGuaranteesSwitchExit(statement.elseStatement, targetSwitch));
-        }
-        return Boolean(statement.elseStatement &&
-            statementGuaranteesSwitchExit(statement.thenStatement, targetSwitch) &&
-            statementGuaranteesSwitchExit(statement.elseStatement, targetSwitch));
-    }
-    if (ts.isTryStatement(statement)) {
-        if (statement.finallyBlock &&
-            statementGuaranteesSwitchExit(statement.finallyBlock, targetSwitch))
-            return true;
-        return statementGuaranteesSwitchExit(statement.tryBlock, targetSwitch) &&
-            Boolean(statement.catchClause &&
-                statementGuaranteesSwitchExit(statement.catchClause.block, targetSwitch));
-    }
-    if (ts.isWithStatement(statement)) {
-        return statementGuaranteesSwitchExit(statement.statement, targetSwitch);
-    }
-    return false;
-}
-function statementGuaranteesFunctionExit(statement) {
-    if (ts.isReturnStatement(statement) || ts.isThrowStatement(statement))
-        return true;
-    if (ts.isBlock(statement)) {
-        return statement.statements.some(statementGuaranteesFunctionExit);
-    }
-    if (ts.isLabeledStatement(statement) || ts.isWithStatement(statement)) {
-        return statementGuaranteesFunctionExit(statement.statement);
-    }
-    if (ts.isIfStatement(statement)) {
-        const condition = staticTruthiness(statement.expression);
-        if (condition === true)
-            return statementGuaranteesFunctionExit(statement.thenStatement);
-        if (condition === false) {
-            return Boolean(statement.elseStatement &&
-                statementGuaranteesFunctionExit(statement.elseStatement));
-        }
-        return Boolean(statement.elseStatement &&
-            statementGuaranteesFunctionExit(statement.thenStatement) &&
-            statementGuaranteesFunctionExit(statement.elseStatement));
-    }
-    if (ts.isTryStatement(statement)) {
-        if (statement.finallyBlock &&
-            statementGuaranteesFunctionExit(statement.finallyBlock))
-            return true;
-        return statementGuaranteesFunctionExit(statement.tryBlock) &&
-            Boolean(statement.catchClause &&
-                statementGuaranteesFunctionExit(statement.catchClause.block));
-    }
-    return false;
-}
-function breakExitsSwitch(statement, targetSwitch) {
-    if (!statement.label) {
-        let current = statement.parent;
-        while (current) {
-            if (ts.isSwitchStatement(current) ||
-                ts.isForStatement(current) ||
-                ts.isForInStatement(current) ||
-                ts.isForOfStatement(current) ||
-                ts.isWhileStatement(current) ||
-                ts.isDoStatement(current))
-                return current === targetSwitch;
-            current = current.parent;
-        }
-        return false;
-    }
-    let current = statement.parent;
-    while (current) {
-        if (ts.isLabeledStatement(current) &&
-            current.label.text === statement.label.text) {
-            return targetSwitch.pos >= current.statement.pos &&
-                targetSwitch.end <= current.statement.end;
-        }
-        current = current.parent;
-    }
-    return false;
-}
-function staticPrimitiveValue(node) {
-    const value = unwrapExpression(node);
-    if (value.kind === ts.SyntaxKind.TrueKeyword)
-        return { known: true, value: true };
-    if (value.kind === ts.SyntaxKind.FalseKeyword)
-        return { known: true, value: false };
-    if (value.kind === ts.SyntaxKind.NullKeyword)
-        return { known: true, value: null };
-    if (ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value)) {
-        return { known: true, value: value.text };
-    }
-    if (ts.isNumericLiteral(value))
-        return { known: true, value: Number(value.text) };
-    if (ts.isTemplateExpression(value)) {
-        let text = value.head.text;
-        for (const span of value.templateSpans) {
-            const expression = staticPrimitiveValue(span.expression);
-            if (!expression.known)
-                return { known: false };
-            text += String(expression.value) + span.literal.text;
-        }
-        return { known: true, value: text };
-    }
-    if (ts.isVoidExpression(value)) {
-        return staticPrimitiveValue(value.expression).known
-            ? { known: true, value: undefined }
-            : { known: false };
-    }
-    if (ts.isPrefixUnaryExpression(value)) {
-        const operand = staticPrimitiveValue(value.operand);
-        if (!operand.known)
-            return { known: false };
-        if (value.operator === ts.SyntaxKind.PlusToken) {
-            return { known: true, value: Number(operand.value) };
-        }
-        if (value.operator === ts.SyntaxKind.MinusToken) {
-            return { known: true, value: -Number(operand.value) };
-        }
-        if (value.operator === ts.SyntaxKind.ExclamationToken) {
-            return { known: true, value: !primitiveTruthiness(operand.value) };
-        }
-        if (value.operator === ts.SyntaxKind.TildeToken) {
-            return { known: true, value: ~Number(operand.value) };
-        }
-        return { known: false };
-    }
-    if (ts.isConditionalExpression(value)) {
-        const condition = staticPrimitiveValue(value.condition);
-        if (!condition.known)
-            return { known: false };
-        return staticPrimitiveValue(primitiveTruthiness(condition.value) ? value.whenTrue : value.whenFalse);
-    }
-    if (ts.isBinaryExpression(value)) {
-        const left = staticPrimitiveValue(value.left);
-        if (!left.known)
-            return { known: false };
-        if (value.operatorToken.kind === ts.SyntaxKind.CommaToken) {
-            return staticPrimitiveValue(value.right);
-        }
-        if (value.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
-            return primitiveTruthiness(left.value)
-                ? staticPrimitiveValue(value.right)
-                : left;
-        }
-        if (value.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-            return primitiveTruthiness(left.value)
-                ? left
-                : staticPrimitiveValue(value.right);
-        }
-        if (value.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
-            return left.value === null || left.value === undefined
-                ? staticPrimitiveValue(value.right)
-                : left;
-        }
-        const right = staticPrimitiveValue(value.right);
-        if (!right.known)
-            return { known: false };
-        const leftValue = left.value;
-        const rightValue = right.value;
-        switch (value.operatorToken.kind) {
-            case ts.SyntaxKind.PlusToken:
-                return {
-                    known: true,
-                    value: typeof leftValue === "string" || typeof rightValue === "string"
-                        ? String(leftValue) + String(rightValue)
-                        : Number(leftValue) + Number(rightValue),
-                };
-            case ts.SyntaxKind.MinusToken:
-                return { known: true, value: Number(leftValue) - Number(rightValue) };
-            case ts.SyntaxKind.AsteriskToken:
-                return { known: true, value: Number(leftValue) * Number(rightValue) };
-            case ts.SyntaxKind.SlashToken:
-                return { known: true, value: Number(leftValue) / Number(rightValue) };
-            case ts.SyntaxKind.PercentToken:
-                return { known: true, value: Number(leftValue) % Number(rightValue) };
-            case ts.SyntaxKind.AsteriskAsteriskToken:
-                return { known: true, value: Number(leftValue) ** Number(rightValue) };
-            case ts.SyntaxKind.AmpersandToken:
-                return { known: true, value: Number(leftValue) & Number(rightValue) };
-            case ts.SyntaxKind.BarToken:
-                return { known: true, value: Number(leftValue) | Number(rightValue) };
-            case ts.SyntaxKind.CaretToken:
-                return { known: true, value: Number(leftValue) ^ Number(rightValue) };
-            case ts.SyntaxKind.LessThanLessThanToken:
-                return { known: true, value: Number(leftValue) << Number(rightValue) };
-            case ts.SyntaxKind.GreaterThanGreaterThanToken:
-                return { known: true, value: Number(leftValue) >> Number(rightValue) };
-            case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
-                return { known: true, value: Number(leftValue) >>> Number(rightValue) };
-            case ts.SyntaxKind.EqualsEqualsEqualsToken:
-                return { known: true, value: leftValue === rightValue };
-            case ts.SyntaxKind.ExclamationEqualsEqualsToken:
-                return { known: true, value: leftValue !== rightValue };
-            case ts.SyntaxKind.EqualsEqualsToken:
-                return { known: true, value: looselyEqualStaticPrimitives(leftValue, rightValue) };
-            case ts.SyntaxKind.ExclamationEqualsToken:
-                return { known: true, value: !looselyEqualStaticPrimitives(leftValue, rightValue) };
-            case ts.SyntaxKind.LessThanToken:
-                return { known: true, value: compareStaticPrimitives(leftValue, rightValue) < 0 };
-            case ts.SyntaxKind.LessThanEqualsToken:
-                return { known: true, value: compareStaticPrimitives(leftValue, rightValue) <= 0 };
-            case ts.SyntaxKind.GreaterThanToken:
-                return { known: true, value: compareStaticPrimitives(leftValue, rightValue) > 0 };
-            case ts.SyntaxKind.GreaterThanEqualsToken:
-                return { known: true, value: compareStaticPrimitives(leftValue, rightValue) >= 0 };
-            default:
-                return { known: false };
-        }
-    }
-    return { known: false };
-}
-function primitiveTruthiness(value) {
-    return Boolean(value);
-}
-function looselyEqualStaticPrimitives(left, right) {
-    if (left === right)
-        return true;
-    if ((left === null && right === undefined) ||
-        (left === undefined && right === null))
-        return true;
-    if (typeof left === "boolean") {
-        return looselyEqualStaticPrimitives(Number(left), right);
-    }
-    if (typeof right === "boolean") {
-        return looselyEqualStaticPrimitives(left, Number(right));
-    }
-    if (typeof left === "string" && typeof right === "number") {
-        return Number(left) === right;
-    }
-    if (typeof left === "number" && typeof right === "string") {
-        return left === Number(right);
-    }
-    return false;
-}
-function compareStaticPrimitives(left, right) {
-    if (typeof left === "string" && typeof right === "string") {
-        return left < right ? -1 : left > right ? 1 : 0;
-    }
-    const leftNumber = Number(left);
-    const rightNumber = Number(right);
-    if (Number.isNaN(leftNumber) || Number.isNaN(rightNumber))
-        return Number.NaN;
-    return leftNumber < rightNumber ? -1 : leftNumber > rightNumber ? 1 : 0;
-}
-function isConditionallyExecutedNode(node, boundary) {
-    let current = node;
-    while (current !== boundary && current.parent) {
-        const parent = current.parent;
-        if (ts.isIfStatement(parent)) {
-            const condition = staticTruthiness(parent.expression);
-            if ((current === parent.thenStatement && condition === undefined) ||
-                (current === parent.elseStatement && condition === undefined))
-                return true;
-        }
-        else if (ts.isConditionalExpression(parent)) {
-            if ((current === parent.whenTrue || current === parent.whenFalse) &&
-                staticTruthiness(parent.condition) === undefined)
-                return true;
-        }
-        else if (ts.isBinaryExpression(parent) && current === parent.right) {
-            if ((parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ||
-                parent.operatorToken.kind === ts.SyntaxKind.BarBarToken) &&
-                staticTruthiness(parent.left) === undefined)
-                return true;
-            if (parent.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken &&
-                staticNullishness(parent.left) === undefined)
-                return true;
-        }
-        else if (ts.isWhileStatement(parent) ||
-            ts.isForStatement(parent) ||
-            ts.isForInStatement(parent) ||
-            ts.isForOfStatement(parent) ||
-            ts.isSwitchStatement(parent) ||
-            ts.isTryStatement(parent) ||
-            ts.isCatchClause(parent)) {
-            return true;
-        }
-        current = parent;
-    }
-    return current !== boundary;
-}
-function returnedFormHandlerUsesController(component, controllerDeclaration, controllerName, isOutputOwned) {
-    let ownsHandler = false;
-    const visit = (node) => {
-        if (ownsHandler || (node !== component && ts.isFunctionLike(node)))
-            return;
-        if ((ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) &&
-            ts.isIdentifier(node.tagName) &&
-            node.tagName.text === "form" &&
-            isOutputOwned(node)) {
-            const onSubmit = node.attributes.properties.find((property) => ts.isJsxAttribute(property) &&
-                ts.isIdentifier(property.name) &&
-                property.name.text === "onSubmit");
-            if (onSubmit && ts.isJsxAttribute(onSubmit) && onSubmit.initializer &&
-                ts.isJsxExpression(onSubmit.initializer) && onSubmit.initializer.expression) {
-                const handler = resolveComponentHandler(component, onSubmit.initializer.expression);
-                ownsHandler = Boolean(handler &&
-                    !hasReachableControllerWriteBefore(component, controllerName, node, controllerDeclaration) &&
-                    handlerCallsControllerSubmit(handler, controllerName));
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(component);
-    return ownsHandler;
-}
-function resolveComponentHandler(component, expression) {
-    const handler = unwrapExpression(expression);
-    if (ts.isArrowFunction(handler) || ts.isFunctionExpression(handler))
-        return handler;
-    if (!ts.isIdentifier(handler) || !component.body || !ts.isBlock(component.body))
-        return null;
-    for (const statement of component.body.statements) {
-        if (ts.isFunctionDeclaration(statement) && statement.name?.text === handler.text) {
-            return statement;
-        }
-        if (!ts.isVariableStatement(statement))
-            continue;
-        for (const declaration of statement.declarationList.declarations) {
-            if (ts.isIdentifier(declaration.name) &&
-                declaration.name.text === handler.text &&
-                declaration.initializer &&
-                (ts.isArrowFunction(unwrapExpression(declaration.initializer)) ||
-                    ts.isFunctionExpression(unwrapExpression(declaration.initializer))))
-                return unwrapExpression(declaration.initializer);
-        }
-    }
-    return null;
-}
-function handlerCallsControllerSubmit(handler, controllerName) {
-    if (handler.parameters.some((parameter) => ts.isIdentifier(parameter.name) && parameter.name.text === controllerName))
-        return false;
-    let callsSubmit = false;
-    let shadowsController = false;
-    const visit = (node) => {
-        if (callsSubmit || (node !== handler && ts.isFunctionLike(node)))
-            return;
-        if (ts.isVariableDeclaration(node) &&
-            ts.isIdentifier(node.name) &&
-            node.name.text === controllerName) {
-            shadowsController = true;
-            return;
-        }
-        if (ts.isCallExpression(node)) {
-            const callee = unwrapExpression(node.expression);
-            if (ts.isPropertyAccessExpression(callee) &&
-                ts.isIdentifier(callee.expression) &&
-                callee.expression.text === controllerName &&
-                callee.name.text === "submit" &&
-                isStaticallyReachableExecutionNode(node, handler) &&
-                !hasReachableControllerWriteBefore(handler, controllerName, node))
-                callsSubmit = true;
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(handler);
-    return callsSubmit && !shadowsController;
-}
-function hasReachableControllerWriteBefore(owner, controllerName, reference, declarationToIgnore) {
-    const source = owner.getSourceFile();
-    const referencePosition = reference.getStart(source);
-    let found = false;
-    const visit = (node) => {
-        if (found ||
-            node.getStart(source) >= referencePosition ||
-            (node !== owner && ts.isFunctionLike(node)))
-            return;
-        if (ts.isBinaryExpression(node) &&
-            node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
-            node.operatorToken.kind <= ts.SyntaxKind.LastAssignment) {
-            const target = unwrapExpression(node.left);
-            if (ts.isIdentifier(target) &&
-                target.text === controllerName &&
-                isStaticallyReachableExecutionNode(node, owner))
-                found = true;
-        }
-        else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
-            (node.operator === ts.SyntaxKind.PlusPlusToken ||
-                node.operator === ts.SyntaxKind.MinusMinusToken)) {
-            const target = unwrapExpression(node.operand);
-            if (ts.isIdentifier(target) &&
-                target.text === controllerName &&
-                isStaticallyReachableExecutionNode(node, owner))
-                found = true;
-        }
-        else if (ts.isVariableDeclaration(node) &&
-            node !== declarationToIgnore &&
-            ts.isIdentifier(node.name) &&
-            node.name.text === controllerName &&
-            isStaticallyReachableExecutionNode(node, owner)) {
-            found = true;
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(owner);
-    return found;
-}
-function nearestLexicalScope(node, source) {
-    let current = node.parent;
-    while (current && current !== source) {
-        if (ts.isBlock(current) || ts.isCaseBlock(current))
-            return current;
-        current = current.parent;
-    }
-    return source;
-}
-function variableDeclarationScope(declaration, source) {
-    const declarationList = ts.isVariableDeclarationList(declaration.parent)
-        ? declaration.parent
-        : null;
-    if (declarationList && (declarationList.flags & ts.NodeFlags.BlockScoped) !== 0) {
-        return nearestLexicalScope(declaration, source);
-    }
-    const owner = nearestFunctionLike(declaration);
-    if (owner)
-        return owner.body && ts.isBlock(owner.body) ? owner.body : owner;
-    return source;
-}
-function nearestFunctionLike(node) {
-    let current = node.parent;
-    while (current) {
-        if (ts.isFunctionDeclaration(current) ||
-            ts.isMethodDeclaration(current) ||
-            ts.isGetAccessorDeclaration(current) ||
-            ts.isSetAccessorDeclaration(current) ||
-            ts.isConstructorDeclaration(current) ||
-            ts.isFunctionExpression(current) ||
-            ts.isArrowFunction(current)) {
-            return current;
-        }
-        current = current.parent;
-    }
-    return undefined;
-}
-function hasModifier(node, kind) {
-    return ts.canHaveModifiers(node) && Boolean(ts.getModifiers(node)?.some((modifier) => modifier.kind === kind));
-}
-function bindingRuntimeOutputValues(declaration) {
-    if (ts.isVariableDeclaration(declaration)) {
-        return declaration.initializer ? [declaration.initializer] : [];
-    }
-    if (ts.isFunctionDeclaration(declaration))
-        return [declaration];
-    return [];
-}
-function collectFunctionOutputValues(declaration) {
-    if (!declaration.body)
-        return [];
-    if (!ts.isBlock(declaration.body))
-        return [declaration.body];
-    return collectReachableStatementListOutputs(declaration.body.statements).outputs;
-}
-function collectReachableStatementListOutputs(statements) {
-    const outputs = [];
-    let canContinue = true;
-    for (const statement of statements) {
-        if (!canContinue)
-            break;
-        const result = collectReachableStatementOutputs(statement);
-        outputs.push(...result.outputs);
-        canContinue = result.canContinue;
-    }
-    return { outputs, canContinue };
-}
-function collectReachableStatementOutputs(statement) {
-    if (ts.isReturnStatement(statement)) {
-        return {
-            outputs: statement.expression ? [statement.expression] : [],
-            canContinue: false,
-        };
-    }
-    if (ts.isThrowStatement(statement))
-        return { outputs: [], canContinue: false };
-    if (ts.isBlock(statement))
-        return collectReachableStatementListOutputs(statement.statements);
-    if (ts.isIfStatement(statement)) {
-        const condition = staticTruthiness(statement.expression);
-        const whenTrue = condition === false
-            ? { outputs: [], canContinue: false }
-            : collectReachableStatementOutputs(statement.thenStatement);
-        const whenFalse = condition === true
-            ? { outputs: [], canContinue: false }
-            : statement.elseStatement
-                ? collectReachableStatementOutputs(statement.elseStatement)
-                : { outputs: [], canContinue: true };
-        if (condition === true)
-            return whenTrue;
-        if (condition === false)
-            return whenFalse;
-        return {
-            outputs: [...whenTrue.outputs, ...whenFalse.outputs],
-            canContinue: whenTrue.canContinue || whenFalse.canContinue,
-        };
-    }
-    if (ts.isWhileStatement(statement)) {
-        if (staticTruthiness(statement.expression) === false) {
-            return { outputs: [], canContinue: true };
-        }
-        return {
-            outputs: collectReachableStatementOutputs(statement.statement).outputs,
-            canContinue: true,
-        };
-    }
-    if (ts.isForStatement(statement)) {
-        if (statement.condition && staticTruthiness(statement.condition) === false) {
-            return { outputs: [], canContinue: true };
-        }
-        return {
-            outputs: collectReachableStatementOutputs(statement.statement).outputs,
-            canContinue: true,
-        };
-    }
-    if (ts.isDoStatement(statement)) {
-        return {
-            outputs: collectReachableStatementOutputs(statement.statement).outputs,
-            canContinue: true,
-        };
-    }
-    if (ts.isLabeledStatement(statement)) {
-        return collectReachableStatementOutputs(statement.statement);
-    }
-    if (ts.isTryStatement(statement)) {
-        const attempted = collectReachableStatementListOutputs(statement.tryBlock.statements);
-        const recovered = statement.catchClause
-            ? collectReachableStatementListOutputs(statement.catchClause.block.statements)
-            : { outputs: [], canContinue: false };
-        const finalized = statement.finallyBlock
-            ? collectReachableStatementListOutputs(statement.finallyBlock.statements)
-            : { outputs: [], canContinue: true };
-        if (statement.finallyBlock && !finalized.canContinue)
-            return finalized;
-        return {
-            outputs: [...attempted.outputs, ...recovered.outputs, ...finalized.outputs],
-            canContinue: finalized.canContinue &&
-                (attempted.canContinue || (statement.catchClause ? recovered.canContinue : false)),
-        };
-    }
-    if (ts.isSwitchStatement(statement)) {
-        const entryAnalysis = analyzeStaticSwitchEntries(statement);
-        if (entryAnalysis) {
-            const outputs = statement.caseBlock.clauses.flatMap((clause, index) => switchClauseIsReachable(statement, index, entryAnalysis.entryIndices)
-                ? collectReachableStatementListOutputs(clause.statements).outputs
-                : []);
-            const entryCanContinue = entryAnalysis.entryIndices.some((entryIndex) => {
-                for (let index = entryIndex; index < statement.caseBlock.clauses.length; index += 1) {
-                    const clause = statement.caseBlock.clauses[index];
-                    if (!switchClauseCanFallThrough(clause, statement)) {
-                        return !clause.statements.some(statementGuaranteesFunctionExit);
-                    }
-                }
-                return true;
-            });
-            return {
-                outputs,
-                canContinue: entryAnalysis.noMatchPossible || entryCanContinue,
-            };
-        }
-        const clauseResults = statement.caseBlock.clauses.map((clause) => collectReachableStatementListOutputs(clause.statements));
-        return {
-            outputs: clauseResults.flatMap((result) => result.outputs),
-            canContinue: clauseResults.length === 0 ||
-                !statement.caseBlock.clauses.some(ts.isDefaultClause) ||
-                clauseResults.some((result) => result.canContinue),
-        };
-    }
-    if (ts.isWithStatement(statement)) {
-        return collectReachableStatementOutputs(statement.statement);
-    }
-    return { outputs: [], canContinue: true };
-}
-function staticTruthiness(node) {
-    const value = unwrapExpression(node);
-    if (value.kind === ts.SyntaxKind.TrueKeyword)
-        return true;
-    if (value.kind === ts.SyntaxKind.FalseKeyword ||
-        value.kind === ts.SyntaxKind.NullKeyword ||
-        ts.isVoidExpression(value))
-        return false;
-    if (ts.isStringLiteral(value) || ts.isNoSubstitutionTemplateLiteral(value)) {
-        return value.text.length > 0;
-    }
-    if (ts.isNumericLiteral(value))
-        return Number(value.text) !== 0;
-    if (ts.isPrefixUnaryExpression(value)) {
-        if (value.operator === ts.SyntaxKind.ExclamationToken) {
-            const operand = staticTruthiness(value.operand);
-            return operand === undefined ? undefined : !operand;
-        }
-        if (value.operator === ts.SyntaxKind.PlusToken ||
-            value.operator === ts.SyntaxKind.MinusToken) {
-            const operand = unwrapExpression(value.operand);
-            if (ts.isNumericLiteral(operand))
-                return Number(operand.text) !== 0;
-        }
-    }
-    if (ts.isConditionalExpression(value)) {
-        const condition = staticTruthiness(value.condition);
-        if (condition === true)
-            return staticTruthiness(value.whenTrue);
-        if (condition === false)
-            return staticTruthiness(value.whenFalse);
-    }
-    if (ts.isBinaryExpression(value)) {
-        if (value.operatorToken.kind === ts.SyntaxKind.CommaToken) {
-            return staticTruthiness(value.right);
-        }
-        if (value.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
-            const left = staticTruthiness(value.left);
-            if (left === false)
-                return false;
-            if (left === true)
-                return staticTruthiness(value.right);
-        }
-        if (value.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
-            const left = staticTruthiness(value.left);
-            if (left === true)
-                return true;
-            if (left === false)
-                return staticTruthiness(value.right);
-        }
-        if (value.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
-            const left = staticNullishness(value.left);
-            if (left === true)
-                return staticTruthiness(value.right);
-            if (left === false)
-                return staticTruthiness(value.left);
-        }
-    }
-    return undefined;
-}
-function staticNullishness(node) {
-    const value = unwrapExpression(node);
-    if (value.kind === ts.SyntaxKind.NullKeyword || ts.isVoidExpression(value))
-        return true;
-    if (value.kind === ts.SyntaxKind.TrueKeyword ||
-        value.kind === ts.SyntaxKind.FalseKeyword ||
-        ts.isStringLiteral(value) ||
-        ts.isNoSubstitutionTemplateLiteral(value) ||
-        ts.isNumericLiteral(value) ||
-        ts.isObjectLiteralExpression(value) ||
-        ts.isArrayLiteralExpression(value) ||
-        ts.isFunctionExpression(value) ||
-        ts.isArrowFunction(value) ||
-        ts.isClassExpression(value))
-        return false;
-    if (ts.isConditionalExpression(value)) {
-        const condition = staticTruthiness(value.condition);
-        if (condition === true)
-            return staticNullishness(value.whenTrue);
-        if (condition === false)
-            return staticNullishness(value.whenFalse);
-    }
-    if (ts.isBinaryExpression(value) && value.operatorToken.kind === ts.SyntaxKind.CommaToken) {
-        return staticNullishness(value.right);
-    }
-    return undefined;
-}
-function isRuntimeIdentifierReference(identifier) {
-    const parent = identifier.parent;
-    if (ts.isVoidExpression(parent)) {
-        return false;
-    }
-    if (((ts.isVariableDeclaration(parent) ||
-        ts.isFunctionDeclaration(parent) ||
-        ts.isFunctionExpression(parent) ||
-        ts.isParameter(parent) ||
-        ts.isClassDeclaration(parent) ||
-        ts.isClassExpression(parent) ||
-        ts.isBindingElement(parent)) && parent.name === identifier) ||
-        ((ts.isPropertyAccessExpression(parent) || ts.isPropertyAccessChain(parent)) && parent.name === identifier) ||
-        ((ts.isPropertyAssignment(parent) ||
-            ts.isMethodDeclaration(parent) ||
-            ts.isGetAccessorDeclaration(parent) ||
-            ts.isSetAccessorDeclaration(parent)) && parent.name === identifier) ||
-        ts.isImportSpecifier(parent) ||
-        ts.isImportClause(parent) ||
-        ts.isNamespaceImport(parent) ||
-        ts.isExportSpecifier(parent) ||
-        ts.isLabeledStatement(parent) ||
-        ts.isBreakOrContinueStatement(parent)) {
-        return false;
-    }
-    return true;
-}
-function addProtectedImplementationIssues(root, issues) {
-    for (const file of walkProjectRuntimeFiles(root)) {
-        const relativePath = normalizePath(relative(root, file));
-        const source = readFileSync(file, "utf8");
-        for (const rule of PROTECTED_LOCAL_PATTERNS) {
-            const match = rule.pattern.exec(source);
-            if (!match || match.index === undefined)
-                continue;
-            const line = source.slice(0, match.index).split("\n").length;
-            issues.push(configIssue({
-                ruleId: rule.ruleId,
-                surface: rule.surface,
-                expected: rule.expected,
-                actual: `A protected local implementation was found in ${relativePath}.`,
-                remediation: rule.ruleId === "brandlab-config-v3-url-derived-breadcrumbs"
-                    ? "Use BrandlabRouteBreadcrumbs with the typed route catalog; keep path labels only as a development fallback."
-                    : "Keep only the thin project binding and consume the shared runtime.",
-                severity: "severity" in rule ? rule.severity : "blocker",
-                path: relativePath,
-                line,
-            }));
-        }
-    }
-}
-function walkSourceFiles(root) {
-    if (!existsSync(root))
-        return [];
-    const files = [];
-    const visit = (directory) => {
-        for (const entry of readdirSync(directory, { withFileTypes: true })) {
-            if (entry.isDirectory()) {
-                if (!SKIPPED_DIRECTORIES.has(entry.name))
-                    visit(join(directory, entry.name));
-            }
-            else if (entry.isFile() && SOURCE_EXTENSIONS.has(extname(entry.name))) {
-                files.push(join(directory, entry.name));
-            }
-        }
-    };
-    visit(root);
-    return files.sort();
-}
-const RUNTIME_SOURCE_ROOTS = ["src", "app", "pages", "components", "lib"];
-const NON_RUNTIME_DIRECTORIES = new Set([
-    "__tests__",
-    "__mocks__",
-    "fixtures",
-    "stories",
-    "test",
-    "tests",
-]);
-const NON_RUNTIME_FILE_PATTERN = /(?:^|\.)(?:test|spec|stories?|fixtures?)\.[^.]+$/i;
-function walkProjectRuntimeFiles(root) {
-    const files = new Set();
-    for (const directory of RUNTIME_SOURCE_ROOTS) {
-        for (const file of walkSourceFiles(join(root, directory))) {
-            const relativePath = normalizePath(relative(root, file));
-            if (relativePath.split("/").some((segment) => NON_RUNTIME_DIRECTORIES.has(segment)) ||
-                NON_RUNTIME_FILE_PATTERN.test(relativePath)) {
-                continue;
-            }
-            files.add(file);
-        }
-    }
-    for (const name of ["next.config.ts", "next.config.mjs", "next.config.js", "next.config.cjs"]) {
-        const file = join(root, name);
-        if (existsSync(file))
-            files.add(file);
-    }
-    return [...files].sort();
-}
-function configIssue(options) {
-    return {
-        ruleId: options.ruleId,
-        surface: options.surface ?? "configuration",
-        severity: options.severity ?? "blocker",
-        evidenceKind: "static",
-        expected: options.expected,
-        actual: options.actual,
-        remediation: options.remediation,
-        ...(options.path ? { path: options.path } : {}),
-        ...(options.line ? { line: options.line } : {}),
-    };
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function normalizePath(value) {
-    return value.split(/[/\\]/).join("/");
-}
-function getParseDiagnostics(source) {
-    return source.parseDiagnostics ?? [];
-}
-/** SHA-256 evidence for the exact canonical serializer output produced at runtime. */
-export function digestBrandlabPlatformContractSerialization(serialized) {
-    if (!serialized)
-        throw new Error("Serialized platform contract cannot be empty.");
-    let parsed;
-    try {
-        parsed = JSON.parse(serialized);
-    }
-    catch {
-        throw new Error("Serialized platform contract must be valid JSON.");
-    }
-    if (!isRecord(parsed) || parsed.schemaVersion !== "brandlab.platform-contract.v1") {
-        throw new Error("Serialized platform contract has an unsupported schemaVersion.");
-    }
-    if (JSON.stringify(canonicalizeJsonValue(parsed)) !== serialized) {
-        throw new Error("Platform contract evidence must use the canonical serializer output.");
-    }
-    return createHash("sha256").update(serialized).digest("hex");
-}
-function canonicalizeJsonValue(value) {
-    if (Array.isArray(value))
-        return value.map(canonicalizeJsonValue);
-    if (!isRecord(value))
-        return value;
-    return Object.fromEntries(Object.entries(value)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, child]) => [key, canonicalizeJsonValue(child)]));
-}
-//# sourceMappingURL=project-config-v3.js.map