infinite-tag 0.1.1

package/dist/src/providers/x.js

@@ -0,0 +1,76 @@
+import { jsLiteral, validateXEventTagIds, validateXPixelId } from "./validate.js";
+function frameworkEnvKeys(framework) {
+    switch (framework) {
+        case "next-app-router":
+        case "next-pages-router":
+            return ["NEXT_PUBLIC_X_EVENT_TAG_IDS", "NEXT_PUBLIC_X_PIXEL_ID"];
+        case "vite-react":
+            return ["VITE_X_EVENT_TAG_IDS", "VITE_X_PIXEL_ID"];
+        case "static-html":
+            return [];
+    }
+}
+export const xProviderAdapter = {
+    id: "x",
+    displayName: "X",
+    envKeys(framework) {
+        return frameworkEnvKeys(framework);
+    },
+    plan(framework, artifact) {
+        const pixelId = artifact && typeof artifact === "object" && "pixelId" in artifact ? artifact.pixelId : undefined;
+        const eventTagIds = artifact && typeof artifact === "object" && "eventTagIds" in artifact
+            ? artifact.eventTagIds
+            : undefined;
+        const blockers = [];
+        const pixelError = validateXPixelId(pixelId);
+        if (pixelError) {
+            blockers.push(pixelError);
+        }
+        const tagsError = validateXEventTagIds(eventTagIds);
+        if (tagsError) {
+            blockers.push(tagsError);
+        }
+        return {
+            assumptions: blockers.length === 0
+                ? ["X wiring will use only the public pixelId and eventTagIds artifacts."]
+                : [],
+            blockers,
+            instructions: blockers.length === 0
+                ? [
+                    {
+                        path: frameworkInstructionPath(framework),
+                        action: framework === "static-html" ? "modify" : "create",
+                        description: framework === "static-html"
+                            ? "Inject the X public pixel bootstrap into index.html."
+                            : "Add the X public pixel bootstrap to the managed analytics module.",
+                        provider: "x",
+                        snippet: framework === "static-html"
+                            ? wrapHtmlSnippet(buildBootstrapSnippet(pixelId, eventTagIds))
+                            : buildBootstrapSnippet(pixelId, eventTagIds)
+                    }
+                ]
+                : []
+        };
+    }
+};
+function frameworkInstructionPath(framework) {
+    switch (framework) {
+        case "static-html":
+            return "index.html";
+        case "vite-react":
+            return "src/lib/infinite-analytics.ts";
+        case "next-app-router":
+        case "next-pages-router":
+            return "lib/infinite-analytics.ts";
+    }
+}
+function buildBootstrapSnippet(pixelId, eventTagIds) {
+    return [
+        `window.__INFINITE_X_EVENT_TAG_IDS = ${jsLiteral(eventTagIds)};`,
+        "!function(e,t,n,s,u,a){e.twq||(s=e.twq=function(){s.exe?s.exe.apply(s,arguments):s.queue.push(arguments)},s.version='1.1',s.queue=[],u=t.createElement(n),u.async=!0,u.src='https://static.ads-twitter.com/uwt.js',a=t.getElementsByTagName(n)[0],a.parentNode.insertBefore(u,a))}(window,document,'script');",
+        `twq('config', ${jsLiteral(pixelId)});`
+    ].join("\n");
+}
+function wrapHtmlSnippet(source) {
+    return ["<script>", source, "</script>"].join("\n");
+}

package/dist/src/render.d.ts

@@ -0,0 +1,25 @@
+import type { ApplyResult, InspectResult, InstallPlan, UninstallResult, VerifyResult, WorkspaceInstallArtifacts } from "./types.js";
+export declare function frameworkLabel(framework: string): string;
+/** Short "GA4 · G-XXXX" lines for the providers present in the artifacts. */
+export declare function providerLines(artifacts: WorkspaceInstallArtifacts): string[];
+/** Friendly product names for the providers present, e.g. "Google Analytics and PostHog". */
+export declare function providerNames(artifacts: WorkspaceInstallArtifacts): string;
+/** The "I'll make N changes" block shown before applying (preview). */
+export declare function renderPreview(plan: InstallPlan): string;
+/** The narration + ✅ success + next-steps block shown after a successful apply. */
+export declare function renderApplied(input: {
+    inspect: InspectResult;
+    plan: InstallPlan;
+    apply: ApplyResult;
+    verify: VerifyResult;
+}): string;
+/** Shown when no artifacts were found and none were passed — the silent-no-op fix. */
+export declare function renderNoArtifacts(artifactsDir: string): string;
+/** Shown when the repo's framework isn't recognised — with a manual GA4 fallback if we have an ID. */
+export declare function renderUnsupported(plan: InstallPlan): string;
+/** Other refusals (existing analytics, low confidence, etc.) surfaced as plain reasons. */
+export declare function renderBlocked(plan: InstallPlan): string;
+export declare function renderInspect(inspect: InspectResult): string;
+export declare function renderVerify(verify: VerifyResult): string;
+export declare function renderUninstall(result: UninstallResult, dryRun: boolean): string;
+export declare function ga4ManualSnippet(measurementId: string): string[];

package/dist/src/render.js

@@ -0,0 +1,260 @@
+const HEADER = "Infinite OS · analytics installer";
+const MANIFEST_REL = ".infinite/install.json";
+export function frameworkLabel(framework) {
+    switch (framework) {
+        case "next-app-router":
+            return "Next.js — App Router";
+        case "next-pages-router":
+            return "Next.js — Pages Router";
+        case "vite-react":
+            return "Vite + React";
+        case "static-html":
+            return "static HTML";
+        default:
+            return framework;
+    }
+}
+/** Short "GA4 · G-XXXX" lines for the providers present in the artifacts. */
+export function providerLines(artifacts) {
+    const lines = [];
+    if (artifacts.ga4?.measurementId) {
+        lines.push(`GA4 · ${artifacts.ga4.measurementId}`);
+    }
+    if (artifacts.posthog && (artifacts.posthog.projectKey || artifacts.posthog.apiHost)) {
+        const host = artifacts.posthog.apiHost ? ` (${artifacts.posthog.apiHost})` : "";
+        lines.push(`PostHog · ${artifacts.posthog.projectKey || "project"}${host}`);
+    }
+    if (artifacts.x && (artifacts.x.pixelId || artifacts.x.eventTagIds.length > 0)) {
+        lines.push(`X Pixel · ${artifacts.x.pixelId || "pixel"}`);
+    }
+    return lines;
+}
+/** Friendly product names for the providers present, e.g. "Google Analytics and PostHog". */
+export function providerNames(artifacts) {
+    const names = [];
+    if (artifacts.ga4) {
+        names.push("Google Analytics");
+    }
+    if (artifacts.posthog) {
+        names.push("PostHog");
+    }
+    if (artifacts.x) {
+        names.push("X Pixel");
+    }
+    return joinWithAnd(names) || "analytics";
+}
+function joinWithAnd(items) {
+    if (items.length <= 1) {
+        return items[0] ?? "";
+    }
+    if (items.length === 2) {
+        return `${items[0]} and ${items[1]}`;
+    }
+    return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+function repoLabel(plan) {
+    return plan.appRoot && plan.appRoot !== "." ? `this repo (app at ${plan.appRoot})` : "this repo";
+}
+function actionByPath(plan) {
+    const map = new Map();
+    for (const instruction of plan.instructions) {
+        // "create" only wins when no "modify" already claimed the path.
+        if (!map.has(instruction.path) || instruction.action === "modify") {
+            map.set(instruction.path, instruction.action);
+        }
+    }
+    return map;
+}
+/** The "I'll make N changes" block shown before applying (preview). */
+export function renderPreview(plan) {
+    const actions = actionByPath(plan);
+    const tagWord = providerNames(plan.artifacts) === "analytics" ? "analytics" : `${providerNames(plan.artifacts)}`;
+    const changeLines = plan.files.map((file) => {
+        const symbol = actions.get(file) === "create" ? "+" : "~";
+        return `  ${symbol} ${pad(file)}${actions.get(file) === "create" ? "add" : "inject"} the ${tagWord} tag`;
+    });
+    changeLines.push(`  + ${pad(MANIFEST_REL)}install record (lets a later \`uninstall\` undo this cleanly)`);
+    const providerBlock = providerLines(plan.artifacts);
+    const analyticsValue = providerBlock.length === 0
+        ? "—"
+        : providerBlock[0] + (providerBlock.length > 1 ? "\n" + providerBlock.slice(1).map((l) => `                  ${l}`).join("\n") : "");
+    const meta = [`  Project repo    ${repoLabel(plan)}  (${frameworkLabel(plan.framework)})`];
+    if (plan.packageManager !== "unknown" && plan.packageManager !== "ambiguous") {
+        meta.push(`  Package manager ${plan.packageManager}`);
+    }
+    meta.push(`  Analytics       ${analyticsValue}`);
+    return [
+        "",
+        HEADER,
+        "",
+        ...meta,
+        "",
+        `I'll make ${plan.files.length + 1} change${plan.files.length + 1 === 1 ? "" : "s"}:`,
+        ...changeLines,
+        ""
+    ].join("\n");
+}
+/** The narration + ✅ success + next-steps block shown after a successful apply. */
+export function renderApplied(input) {
+    const { plan, apply, verify } = input;
+    const names = providerNames(plan.artifacts);
+    const codeFiles = apply.changedFiles.filter((file) => !file.endsWith("install.json"));
+    const manifestWritten = apply.changedFiles.some((file) => file.endsWith("install.json"));
+    const steps = [`  ✓ Detected ${frameworkLabel(plan.framework)} at ${plan.appRoot}`];
+    if (codeFiles.length > 0) {
+        steps.push(`  ✓ Installed ${names} → ${codeFiles.join(", ")}`);
+    }
+    if (manifestWritten) {
+        steps.push(`  ✓ Recorded the install → ${MANIFEST_REL}`);
+    }
+    if (verify.buildOk) {
+        const n = plan.files.length;
+        steps.push(`  ✓ Verified ${n} file${n === 1 ? "" : "s"} against the recorded install`);
+    }
+    const ids = providerLines(plan.artifacts).join(", ");
+    const idSuffix = ids ? ` (${ids})` : "";
+    const lines = [
+        "",
+        "Installing analytics into your site…",
+        ...steps,
+        "",
+        `✅ Done — your site is now wired for ${names}${idSuffix}.`,
+        "",
+        "Next steps:",
+        "  1. Review the change:  git diff",
+        "  2. Commit & deploy your site so the tag goes live.",
+        `  3. Confirm it's working: ${confirmHint(plan.artifacts)}`
+    ];
+    const warnings = [...apply.warnings, ...verify.warnings.filter((w) => !w.startsWith("Static verification only"))];
+    if (warnings.length > 0) {
+        lines.push("", "Notes:", ...warnings.map((w) => `  • ${w}`));
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function confirmHint(artifacts) {
+    if (artifacts.ga4) {
+        return "open Google Analytics → Realtime (live within minutes; full reports ~24h).";
+    }
+    if (artifacts.posthog) {
+        return "open PostHog → Activity to watch events arrive.";
+    }
+    return "check your provider's dashboard for incoming events.";
+}
+/** Shown when no artifacts were found and none were passed — the silent-no-op fix. */
+export function renderNoArtifacts(artifactsDir) {
+    return [
+        "",
+        HEADER,
+        "",
+        "I couldn't find any analytics to install.",
+        "",
+        `No saved setup data was found on this machine (looked in ${artifactsDir}). Either:`,
+        "  • Run `infinite setup` first (it saves your keys there), then re-run this; or",
+        "  • Pass it directly:  npx infinite-tag install --ga4-measurement-id G-XXXXXXX",
+        ""
+    ].join("\n");
+}
+/** Shown when the repo's framework isn't recognised — with a manual GA4 fallback if we have an ID. */
+export function renderUnsupported(plan) {
+    const lines = ["", HEADER, ""];
+    const providerBlock = providerLines(plan.artifacts);
+    if (providerBlock.length > 0) {
+        lines.push(`  Analytics   ${providerBlock.join(", ")}`, "");
+    }
+    lines.push("⚠️  I couldn't recognize this project's framework (I look for Next.js, Vite + React, or static HTML).", "Nothing was changed.");
+    const measurementId = plan.artifacts.ga4?.measurementId;
+    if (measurementId) {
+        lines.push("", "You can add the Google Analytics tag by hand — paste this into the <head> of every page:", ...ga4ManualSnippet(measurementId));
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/** Other refusals (existing analytics, low confidence, etc.) surfaced as plain reasons. */
+export function renderBlocked(plan) {
+    return [
+        "",
+        HEADER,
+        "",
+        "I can't safely install yet:",
+        ...plan.blockers.map((blocker) => `  • ${blocker}`),
+        "",
+        "Fix the above and re-run, or pass --json to see the full machine-readable plan.",
+        ""
+    ].join("\n");
+}
+export function renderInspect(inspect) {
+    const lines = [
+        "",
+        HEADER,
+        "",
+        `  Framework       ${frameworkLabel(inspect.framework)}`,
+        `  App root        ${inspect.appRoot}`,
+        `  Package manager ${inspect.packageManager}`,
+        `  Git status      ${inspect.repoStatus}`
+    ];
+    if (inspect.existingProviders.length > 0) {
+        lines.push(`  Existing tags   ${inspect.existingProviders.join(", ")}`);
+    }
+    if (inspect.blockers.length > 0) {
+        lines.push("", "Blockers:", ...inspect.blockers.map((b) => `  • ${b}`));
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+export function renderVerify(verify) {
+    const lines = ["", HEADER, ""];
+    if (verify.buildOk) {
+        lines.push("✅ Verified — the managed analytics files match the recorded install.");
+    }
+    else {
+        lines.push("❌ Verification failed:");
+        lines.push(...verify.routeChecks.map((c) => `  • ${c}`));
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+export function renderUninstall(result, dryRun) {
+    const lines = ["", HEADER, ""];
+    if (!result.manifestPath) {
+        lines.push("Nothing to uninstall — no Infinite install record was found in this repo.", "");
+        return lines.join("\n");
+    }
+    if (dryRun) {
+        lines.push("Uninstall preview (nothing was changed):");
+    }
+    else {
+        lines.push("✅ Removed the Infinite analytics install:");
+    }
+    for (const file of result.restoredFiles) {
+        lines.push(`  ~ ${file}${dryRun ? "  (would restore)" : "  restored"}`);
+    }
+    for (const file of result.removedFiles) {
+        lines.push(`  - ${file}${dryRun ? "  (would remove)" : "  removed"}`);
+    }
+    if (result.warnings.length > 0) {
+        lines.push("", "Notes:", ...result.warnings.map((w) => `  • ${w}`));
+    }
+    if (dryRun) {
+        lines.push("", "To remove for real:  npx infinite-tag uninstall --yes");
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+export function ga4ManualSnippet(measurementId) {
+    return [
+        "",
+        "  <!-- Google tag (gtag.js) -->",
+        `  <script async src="https://www.googletagmanager.com/gtag/js?id=${measurementId}"></script>`,
+        "  <script>",
+        "    window.dataLayer = window.dataLayer || [];",
+        "    function gtag(){dataLayer.push(arguments);}",
+        "    gtag('js', new Date());",
+        `    gtag('config', '${measurementId}');`,
+        "  </script>"
+    ];
+}
+function pad(value) {
+    const width = 26;
+    return value.length >= width ? `${value}  ` : value.padEnd(width);
+}

package/dist/src/types.d.ts

@@ -0,0 +1,151 @@
+export declare const packageManagers: readonly ["pnpm", "npm", "yarn", "bun"];
+export type PackageManager = (typeof packageManagers)[number];
+export type PackageManagerDetectionKind = PackageManager | "ambiguous" | "unknown";
+export type RepoStatus = "clean" | "dirty" | "not-a-git-repo";
+export type ApplyMode = "supported" | "plan-only";
+export declare const supportedFrameworks: readonly ["next-app-router", "next-pages-router", "vite-react", "static-html"];
+export type SupportedFramework = (typeof supportedFrameworks)[number];
+export declare const providerIds: readonly ["ga4", "posthog", "x"];
+export type ProviderId = (typeof providerIds)[number];
+export interface PackageManagerDetection {
+    kind: PackageManagerDetectionKind;
+    reason: "lockfile" | "multiple-lockfiles" | "no-lockfile" | "override";
+    lockfiles: string[];
+}
+export interface PackageManagerCommands {
+    packageManager: PackageManager;
+    oneOff: string;
+    repeatableInstall: string;
+    repeatableRun: string;
+}
+export interface InspectResult {
+    framework: string;
+    appRoot: string;
+    packageManager: string;
+    confidence: number;
+    existingProviders: string[];
+    repoStatus: RepoStatus;
+    assumptions: string[];
+    blockers: string[];
+    detectedFiles: string[];
+}
+export interface InstallPlan {
+    framework: string;
+    providers: string[];
+    files: string[];
+    envKeys: string[];
+    applyMode: ApplyMode;
+    instructions: InstallInstruction[];
+    assumptions: string[];
+    blockers: string[];
+    confidence: number;
+    appRoot: string;
+    packageManager: string;
+    repoStatus: RepoStatus;
+    workspaceId?: string;
+    artifacts: WorkspaceInstallArtifacts;
+}
+export interface ApplyResult {
+    changedFiles: string[];
+    manifestPath: string;
+    warnings: string[];
+}
+export interface UninstallResult {
+    removedFiles: string[];
+    restoredFiles: string[];
+    warnings: string[];
+    manifestPath: string | null;
+}
+export interface VerifyResult {
+    buildOk: boolean;
+    routeChecks: string[];
+    beaconChecks: string[];
+    warnings: string[];
+}
+export interface Ga4PublicArtifact {
+    measurementId: string;
+}
+export interface PosthogPublicArtifact {
+    projectKey: string;
+    apiHost: string;
+}
+export interface XPublicArtifact {
+    pixelId: string;
+    eventTagIds: string[];
+}
+export interface WorkspaceInstallArtifacts {
+    ga4?: Ga4PublicArtifact;
+    posthog?: PosthogPublicArtifact;
+    x?: XPublicArtifact;
+}
+export interface InstallManifest {
+    workspaceId: string;
+    appRoot: string;
+    framework: SupportedFramework;
+    providers: ProviderId[];
+    files: string[];
+    envKeys: string[];
+    contentHashes: Record<string, string>;
+    wiringVersion: number;
+    verifiedAt: string | null;
+}
+export interface FrameworkMatch {
+    framework: SupportedFramework;
+    confidence: number;
+    files: string[];
+    assumptions: string[];
+}
+export interface FrameworkPlanDraft {
+    files: string[];
+    applyMode: ApplyMode;
+    instructions: InstallInstruction[];
+    assumptions: string[];
+    blockers: string[];
+    confidence: number;
+}
+export interface InstallInstruction {
+    path: string;
+    action: "create" | "modify";
+    description: string;
+    snippet: string;
+    provider?: ProviderId;
+}
+export interface FrameworkAdapter {
+    id: SupportedFramework;
+    displayName: string;
+    detect(root: string): FrameworkMatch | null;
+    plan(root: string): FrameworkPlanDraft;
+    apply?(context: FrameworkApplyContext): FrameworkApplyResult;
+    uninstall?(context: FrameworkUninstallContext): FrameworkUninstallResult;
+}
+export interface ProviderPlanDraft {
+    assumptions: string[];
+    blockers: string[];
+    instructions: InstallInstruction[];
+}
+export interface FrameworkApplyContext {
+    root: string;
+    appRoot: string;
+    plan: InstallPlan;
+}
+export interface FrameworkApplyResult {
+    changedFiles: string[];
+    warnings: string[];
+}
+export interface FrameworkUninstallContext {
+    root: string;
+    appRoot: string;
+    manifest: InstallManifest;
+    dryRun: boolean;
+}
+export interface FrameworkUninstallResult {
+    removedFiles: string[];
+    restoredFiles: string[];
+    warnings: string[];
+}
+export interface ProviderAdapter {
+    id: ProviderId;
+    displayName: string;
+    envKeys(framework: SupportedFramework): string[];
+    plan(framework: SupportedFramework, artifact: WorkspaceInstallArtifacts[ProviderId] | undefined): ProviderPlanDraft;
+}

package/dist/src/types.js

@@ -0,0 +1,8 @@
+export const packageManagers = ["pnpm", "npm", "yarn", "bun"];
+export const supportedFrameworks = [
+    "next-app-router",
+    "next-pages-router",
+    "vite-react",
+    "static-html"
+];
+export const providerIds = ["ga4", "posthog", "x"];

package/dist/src/uninstall.d.ts

@@ -0,0 +1,7 @@
+import type { UninstallResult } from "./types.js";
+export interface UninstallInstallationOptions {
+    root: string;
+    allowDirty?: boolean;
+    dryRun?: boolean;
+}
+export declare function uninstallInstallation(options: UninstallInstallationOptions): UninstallResult;

package/dist/src/uninstall.js

@@ -0,0 +1,66 @@
+import { existsSync, readdirSync, rmdirSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { snapshotFiles, restoreSnapshot } from "./apply.js";
+import { getFrameworkAdapter } from "./frameworks/index.js";
+import { detectRepoStatus } from "./inspect.js";
+import { installManifestPath, installManifestRelativePath, readInstallManifest } from "./manifest.js";
+export function uninstallInstallation(options) {
+    const manifest = readInstallManifest(options.root);
+    if (!manifest) {
+        return {
+            removedFiles: [],
+            restoredFiles: [],
+            warnings: ["No .infinite/install.json manifest found. Nothing to uninstall."],
+            manifestPath: null
+        };
+    }
+    const dryRun = options.dryRun ?? false;
+    if (!dryRun && detectRepoStatus(options.root) === "dirty" && !options.allowDirty) {
+        throw new Error("Refusing to uninstall on a dirty git tree without --allow-dirty.");
+    }
+    const adapter = getFrameworkAdapter(manifest.framework);
+    if (!adapter?.uninstall) {
+        throw new Error(`No uninstall implementation is registered for ${manifest.framework}.`);
+    }
+    const snapshot = snapshotFiles(options.root, [
+        ...manifest.files,
+        installManifestRelativePath
+    ]);
+    let frameworkResult;
+    try {
+        frameworkResult = adapter.uninstall({
+            root: options.root,
+            appRoot: manifest.appRoot,
+            manifest,
+            dryRun
+        });
+    }
+    catch (error) {
+        restoreSnapshot(options.root, snapshot);
+        throw error;
+    }
+    const hasWiringLeftover = frameworkResult.warnings.some((w) => w.includes("automatically") || w.includes("leftover"));
+    const manifestPath = installManifestPath(options.root);
+    if (!dryRun && !hasWiringLeftover) {
+        rmSync(manifestPath);
+        removeDirIfEmpty(dirname(manifestPath));
+        // Also prune empty lib dirs left by adapter file removals
+        const appRoot = manifest.appRoot === "." ? options.root : join(options.root, manifest.appRoot);
+        for (const candidate of ["lib", "src/lib"]) {
+            removeDirIfEmpty(join(appRoot, candidate));
+        }
+    }
+    return {
+        removedFiles: hasWiringLeftover
+            ? frameworkResult.removedFiles
+            : [...frameworkResult.removedFiles, installManifestRelativePath],
+        restoredFiles: frameworkResult.restoredFiles,
+        warnings: frameworkResult.warnings,
+        manifestPath: hasWiringLeftover ? null : manifestPath
+    };
+}
+function removeDirIfEmpty(path) {
+    if (existsSync(path) && readdirSync(path).length === 0) {
+        rmdirSync(path);
+    }
+}

package/dist/src/verify.d.ts

@@ -0,0 +1,5 @@
+import type { VerifyResult } from "./types.js";
+export interface VerifyInstallationOptions {
+    root: string;
+}
+export declare function verifyInstallation(options: VerifyInstallationOptions): VerifyResult;

package/dist/src/verify.js

@@ -0,0 +1,50 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { readInstallManifest } from "./manifest.js";
+export function verifyInstallation(options) {
+    const manifest = readInstallManifest(options.root);
+    if (!manifest) {
+        return {
+            buildOk: false,
+            routeChecks: ["Missing .infinite/install.json"],
+            beaconChecks: [],
+            warnings: ["Run apply before verify so the manifest exists."]
+        };
+    }
+    const routeChecks = [`Manifest loaded for ${manifest.framework} at ${manifest.appRoot}.`];
+    const failures = [];
+    let verifiedFileCount = 0;
+    for (const relativePath of manifest.files) {
+        const absolutePath = join(options.root, relativePath);
+        if (!existsSync(absolutePath)) {
+            failures.push(`Missing managed file: ${relativePath}`);
+            continue;
+        }
+        const expectedHash = manifest.contentHashes[relativePath];
+        if (!expectedHash) {
+            failures.push(`Manifest is missing a content hash for ${relativePath}`);
+            continue;
+        }
+        const actualHash = createHash("sha256").update(readFileSync(absolutePath)).digest("hex");
+        if (actualHash !== expectedHash) {
+            failures.push(`Managed file content drifted from manifest: ${relativePath}`);
+            continue;
+        }
+        verifiedFileCount += 1;
+    }
+    if (failures.length === 0) {
+        routeChecks.push(`Verified ${verifiedFileCount} managed file${verifiedFileCount === 1 ? "" : "s"} against recorded content hashes.`);
+    }
+    else {
+        routeChecks.push(...failures);
+    }
+    return {
+        buildOk: failures.length === 0,
+        routeChecks,
+        beaconChecks: manifest.providers.map((provider) => `${provider}: manifest-backed wiring is present in the managed install files.`),
+        warnings: [
+            "Static verification only. Runtime beacon delivery still requires a browser/network check."
+        ]
+    };
+}