pagegraph 0.5.0 → 0.5.1

package/dist/main-GFEobQTH.js

@@ -1,750 +0,0 @@
-import { c as renderSitemap, i as hasStructuralViolations, n as inspectHtml, o as inspectNode, r as checkGraph, s as renderRobots, t as hasBlockingIssues } from "./inspect-html-CHuoiO2s.js";
-import { _ as compareAuditReports, a as makeHttpScanner, b as AuditReport, c as writeAuditFiles, d as AuditLayer, f as AuditComparisonResult, o as renderAuditDiff, r as makeLighthouseScanner, s as renderAuditMarkdown, t as makeHostedScanner, w as Audit } from "./audit-B96V1x3q.js";
-import * as fs from "node:fs";
-import { existsSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import * as Data$1 from "effect/Data";
-import * as Effect$1 from "effect/Effect";
-import { Effect, FileSystem, Schema } from "effect";
-import * as Option from "effect/Option";
-import * as BunRuntime from "@effect/platform-bun/BunRuntime";
-import * as BunServices from "@effect/platform-bun/BunServices";
-import * as Console from "effect/Console";
-import * as Logger from "effect/Logger";
-import * as Runtime from "effect/Runtime";
-import * as CliError from "effect/unstable/cli/CliError";
-import * as Command from "effect/unstable/cli/Command";
-import { pathToFileURL } from "node:url";
-import * as Predicate from "effect/Predicate";
-import * as Flag from "effect/unstable/cli/Flag";
-import * as Argument from "effect/unstable/cli/Argument";
-//#region package.json
-var version = "0.5.0";
-//#endregion
-//#region src/cli/output.ts
-/**
-* Shared surfaces for the `pagegraph` CLI. The three output planes:
-*  - **data** → stdout via {@link printJson} / {@link printText}. Under `--json`
-*    this is the *only* thing on stdout: no ANSI, no status, valid JSON.
-*  - **status** → stderr via Effect leveled logging (`Effect.logInfo` /
-*    `Effect.logDebug`), routed off stdout by `Logger.LogToStderr` in `main.ts`
-*    and gated by the built-in `--log-level` flag.
-*  - **diagnostics** → stderr; expected failures surface as {@link SeoCliError},
-*    printed by the entrypoint with a non-zero exit.
-*/
-/** Expected, user-facing CLI failure — message to stderr, process exits non-zero. */
-var SeoCliError = class extends Data$1.TaggedError("SeoCliError") {};
-/** Machine-readable output. When set, stdout is exactly the JSON payload. */
-const jsonFlag = Flag.boolean("json").pipe(Flag.withDescription("Emit the payload as JSON on stdout (no status, no color)"), Flag.withDefault(false));
-/**
-* Absolute origin the sitemap/robots projection is rendered under. It carries no
-* static default: the fallback is the host's own `origin` from `seo.config.ts`,
-* which is not known until the config is loaded. Resolve it with {@link originOf}.
-*/
-const originFlag = Flag.string("origin").pipe(Flag.withDescription("Absolute origin for URLs (default: `origin` from seo.config.ts)"), Flag.optional);
-/** The `--origin` flag when given, else the origin the config declares. */
-const originOf = (flag, configured) => Option.getOrElse(flag, () => configured);
-/**
-* `--indexable` (default true) / `--no-indexable`. A non-indexable host yields a
-* disallow-all robots.txt with no Sitemap line — the preview posture.
-*/
-const indexableFlag = Flag.boolean("indexable").pipe(Flag.withDescription("Render as an indexable host; --no-indexable = disallow-all robots.txt"), Flag.withDefault(true));
-/** Data plane: pretty-printed JSON on stdout. */
-const printJson = (value) => Console.log(JSON.stringify(value, null, 2));
-/** Data plane: a block of already-formatted text on stdout. */
-const printText = (text) => Console.log(text);
-//#endregion
-//#region src/cli/load-config.ts
-/**
-* Config discovery and graph acquisition for the `pagegraph` CLI.
-*
-* The CLI knows how to *view* a graph; the host knows how to *produce* one. That
-* seam is a `seo.config.ts` at the app root, found by walking up from the working
-* directory — so `bun run pagegraph check` works from anywhere inside the app.
-*
-* The config is a TypeScript module the CLI imports directly, which is one of the
-* reasons the `bin` runs under Bun (the other being the synchronous fd-1 flush in
-* `main.ts`).
-*/
-const CONFIG_FILENAMES = [
-	"seo.config.ts",
-	"seo.config.js",
-	"seo.config.mjs"
-];
-const messageOf = (cause) => cause instanceof Error ? cause.message : String(cause);
-/** First `seo.config.*` at or above `from`, or undefined at the filesystem root. */
-const findConfigFile = (from) => {
-	let directory = resolve(from);
-	for (;;) {
-		for (const filename of CONFIG_FILENAMES) {
-			const candidate = join(directory, filename);
-			if (existsSync(candidate)) return candidate;
-		}
-		const parent = dirname(directory);
-		if (parent === directory) return void 0;
-		directory = parent;
-	}
-};
-const isStringArray = (value) => Array.isArray(value) && value.every(Predicate.isString);
-/**
-* `seo.config.ts` is the consumer's file and may be plain JS, so its types are
-* a suggestion, not a guarantee. Check every field the commands actually read —
-* an undefined `origin` would otherwise surface as "undefined/pricing" in a
-* rendered sitemap rather than as an error here.
-*/
-const isSeoCliConfig = (value) => Predicate.isObject(value) && Predicate.isFunction(value["loadGraph"]) && Predicate.isString(value["origin"]) && isStringArray(value["disallow"]) && (value["contentSignal"] === void 0 || Predicate.isString(value["contentSignal"])) && (value["directives"] === void 0 || isStringArray(value["directives"])) && (value["transform"] === void 0 || Predicate.isFunction(value["transform"]));
-/**
-* Load the app's `seo.config.ts`. Cheap to run more than once per process: the
-* ESM cache evaluates the config module exactly once.
-*/
-const loadSeoConfig = Effect$1.gen(function* () {
-	const cwd = process.cwd();
-	const configPath = findConfigFile(cwd);
-	if (configPath === void 0) return yield* new SeoCliError({ message: `No ${CONFIG_FILENAMES[0]} in ${cwd} or any parent directory. Create one that exports \`defineSeoConfig({ origin, disallow, loadGraph })\` from "pagegraph/config".` });
-	yield* Effect$1.logDebug(`Loading SEO config from ${configPath}`);
-	const module = yield* Effect$1.tryPromise({
-		try: () => import(pathToFileURL(configPath).href),
-		catch: (cause) => new SeoCliError({ message: `Could not load ${configPath}: ${messageOf(cause)}` })
-	});
-	if (!isSeoCliConfig(module.default)) return yield* new SeoCliError({ message: `${configPath} must default-export defineSeoConfig({ origin, disallow, loadGraph }).` });
-	return module.default;
-});
-/**
-* The live SEO graph as a scoped resource: whatever the loader acquired (for
-* {@link viteGraphLoader}, an in-process Vite server) is released when the
-* surrounding `Effect.scoped` exits, on success or failure.
-*/
-const acquireGraph = (config) => Effect$1.gen(function* () {
-	yield* Effect$1.logDebug("Loading the SEO graph…");
-	const loaded = yield* Effect$1.acquireRelease(Effect$1.tryPromise({
-		try: () => config.loadGraph(),
-		catch: (cause) => new SeoCliError({ message: messageOf(cause) })
-	}), (acquired) => Effect$1.promise(() => acquired.dispose()).pipe(Effect$1.catchDefect((defect) => Effect$1.logWarning(`Could not dispose the SEO graph loader: ${messageOf(defect)}`))));
-	yield* Effect$1.logDebug(`Loaded SEO graph: ${loaded.graph.nodes.size} nodes, ${loaded.graph.edges.length} edges.`);
-	return loaded.graph;
-});
-//#endregion
-//#region src/cli/render.ts
-/** Count of edges pointing *at* each node — 0 means nothing links to it. */
-const incomingCounts = (graph) => {
-	const counts = /* @__PURE__ */ new Map();
-	for (const node of graph.nodes.keys()) counts.set(node, 0);
-	for (const edge of graph.edges) counts.set(edge.to, (counts.get(edge.to) ?? 0) + 1);
-	return counts;
-};
-/** Paths nothing links to (zero incoming edges) — the "orphan" set. */
-const orphanPaths = (graph) => {
-	const incoming = incomingCounts(graph);
-	return new Set([...graph.nodes.keys()].filter((path) => (incoming.get(path) ?? 0) === 0));
-};
-const byPath = (a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0;
-/** A compact one-line summary of a node's policy — kind and the flags that matter. */
-const nodeMarkers = (node) => {
-	const markers = [node.kind];
-	if (node.source !== "route") markers.push(node.source);
-	const sitemap = node.policy.sitemap;
-	if (sitemap) markers.push(`sitemap:${sitemap.priority.toFixed(1)}`);
-	if (node.policy.robots?.includes("noindex")) markers.push("noindex");
-	if (node.policy.redirectTo) markers.push(`→ ${node.policy.redirectTo}`);
-	return markers.join("  ");
-};
-/** Map each node to its parent = the longest strict path-prefix that is also a node. */
-const parentOf = (path, nodePaths) => {
-	if (path === "/") return void 0;
-	const segments = path.split("/").filter(Boolean);
-	for (let depth = segments.length - 1; depth >= 1; depth--) {
-		const candidate = `/${segments.slice(0, depth).join("/")}`;
-		if (nodePaths.has(candidate)) return candidate;
-	}
-	return nodePaths.has("/") ? "/" : void 0;
-};
-/** Render the graph as an indented path hierarchy with per-node markers. */
-const renderTree = (graph) => {
-	const nodePaths = new Set(graph.nodes.keys());
-	const children = /* @__PURE__ */ new Map();
-	const roots = [];
-	for (const path of [...nodePaths].sort()) {
-		const parent = parentOf(path, nodePaths);
-		if (parent === void 0) roots.push(path);
-		else {
-			const bucket = children.get(parent);
-			if (bucket) bucket.push(path);
-			else children.set(parent, [path]);
-		}
-	}
-	const lines = [];
-	const walk = (path, depth) => {
-		const node = graph.nodes.get(path);
-		lines.push(`${"  ".repeat(depth)}${path}  ·  ${nodeMarkers(node)}`);
-		for (const child of children.get(path) ?? []) walk(child, depth + 1);
-	};
-	for (const root of roots) walk(root, 0);
-	return `${lines.join("\n")}\n\n${renderSummary(graph)}`;
-};
-/** One-line-per-node list of nodes nothing links to (no incoming graph edges). */
-const renderOrphans = (graph) => {
-	const orphans = orphanPaths(graph);
-	const orphanNodes = [...graph.nodes.values()].filter((node) => orphans.has(node.path)).sort(byPath);
-	if (orphanNodes.length === 0) return "No orphan nodes — every node has an incoming edge.";
-	const lines = orphanNodes.map((node) => `${node.path}  ·  ${nodeMarkers(node)}`);
-	return [
-		`Orphans — ${orphanNodes.length} node(s) with no incoming edge (reachable only via nav/sitemap):`,
-		"",
-		...lines
-	].join("\n");
-};
-const sanitizeId = (path) => `n_${path.replace(/[^a-zA-Z0-9]/g, "_")}`;
-/** Render the graph (or just its orphans) as a Mermaid `graph LR` diagram. */
-const renderMermaid = (graph, orphansOnly) => {
-	const orphans = orphanPaths(graph);
-	const nodes = [...graph.nodes.values()].filter((node) => !orphansOnly || orphans.has(node.path)).sort(byPath);
-	const visible = new Set(nodes.map((node) => node.path));
-	const lines = ["graph LR"];
-	for (const node of nodes) lines.push(`  ${sanitizeId(node.path)}["${node.path}"]`);
-	if (!orphansOnly) for (const edge of graph.edges) {
-		if (!visible.has(edge.from) || !visible.has(edge.to)) continue;
-		lines.push(`  ${sanitizeId(edge.from)} -->|${edge.type}| ${sanitizeId(edge.to)}`);
-	}
-	return lines.join("\n");
-};
-const renderSummary = (graph) => {
-	const bySource = /* @__PURE__ */ new Map();
-	for (const node of graph.nodes.values()) bySource.set(node.source, (bySource.get(node.source) ?? 0) + 1);
-	const byEdge = /* @__PURE__ */ new Map();
-	for (const edge of graph.edges) byEdge.set(edge.type, (byEdge.get(edge.type) ?? 0) + 1);
-	const sources = [...bySource.entries()].map(([source, count]) => `${source} ${count}`).join(", ");
-	const edges = [...byEdge.entries()].map(([type, count]) => `${type} ${count}`).join(", ");
-	return `${graph.nodes.size} nodes (${sources}) · ${graph.edges.length} edges (${edges})`;
-};
-/** Static `inspect <path>` report: the node's declaration, sitemap status, edges. */
-const renderNodeReport = (report) => {
-	const { node } = report;
-	const lines = [
-		node.path,
-		`  kind        ${node.kind}`,
-		`  source      ${node.source}`,
-		`  in sitemap  ${report.inSitemap ? "yes" : "no"}`
-	];
-	if (node.policy.robots) lines.push(`  robots      ${node.policy.robots}`);
-	if (node.policy.redirectTo) lines.push(`  redirect →  ${node.policy.redirectTo}`);
-	if (node.policy.link) {
-		lines.push(`  link.title  ${node.policy.link.title}`);
-		lines.push(`  link.desc   ${node.policy.link.description}`);
-	}
-	if (node.instance) {
-		lines.push(`  title       ${node.instance.title}`);
-		if (node.instance.description) lines.push(`  description  ${node.instance.description}`);
-		if (node.instance.publishedAt) lines.push(`  published   ${node.instance.publishedAt}`);
-		if (node.instance.modifiedAt) lines.push(`  modified    ${node.instance.modifiedAt}`);
-	}
-	const edgeLine = (label, edges) => {
-		if (edges.length === 0) return;
-		lines.push(`  ${label}`);
-		for (const edge of edges) {
-			const other = label === "outgoing" ? edge.to : edge.from;
-			lines.push(`    ${edge.type.padEnd(13)} ${other}`);
-		}
-	};
-	edgeLine("outgoing", report.outgoing);
-	edgeLine("incoming", report.incoming);
-	return lines.join("\n");
-};
-/** Live `inspect <url> --live` report: fetched head tags + JSON-LD validation. */
-const renderLiveReport = (report) => {
-	const lines = [
-		`${report.url}  (HTTP ${report.status})`,
-		`  title        ${report.title ?? "—"}`,
-		`  description  ${report.description ?? "—"}`,
-		`  canonical    ${report.canonical ?? "—"}`,
-		`  robots       ${report.robots ?? "—"}`
-	];
-	const kv = (label, map) => {
-		const keys = Object.keys(map);
-		if (keys.length === 0) return;
-		lines.push(`  ${label}`);
-		for (const key of keys) lines.push(`    ${key.padEnd(18)} ${map[key]}`);
-	};
-	kv("open graph", report.og);
-	kv("twitter", report.twitter);
-	if (report.jsonLd.length > 0) {
-		lines.push("  json-ld");
-		for (const block of report.jsonLd) {
-			lines.push(`    ${block.valid ? "✓" : "✗"} ${block.type}`);
-			for (const error of block.errors) lines.push(`        ${error}`);
-		}
-	}
-	if (report.issues.length > 0) {
-		lines.push("", `  ${report.issues.length} issue(s):`);
-		for (const issue of report.issues) lines.push(`    ✗ ${issue}`);
-	} else lines.push("", "  ✓ required tags present, JSON-LD valid");
-	return lines.join("\n");
-};
-/** `pagegraph check` report: violations grouped by severity, with a headline count. */
-const renderViolations = (violations) => {
-	const structural = violations.filter((violation) => violation.severity === "structural");
-	const editorial = violations.filter((violation) => violation.severity === "editorial");
-	if (violations.length === 0) return "✓ No violations. The SEO graph is clean.";
-	const block = (title, group) => {
-		if (group.length === 0) return [];
-		const lines = [`${title} (${group.length}):`, ""];
-		for (const violation of group) {
-			const where = violation.path ? `  ${violation.path}` : "";
-			lines.push(`  ✗ [${violation.rule}]${where}`);
-			lines.push(`      ${violation.message}`);
-			if (violation.fix) lines.push(`      fix: ${violation.fix}`);
-		}
-		lines.push("");
-		return lines;
-	};
-	return [
-		...block("Structural", structural),
-		...block("Editorial", editorial),
-		structural.length > 0 ? `${structural.length} structural, ${editorial.length} editorial — structural violations fail the check.` : `${editorial.length} editorial warning(s) — no structural violations.`
-	].join("\n");
-};
-//#endregion
-//#region src/cli/commands/check.ts
-const checkCommand = Command.make("check", { json: jsonFlag }).pipe(Command.withDescription("Check the SEO graph; exit 1 on any structural violation"), Command.withExamples([{
-	command: "pagegraph check",
-	description: "Run every rule and print the violations"
-}, {
-	command: "pagegraph check --json",
-	description: "Violations as JSON (exit 1 iff structural)"
-}]), Command.withHandler(Effect$1.fnUntraced(function* ({ json }) {
-	const config = yield* loadSeoConfig;
-	const graph = yield* Effect$1.scoped(acquireGraph(config));
-	const violations = checkGraph(graph);
-	const structural = violations.filter((violation) => violation.severity === "structural");
-	if (json) yield* printJson({
-		ok: structural.length === 0,
-		structural: structural.length,
-		editorial: violations.length - structural.length,
-		violations
-	});
-	else yield* printText(renderViolations(violations));
-	if (hasStructuralViolations(violations)) return yield* new SeoCliError({ message: `${structural.length} structural violation(s) — see the report above.` });
-})));
-//#endregion
-//#region src/cli/commands/audit.ts
-const urls = Argument.string("url").pipe(Argument.withDescription("One or more absolute http(s) URLs"), Argument.variadic({ min: 1 }));
-const allowPrivate = Flag.boolean("allow-private").pipe(Flag.withDescription("Allow localhost and private addresses (local development only)"), Flag.withDefault(false));
-const probeOnly = Flag.boolean("probe-only").pipe(Flag.withDescription("Run HTTP probes without Lighthouse"), Flag.withDefault(false));
-const hosted = Flag.boolean("hosted").pipe(Flag.withDescription("Opt in to external agent-readiness scanners"), Flag.withDefault(false));
-const formFactor = Flag.choice("form-factor", ["mobile", "desktop"]).pipe(Flag.withDescription("Lighthouse form factor"), Flag.withDefault("mobile"));
-const runs = Flag.integer("runs").pipe(Flag.withDescription("Lighthouse runs per target"), Flag.withDefault(1));
-const concurrency = Flag.integer("concurrency").pipe(Flag.withDescription("Maximum concurrent target/scanner pairs"), Flag.withDefault(4));
-const requestTimeoutMs = Flag.integer("request-timeout-ms").pipe(Flag.withDescription("HTTP request timeout in milliseconds"), Flag.withDefault(15e3));
-const scannerTimeoutMs = Flag.integer("scanner-timeout-ms").pipe(Flag.withDescription("Lighthouse and hosted scanner timeout in milliseconds"), Flag.withDefault(18e4));
-const maxBodyBytes = Flag.integer("max-body-bytes").pipe(Flag.withDescription("Maximum captured response bytes"), Flag.withDefault(2e6));
-const outputDir = Flag.string("output-dir").pipe(Flag.withDescription("Atomically write timestamped JSON and Markdown artifacts"), Flag.optional);
-const positive = (name, value) => Number.isSafeInteger(value) && value > 0 ? Effect$1.succeed(value) : Effect$1.fail(new SeoCliError({ message: `--${name} must be a positive integer` }));
-const auditCommand = Command.make("audit", {
-	urls,
-	json: jsonFlag,
-	allowPrivate,
-	probeOnly,
-	hosted,
-	formFactor,
-	runs,
-	concurrency,
-	requestTimeoutMs,
-	scannerTimeoutMs,
-	maxBodyBytes,
-	outputDir
-}).pipe(Command.withDescription("Audit any website without a TanStack app or seo.config.ts"), Command.withExamples([
-	{
-		command: "pagegraph audit https://example.com",
-		description: "HTTP and Lighthouse audit"
-	},
-	{
-		command: "pagegraph audit https://example.com --json",
-		description: "One JSON report on stdout"
-	},
-	{
-		command: "pagegraph audit http://localhost:3000 --allow-private --probe-only",
-		description: "Audit a local app"
-	}
-]), Command.withHandler(Effect$1.fn("SeoCli.audit")(function* (options) {
-	const checkedRuns = yield* positive("runs", options.runs);
-	const checkedConcurrency = yield* positive("concurrency", options.concurrency);
-	const checkedRequestTimeout = yield* positive("request-timeout-ms", options.requestTimeoutMs);
-	const checkedScannerTimeout = yield* positive("scanner-timeout-ms", options.scannerTimeoutMs);
-	const checkedMaxBody = yield* positive("max-body-bytes", options.maxBodyBytes);
-	const scanners = [
-		makeHttpScanner({
-			allowPrivate: options.allowPrivate,
-			timeoutMs: checkedRequestTimeout,
-			maxBodyBytes: checkedMaxBody
-		}),
-		...!options.probeOnly ? [makeLighthouseScanner({
-			allowPrivate: options.allowPrivate,
-			timeoutMs: checkedScannerTimeout
-		})] : [],
-		...options.hosted ? [makeHostedScanner({
-			allowPrivate: options.allowPrivate,
-			timeoutMs: checkedScannerTimeout,
-			maxBodyBytes: checkedMaxBody,
-			origins: {
-				isitagentready: "https://isitagentready.com",
-				isAgentic: "https://is-agentic.com"
-			}
-		})] : []
-	];
-	const report = yield* Effect$1.gen(function* () {
-		return yield* (yield* Audit.Service).run({
-			targets: [...new Set(options.urls)],
-			options: {
-				concurrency: checkedConcurrency,
-				formFactors: [options.formFactor],
-				runs: checkedRuns,
-				allowPrivate: options.allowPrivate,
-				requestTimeoutMs: checkedRequestTimeout,
-				scannerTimeoutMs: checkedScannerTimeout,
-				maxBodyBytes: checkedMaxBody
-			}
-		});
-	}).pipe(Effect$1.provide(AuditLayer(scanners)), Effect$1.mapError((error) => new SeoCliError({ message: error.message })));
-	if (options.json) yield* printJson(report);
-	else yield* printText(renderAuditMarkdown(report));
-	if (Option.isSome(options.outputDir)) {
-		const directory = options.outputDir.value;
-		const artifacts = yield* Effect$1.tryPromise({
-			try: () => writeAuditFiles(report, directory),
-			catch: (cause) => new SeoCliError({ message: `Could not write audit artifacts: ${cause instanceof Error ? cause.message : String(cause)}` })
-		});
-		yield* Effect$1.logInfo(`Wrote ${artifacts.json} and ${artifacts.markdown}`);
-	}
-	const structural = report.findings.filter((finding) => finding.severity === "structural");
-	const http = report.results.filter((result) => result.scanner === "http");
-	if (structural.length > 0 || http.every((result) => result.status === "error")) return yield* new SeoCliError({ message: `${structural.length} structural finding(s); see the report above.` });
-})));
-//#endregion
-//#region src/cli/commands/diff.ts
-const before = Argument.string("before.json").pipe(Argument.withDescription("Earlier pagegraph audit JSON artifact"));
-const after = Argument.string("after.json").pipe(Argument.withDescription("Later pagegraph audit JSON artifact"));
-const readAuditReport = Effect.fn("SeoCli.readAuditReport")(function* (label, path) {
-	const contents = yield* (yield* FileSystem.FileSystem).readFileString(path).pipe(Effect.mapError((error) => new SeoCliError({ message: `Could not read ${label} report ${path}: ${error.message}` })));
-	return yield* Schema.decodeUnknownEffect(Schema.fromJsonString(AuditReport))(contents).pipe(Effect.mapError((error) => new SeoCliError({ message: `Invalid ${label} report ${path}: ${error.message}` })));
-});
-const diffCommand = Command.make("diff", {
-	before,
-	after,
-	json: jsonFlag
-}).pipe(Command.withDescription("Compare two versioned pagegraph audit JSON artifacts for semantic regressions"), Command.withExamples([{
-	command: "pagegraph diff before.json after.json",
-	description: "Render a human-readable semantic comparison"
-}, {
-	command: "pagegraph diff before.json after.json --json",
-	description: "Emit one versioned JSON diff on stdout"
-}]), Command.withHandler(Effect.fn("SeoCli.diff")(function* (options) {
-	const beforeReport = yield* readAuditReport("before", options.before);
-	const afterReport = yield* readAuditReport("after", options.after);
-	const comparison = compareAuditReports(beforeReport, afterReport);
-	if (AuditComparisonResult.$is("InvalidReport")(comparison)) return yield* new SeoCliError({ message: `Invalid audit report invariants:\n${comparison.issues.map((issue) => `- ${issue}`).join("\n")}` });
-	if (options.json) yield* printJson(comparison.diff);
-	else yield* printText(renderAuditDiff(comparison.diff));
-	if (comparison.diff.outcome === "regressed") {
-		const summary = comparison.diff.summary;
-		return yield* new SeoCliError({ message: `${summary.structuralRegressions} structural, ${summary.scannerRegressions} scanner, and ${summary.coverageRegressions} coverage regression(s); see the diff above.` });
-	}
-})));
-//#endregion
-//#region src/cli/serialize.ts
-const serializeCrumb = (crumb) => {
-	if (crumb === void 0) return void 0;
-	return typeof crumb === "function" ? "(dynamic)" : crumb;
-};
-/** JSON-safe projection of one node (route policy `crumb` functions → sentinel). */
-const serializeNode = (node) => ({
-	path: node.path,
-	kind: node.kind,
-	source: node.source,
-	policy: {
-		kind: node.policy.kind,
-		crumb: serializeCrumb(node.policy.crumb),
-		sitemap: node.policy.sitemap,
-		robots: node.policy.robots,
-		related: node.policy.related,
-		link: node.policy.link,
-		redirectTo: node.policy.redirectTo
-	},
-	instance: node.instance
-});
-/** Flatten the graph to a sorted, JSON-safe shape. Nodes are ordered by path. */
-const serializeGraph = (graph) => ({
-	nodes: [...graph.nodes.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0).map(serializeNode),
-	edges: graph.edges
-});
-//#endregion
-//#region src/cli/commands/graph.ts
-const formatFlag = Flag.choice("format", [
-	"tree",
-	"mermaid",
-	"json"
-]).pipe(Flag.withDescription("Output format: tree (default), mermaid diagram, or json"), Flag.withDefault("tree"));
-const orphansFlag = Flag.boolean("orphans").pipe(Flag.withDescription("Show only orphan nodes (nothing links to them)"), Flag.withDefault(false));
-const graphCommand = Command.make("graph", {
-	format: formatFlag,
-	orphans: orphansFlag
-}).pipe(Command.withDescription("Render the SEO graph as a tree, a Mermaid diagram, or JSON"), Command.withExamples([
-	{
-		command: "pagegraph graph",
-		description: "The graph as an indented path tree"
-	},
-	{
-		command: "pagegraph graph --format mermaid",
-		description: "A Mermaid diagram of nodes and edges"
-	},
-	{
-		command: "pagegraph graph --orphans",
-		description: "Only nodes with no incoming edge"
-	},
-	{
-		command: "pagegraph graph --format json",
-		description: "The serialized graph on stdout"
-	}
-]), Command.withHandler(Effect$1.fnUntraced(function* ({ format, orphans }) {
-	const config = yield* loadSeoConfig;
-	const graph = yield* Effect$1.scoped(acquireGraph(config));
-	if (format === "json") {
-		const serialized = serializeGraph(graph);
-		if (!orphans) return yield* printJson(serialized);
-		const orphanSet = orphanPaths(graph);
-		return yield* printJson({
-			nodes: serialized.nodes.filter((node) => orphanSet.has(node.path)),
-			edges: serialized.edges.filter((edge) => orphanSet.has(edge.from) && orphanSet.has(edge.to))
-		});
-	}
-	if (format === "mermaid") return yield* printText(renderMermaid(graph, orphans));
-	return yield* printText(orphans ? renderOrphans(graph) : renderTree(graph));
-})));
-//#endregion
-//#region src/cli/live-inspect.ts
-/**
-* `pagegraph inspect <url> --live`: fetch a URL and hand its body to the pure head
-* validator in `../inspect-html`. The fetch is all that lives here — the
-* validation is a library capability, not a CLI one, so it stays out of the
-* Effect-bearing half of the package.
-*/
-/** Fetch a URL and inspect its `<head>`. Network failures surface as SeoCliError. */
-const fetchAndInspect = (url) => Effect$1.tryPromise({
-	try: async () => {
-		const response = await fetch(url, { headers: { "user-agent": "pagegraph-cli" } });
-		const html = await response.text();
-		return inspectHtml(url, response.status, html);
-	},
-	catch: (cause) => new SeoCliError({ message: `Could not fetch ${url}: ${cause instanceof Error ? cause.message : String(cause)}` })
-});
-//#endregion
-//#region src/cli/commands/inspect.ts
-const targetArg = Argument.string("target").pipe(Argument.withDescription("A route path (e.g. /pricing), or a full URL with --live"));
-const liveFlag = Flag.boolean("live").pipe(Flag.withDescription("Fetch the URL and inspect its rendered <head> and JSON-LD"), Flag.withDefault(false));
-const inspectCommand = Command.make("inspect", {
-	target: targetArg,
-	live: liveFlag,
-	json: jsonFlag
-}).pipe(Command.withDescription("Inspect one page: its graph declaration, or its live <head> with --live"), Command.withExamples([
-	{
-		command: "pagegraph inspect /pricing",
-		description: "The graph node, policy, and edges for a path"
-	},
-	{
-		command: "pagegraph inspect https://example.com/pricing --live",
-		description: "Fetch the page and validate its head tags + JSON-LD"
-	},
-	{
-		command: "pagegraph inspect /blog/some-post --json",
-		description: "The node report as JSON"
-	}
-]), Command.withHandler(Effect$1.fnUntraced(function* ({ target, live, json }) {
-	if (live) {
-		const report = yield* fetchAndInspect(target);
-		if (json) yield* printJson(report);
-		else yield* printText(renderLiveReport(report));
-		if (hasBlockingIssues(report)) return yield* new SeoCliError({ message: `${report.issues.length} issue(s) found at ${target}.` });
-		return;
-	}
-	const config = yield* loadSeoConfig;
-	const graph = yield* Effect$1.scoped(acquireGraph(config));
-	const report = inspectNode(graph, target);
-	if (report === void 0) return yield* new SeoCliError({ message: `No node at "${target}". Run \`pagegraph graph\` to list paths, or pass a URL with --live.` });
-	if (json) return yield* printJson({
-		node: serializeNode(report.node),
-		inSitemap: report.inSitemap,
-		incoming: report.incoming,
-		outgoing: report.outgoing
-	});
-	return yield* printText(renderNodeReport(report));
-})));
-//#endregion
-//#region src/cli/commands/robots.ts
-const robotsCommand = Command.make("robots", {
-	origin: originFlag,
-	indexable: indexableFlag
-}).pipe(Command.withDescription("Render robots.txt from the graph (the exact server-route output)"), Command.withExamples([{
-	command: "pagegraph robots",
-	description: "The robots.txt, under the origin from seo.config.ts"
-}, {
-	command: "pagegraph robots --origin https://preview.example.com --no-indexable",
-	description: "Disallow-all with no Sitemap line — the preview posture"
-}]), Command.withHandler(Effect$1.fnUntraced(function* ({ origin, indexable }) {
-	const config = yield* loadSeoConfig;
-	const graph = yield* Effect$1.scoped(acquireGraph(config));
-	yield* printText(renderRobots(graph, {
-		origin: originOf(origin, config.origin),
-		indexable,
-		disallow: config.disallow,
-		contentSignal: config.contentSignal,
-		directives: config.directives,
-		transform: config.transform
-	}));
-})));
-//#endregion
-//#region src/cli/commands/sitemap.ts
-const sitemapCommand = Command.make("sitemap", {
-	origin: originFlag,
-	indexable: indexableFlag
-}).pipe(Command.withDescription("Render sitemap.xml from the graph (the exact server-route output)"), Command.withExamples([{
-	command: "pagegraph sitemap",
-	description: "The sitemap XML, under the origin from seo.config.ts"
-}, {
-	command: "pagegraph sitemap --origin https://preview.example.com --no-indexable",
-	description: "Sitemap body is host-independent; robots.txt is what gates crawling"
-}]), Command.withHandler(Effect$1.fnUntraced(function* ({ origin, indexable }) {
-	const config = yield* loadSeoConfig;
-	const graph = yield* Effect$1.scoped(acquireGraph(config));
-	yield* printText(renderSitemap(graph, {
-		origin: originOf(origin, config.origin),
-		indexable
-	}));
-})));
-//#endregion
-//#region src/cli/cli.ts
-/**
-* Root `pagegraph` command. Every subcommand reads the same SEO graph that render
-* time, the sitemap/robots server routes, and the test suite read — the one the
-* app's `seo.config.ts` loader produces. Route declarations are the single
-* source of truth, and these are pure views over them.
-*/
-const cli = Command.make("pagegraph").pipe(Command.withDescription("Inspect and audit a TanStack Start SEO graph: sitemap, robots, cross-links, structured data, and link decisions."), Command.withExamples([
-	{
-		command: "pagegraph audit https://example.com",
-		description: "Audit any deployed website"
-	},
-	{
-		command: "pagegraph check",
-		description: "Fail (exit 1) on any structural SEO violation"
-	},
-	{
-		command: "pagegraph graph",
-		description: "Print the SEO graph as a tree"
-	},
-	{
-		command: "pagegraph sitemap",
-		description: "Render sitemap.xml"
-	}
-]), Command.withSubcommands([
-	auditCommand,
-	diffCommand,
-	graphCommand,
-	inspectCommand,
-	checkCommand,
-	sitemapCommand,
-	robotsCommand
-]));
-//#endregion
-//#region src/cli/main.ts
-/**
-* The `pagegraph` CLI program (Bun runtime), wiring the three output planes:
-*  - **data** → stdout, via `Console.log` in the command handlers.
-*  - **status** → stderr, via `Logger.LogToStderr(true)`: the built-in loggers
-*    call `console.error`, so `Effect.log*` never touches stdout. The built-in
-*    `--log-level` flag (from `Command.run`) gates them.
-*  - **diagnostics** → stderr: an expected `SeoCliError` prints `✗ <message>`.
-*
-* This module is what `bin.ts` dynamic-imports, and it is the only place Effect
-* enters the package — which is what keeps Effect an *optional* peer dependency
-* that no consumer of `pagegraph` or `pagegraph/react` ever installs.
-*
-* Two Bun-specific wrinkles are handled here:
-*  - `Command.run` writes its help to stdout, so a flag typo would dump the full
-*    help there. Under Bun, `Console.log` bypasses `process.stdout.write` (it
-*    calls `console.log` natively), so the buffer intercepts `console.log`.
-*  - A graph loader may leave handles alive after the command finishes (the Vite
-*    loader's worker threads do), and the default teardown only force-exits on a
-*    non-zero code, so a custom teardown exits on success too.
-*/
-/**
-* Write one buffered line synchronously to fd 1, looping over partial writes and
-* retrying `EAGAIN`. The forced `process.exit` needed to escape the Vite loader's
-* lingering handles truncates async stdout to a slow pipe (`… | jq`) at the OS
-* pipe-buffer boundary; a synchronous write blocks until every byte lands, so
-* `process.exit` afterwards can't cut it off.
-*/
-const writeLineSync = (line) => {
-	const buffer = Buffer.from(`${line}\n`, "utf8");
-	let offset = 0;
-	while (offset < buffer.length) try {
-		offset += fs.writeSync(1, buffer, offset, buffer.length - offset);
-	} catch (cause) {
-		if (cause.code === "EAGAIN") continue;
-		throw cause;
-	}
-};
-const flushStdout = (state) => {
-	for (const args of state.buffer) writeLineSync(args.map((arg) => typeof arg === "string" ? arg : String(arg)).join(" "));
-	state.buffer.length = 0;
-};
-/**
-* `Command.run` already prints the error itself to stderr (showHelp → Console.error);
-* this adds only the "Try …" nudge, and `commandPath` already starts with "seo".
-*/
-const formatParseHint = (error) => {
-	return `Try: ${error.commandPath.length > 0 ? error.commandPath.join(" ") : "seo"} --help`;
-};
-/**
-* Buffer stdout (`console.log`) so a parse error can suppress the help dump and
-* print a one-line hint to stderr instead. Successful runs flush the buffer as
-* their final act. The Vite loader temporarily re-points `console.log` to stderr
-* while it runs (see `vite-graph-loader.ts`), nested inside this override, so its
-* noise never enters the buffer.
-*/
-const withStdoutBuffer = (program) => Effect$1.acquireUseRelease(Effect$1.sync(() => {
-	const originalLog = console.log;
-	const buffer = [];
-	console.log = (...args) => buffer.push(args);
-	return {
-		originalLog,
-		buffer,
-		discard: false
-	};
-}), (state) => program.pipe(Effect$1.tap(() => Effect$1.sync(() => flushStdout(state))), Effect$1.tapError((error) => {
-	if (CliError.isCliError(error) && error._tag === "ShowHelp" && error.errors.length > 0) {
-		state.discard = true;
-		return Console.error(formatParseHint(error));
-	}
-	return Effect$1.sync(() => flushStdout(state));
-})), (state) => Effect$1.sync(() => {
-	console.log = state.originalLog;
-	if (!state.discard && state.buffer.length > 0) flushStdout(state);
-	else state.buffer.length = 0;
-}));
-const program = withStdoutBuffer(Command.run(cli, { version }).pipe(Effect$1.provideService(Logger.LogToStderr, true), Effect$1.provide(BunServices.layer), Effect$1.tapErrorTag("SeoCliError", (error) => Console.error(`✗ ${error.message}`))));
-/**
-* Run the CLI. An explicit call from `bin.ts` rather than an import-time side
-* effect: the package declares `sideEffects: false`, so a body that only ran on
-* import would be tree-shaken out of the built chunk.
-*
-* Force exit to escape the Vite loader's lingering worker handles. `flushStdout`
-* already wrote the data plane synchronously, so exiting here can't truncate it.
-*/
-const run = () => {
-	BunRuntime.runMain(program, {
-		disableErrorReporting: true,
-		teardown: (exit, _onExit) => Runtime.defaultTeardown(exit, (code) => process.exit(code))
-	});
-};
-//#endregion
-export { run };
-
-//# sourceMappingURL=main-GFEobQTH.js.map