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

package/dist/project-config-v2-contract.js

@@ -1,926 +0,0 @@
-/**
- * Immutable Project Config v2 evaluator snapshot.
- *
- * This module preserves the exact 1.0.0-rc.1 maintenance contract. Newer
- * configuration requirements belong in project-config.ts and must never be
- * applied retroactively to a project whose installed release declares
- * project-config-v2.
- */
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { extname, join, relative } from "node:path";
-import * as ts from "typescript";
-export const BRANDLAB_CONFIG_V2_RULESET_ID = "project-config-v2@1.0.0-rc.1:5d6c4a9a27abd65e5a8e55d5f66145ff499ead7d";
-export const BRANDLAB_CONFIG_V2_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 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 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-core/business", "business"],
-    ["@brandlab-digital/site-core/routes", "routes"],
-    ["@brandlab-digital/site-next/metadata", "metadata"],
-    ["@brandlab-digital/site-next/schema", "schema"],
-    ["@brandlab-digital/site-next/breadcrumbs", "breadcrumbs"],
-    ["@brandlab-digital/site-next/sitemaps", "sitemap"],
-    ["@brandlab-digital/site-next/robots", "robots"],
-    ["@brandlab-digital/site-next/contact/server", "contact"],
-    ["@brandlab-digital/site-next/contact/client", "contact"],
-    ["@brandlab-digital/site-next/analytics", "analytics"],
-    ["@brandlab-digital/site-next/ui", "accessibility"],
-];
-const PROTECTED_LOCAL_PATTERNS = [
-    {
-        ruleId: "brandlab-config-v2-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-v2-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-v2-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-v2-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 inspectBrandlabConfigV2(root) {
-    const issues = [];
-    const configPath = join(root, "brandlab.config.ts");
-    const { imports, executableImports } = collectProjectImports(root, issues);
-    if (!existsSync(configPath)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v2-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 { config: null, imports, executableImports, 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-v2-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-v2-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-v2-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 { config: null, imports, executableImports, 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-v2-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 { config: null, imports, executableImports, issues };
-    }
-    const config = validateConfigValue(value, issues);
-    if (config) {
-        addImportContractIssues(config, imports, executableImports, issues);
-    }
-    addProtectedImplementationIssues(root, issues);
-    return { config, imports, executableImports, 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-v2-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-v2-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 (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(projectId)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v2-project-id",
-            expected: "A canonical lowercase kebab-case projectId.",
-            actual: projectId ? `Invalid projectId "${projectId}".` : "projectId is missing.",
-            remediation: "Use the canonical entity identifier.",
-            path: "brandlab.config.ts",
-        }));
-    }
-    if (!BRANDLAB_CONFIG_V2_PROFILES.includes(profile)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v2-profile",
-            expected: `One supported profile: ${BRANDLAB_CONFIG_V2_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-v2-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-v2-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-v2-route-family-duplicate", "routes.families", issues);
-        validateAliases(routes.aliases, issues);
-    }
-    if (!searchCertification) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v2-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-v2-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-v2-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-v2-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 capabilities = value.capabilities === undefined
-        ? {}
-        : isRecord(value.capabilities)
-            ? value.capabilities
-            : null;
-    if (capabilities === null) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v2-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;
-    return {
-        projectId,
-        profile: profile,
-        routes: { families },
-        capabilities: {
-            blogAdapter: typeof blog?.adapter === "string" ? blog.adapter : null,
-            contactEnabled: contact !== null,
-        },
-    };
-}
-function validateAliases(value, issues) {
-    if (value === undefined)
-        return;
-    if (!Array.isArray(value)) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v2-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-v2-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-v2-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-v2-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-v2-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-v2-route-alias-duplicate", "routes.aliases.from", issues);
-    const chain = fromPaths.find((from) => toPaths.includes(from));
-    if (chain) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v2-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"]), 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-v2-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-v2-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-v2-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-v2-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",
-                }));
-            }
-        }
-    }
-}
-function addShapeIssue(surface, issues) {
-    issues.push(configIssue({
-        ruleId: `brandlab-config-v2-${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-v2-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-v2-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-v2-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-v2-sitemap-family-duplicate", "sitemap.families", issues);
-        if (families.some((path) => !isRootRelativePath(path))) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v2-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-v2-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-v2-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-v2-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-v2-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-v2-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-v2-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-v2-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-v2-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(config, imports, executableImports, issues) {
-    for (const [moduleName, surface] of REQUIRED_KERNEL_IMPORTS) {
-        const acceptedModules = moduleName === "@brandlab-digital/site-next/contact/server"
-            ? [moduleName, "@brandlab-digital/site-next/contact/route"]
-            : [moduleName];
-        const importedModule = acceptedModules.find((candidate) => imports.has(candidate));
-        const executableModule = acceptedModules.find((candidate) => executableImports.has(candidate));
-        const expectedModule = acceptedModules.join(" or ");
-        if (!importedModule) {
-            issues.push(configIssue({
-                ruleId: `brandlab-config-v2-shared-${surface}`,
-                surface,
-                expected: `An import from ${expectedModule}.`,
-                actual: "No project source file consumes the shared executable contract.",
-                remediation: `Replace the local ${surface} implementation with ${expectedModule}.`,
-            }));
-        }
-        else if (!executableModule) {
-            issues.push(configIssue({
-                ruleId: `brandlab-config-v2-shared-${surface}-unused`,
-                surface,
-                expected: `An executable call or rendered component from ${expectedModule}.`,
-                actual: `${importedModule} is only imported or re-exported; no executable consumption was found.`,
-                remediation: `Wire the shared ${surface} contract into the rendered or server execution path.`,
-            }));
-        }
-    }
-    if (config.capabilities.blogAdapter &&
-        config.capabilities.blogAdapter !== "none" &&
-        !imports.has("@brandlab-digital/site-next/blog")) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v2-shared-blog",
-            surface: "blog",
-            expected: "An import from @brandlab-digital/site-next/blog.",
-            actual: `The ${config.capabilities.blogAdapter} blog capability does not consume the shared adapter.`,
-            remediation: "Use the shared blog adapter while retaining project-owned content and design.",
-        }));
-    }
-    else if (config.capabilities.blogAdapter &&
-        config.capabilities.blogAdapter !== "none" &&
-        !executableImports.has("@brandlab-digital/site-next/blog")) {
-        issues.push(configIssue({
-            ruleId: "brandlab-config-v2-shared-blog-unused",
-            surface: "blog",
-            expected: "An executable shared blog adapter call.",
-            actual: "The blog package is imported but no shared adapter is executed.",
-            remediation: "Construct the configured blog adapter through @brandlab-digital/site-next/blog.",
-        }));
-    }
-}
-function collectProjectImports(root, issues) {
-    const imports = new Set();
-    const executableImports = new Set();
-    for (const file of walkSourceFiles(join(root, "src"))) {
-        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 localImportModules = 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)
-                        localImportModules.set(clause.name.text, moduleName);
-                    const bindings = clause.namedBindings;
-                    if (bindings && ts.isNamespaceImport(bindings)) {
-                        localImportModules.set(bindings.name.text, moduleName);
-                    }
-                    else if (bindings && ts.isNamedImports(bindings)) {
-                        for (const element of bindings.elements) {
-                            if (!element.isTypeOnly)
-                                localImportModules.set(element.name.text, moduleName);
-                        }
-                    }
-                }
-            }
-            if (ts.isExportDeclaration(statement) &&
-                statement.moduleSpecifier &&
-                ts.isStringLiteral(statement.moduleSpecifier)) {
-                imports.add(statement.moduleSpecifier.text);
-            }
-        }
-        const markExecutableImport = (expression) => {
-            let current = expression;
-            while (ts.isPropertyAccessExpression(current) ||
-                ts.isElementAccessExpression(current)) {
-                current = current.expression;
-            }
-            if (ts.isIdentifier(current)) {
-                const moduleName = localImportModules.get(current.text);
-                if (moduleName)
-                    executableImports.add(moduleName);
-            }
-        };
-        const visit = (node) => {
-            if (ts.isCallExpression(node) || ts.isNewExpression(node)) {
-                markExecutableImport(node.expression);
-            }
-            else if (ts.isTaggedTemplateExpression(node)) {
-                markExecutableImport(node.tag);
-            }
-            else if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
-                markExecutableImport(node.tagName);
-            }
-            ts.forEachChild(node, visit);
-        };
-        ts.forEachChild(source, visit);
-        if (getParseDiagnostics(source).length > 0) {
-            issues.push(configIssue({
-                ruleId: "brandlab-config-v2-source-syntax",
-                surface: "architecture",
-                expected: "Statically parseable project source.",
-                actual: `${normalizePath(relative(root, file))} contains a syntax error.`,
-                remediation: "Correct source syntax before conformance evaluation.",
-                path: normalizePath(relative(root, file)),
-            }));
-        }
-    }
-    return { imports, executableImports };
-}
-function addProtectedImplementationIssues(root, issues) {
-    for (const file of walkSourceFiles(join(root, "src"))) {
-        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-v2-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();
-}
-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 ?? [];
-}
-//# sourceMappingURL=project-config-v2-contract.js.map