pagegraph 0.11.0 → 0.13.0

package/dist/tanstack-start/index.js

@@ -0,0 +1,717 @@
+import { t as buildSeoGraph } from "../graph-DMNOLXLu.js";
+import { n as graphToJson } from "../wire-B4RQMc4e.js";
+import { a as globToRegExp } from "../checks-BS-aDXB_.js";
+import { o as hashDocument } from "../inline-BbS93GAT.js";
+import { t as decodeFacts } from "../facts-1OKclPOk.js";
+import { n as documentMarkdown } from "../markdown-C6dRE9zD.js";
+import { i as seoRouteConfig, n as inMemoryWriteFs, r as resolveOptions, t as deriveRouteConfig } from "../route-config-35ZEzkNC.js";
+import { n as withCleanStdout } from "../vite-graph-loader-CsGiYNWE.js";
+import { r as replayClaims } from "../claims-Bv7voeEV.js";
+import { t as MARKDOWN_CAPTURE_PATH } from "../markdown-path-lJB9BAVZ.js";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { Generator, getConfig } from "@tanstack/router-generator";
+import { createRunnableDevEnvironment, parseAst, resolveConfig } from "vite";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { pathToFileURL } from "node:url";
+//#region src/tanstack-start/routes.ts
+/**
+* Route discovery for the graph: the router's own generator parses the routes
+* directory (the same parse `routeTree.gen.ts` comes from), into memory only.
+*/
+async function scanRoutes(root, routesDirectory) {
+	const cacheDirectory = resolve(root, "node_modules/.cache/pagegraph");
+	let scanned;
+	const config = getConfig({
+		routesDirectory: resolve(root, routesDirectory),
+		generatedRouteTree: resolve(cacheDirectory, "route-tree.gen.ts"),
+		tmpDir: resolve(cacheDirectory, "tmp"),
+		disableTypes: true,
+		enableRouteTreeFormatting: false,
+		disableLogging: true,
+		plugins: [{
+			name: "pagegraph:scan",
+			onRouteTreeChanged({ routeTree, routeNodes, rootRouteNode }) {
+				scanned = {
+					root: rootRouteNode,
+					tree: routeTree,
+					nodes: routeNodes
+				};
+			}
+		}]
+	}, root);
+	const memory = inMemoryWriteFs(config.generatedRouteTree);
+	await new Generator({
+		config,
+		root,
+		fs: memory.fs
+	}).run();
+	if (scanned === void 0) throw new Error(`pagegraph found no route tree in ${resolve(root, routesDirectory)}`);
+	return scanned;
+}
+//#endregion
+//#region src/tanstack-start/graph.ts
+/**
+* Build the graph from the app's own modules, evaluated in the `pagegraph`
+* Vite environment: one module per route file that declares `staticData`, plus
+* the app's collections module. Never the route tree, which reaches every
+* route — including app routes that only resolve inside the server runtime.
+*/
+const GRAPH_ROUTE_TYPES = /* @__PURE__ */ new Set([
+	"__root",
+	"static",
+	"layout",
+	"pathless_layout"
+]);
+const messageOf = (cause) => cause instanceof Error ? cause.message : String(cause);
+const routeStaticData = (module, file) => {
+	const route = module["Route"];
+	if (route?.options === void 0) throw new Error(`${file} has no \`Route\` export`);
+	const data = route.options.staticData;
+	return data === void 0 ? void 0 : {
+		seo: data.seo,
+		markdown: data.markdown,
+		llms: data.llms
+	};
+};
+const loadCollections = async (runner, root, fullPath) => {
+	const path = relative(root, fullPath);
+	const exported = (await runner.import(fullPath).catch((cause) => {
+		throw new Error(`pagegraph could not evaluate ${path}: ${messageOf(cause)}`, { cause });
+	}))["collections"];
+	if (exported === void 0) throw new Error(`${path} has no \`collections\` export`);
+	const collections = typeof exported === "function" ? await exported() : exported;
+	if (!Array.isArray(collections)) throw new Error(`${path} \`collections\` must be an array or return one`);
+	return collections;
+};
+/** Scan the routes directory and pick the modules an evaluation loads. */
+async function planGraph(root, options) {
+	const scan = await scanRoutes(root, options.routesDirectory ?? "src/routes");
+	const excluded = (options.exclude ?? []).map(globToRegExp);
+	const participates = (node) => GRAPH_ROUTE_TYPES.has(node._fsRouteType) && (node._fsRouteType === "__root" || node.createFileRouteProps?.has("staticData") === true) && !excluded.some((pattern) => pattern.test(node.filePath));
+	return {
+		root,
+		options,
+		scan,
+		routeFiles: [scan.root, ...scan.nodes].filter(participates).map((node) => node.fullPath),
+		collectionsFile: options.collections === void 0 ? void 0 : resolve(root, options.collections),
+		factsFile: options.facts === void 0 ? void 0 : resolve(root, options.facts)
+	};
+}
+/**
+* A route node's path relative to its parent, as the router matches it: route
+* groups, pathless layouts, and trailing underscores contribute no segment.
+*/
+const publicSegment = (node) => node.isNonPath === true || node.cleanedPath === void 0 || node.cleanedPath === "" ? void 0 : node.cleanedPath;
+/** Evaluate a plan's modules through `runner`, then build the graph and the site runtime. */
+async function evaluateGraph(runner, plan) {
+	const { root, options, scan } = plan;
+	const staticData = new Map(await Promise.all(plan.routeFiles.map(async (fullPath) => {
+		const file = relative(root, fullPath);
+		const routeFile = relative(resolve(root, options.routesDirectory ?? "src/routes"), fullPath);
+		const module = await runner.import(fullPath).catch((cause) => {
+			throw new Error(`pagegraph could not evaluate ${file} in the graph environment: ${messageOf(cause)}\nIf it is an app surface rather than a public page, add "${routeFile}" to pagegraph({ exclude }).`, { cause });
+		});
+		return [fullPath, routeStaticData(module, file)];
+	})));
+	const walkable = (node) => ({
+		options: {
+			path: publicSegment(node),
+			staticData: staticData.get(node.fullPath)
+		},
+		children: (node.children ?? []).map(walkable)
+	});
+	const routeTree = {
+		options: { staticData: staticData.get(scan.root.fullPath) },
+		children: scan.tree.map(walkable)
+	};
+	const collections = plan.collectionsFile === void 0 ? [] : await loadCollections(runner, root, plan.collectionsFile);
+	const graph = buildSeoGraph({
+		routeTree,
+		collections
+	});
+	const exclusions = options.routeConfig === void 0 ? [] : deriveRouteConfig(scan.nodes, resolveOptions({
+		...options.routeConfig,
+		routesDirectory: options.routesDirectory
+	})).robotsExclusions;
+	const site = {
+		origin: options.origin,
+		indexable: options.indexable ?? true,
+		robots: {
+			disallow: [.../* @__PURE__ */ new Set([...exclusions, ...options.robots?.disallow ?? []])].sort(),
+			contentSignal: options.robots?.contentSignal,
+			directives: options.robots?.directives
+		}
+	};
+	let facts;
+	if (plan.factsFile !== void 0) {
+		const path = relative(root, plan.factsFile);
+		try {
+			const module = await runner.import(plan.factsFile);
+			if (module["facts"] === void 0) throw new Error(`${path} has no \`facts\` export`);
+			facts = decodeFacts(module["facts"]);
+		} catch (cause) {
+			throw new Error(`pagegraph could not evaluate ${path}: ${messageOf(cause)}`, { cause });
+		}
+	}
+	return {
+		graph,
+		site,
+		markdown: options.markdown === void 0 ? null : { origin: options.markdown.origin },
+		facts
+	};
+}
+//#endregion
+//#region src/markdown/schema.ts
+const InlineNode = Schema.suspend(() => Schema.Union([
+	Schema.String,
+	Schema.Struct({
+		fact: Schema.String,
+		text: Schema.String
+	}),
+	Schema.Struct({
+		tag: Schema.Literals([
+			"em",
+			"strong",
+			"a",
+			"code",
+			"br"
+		]),
+		href: Schema.optionalKey(Schema.String),
+		children: Schema.Array(InlineNode)
+	})
+]));
+const Message = Schema.Struct({
+	hash: Schema.String,
+	tree: Schema.Array(InlineNode),
+	text: Schema.String,
+	source: Schema.String,
+	facts: Schema.Array(Schema.String),
+	audience: Schema.Literals([
+		"all",
+		"agents",
+		"humans"
+	])
+});
+const BodyEntry = Schema.Union([Schema.Struct({
+	type: Schema.Literal("message"),
+	message: Message
+}), Schema.Struct({
+	type: Schema.Literal("visual"),
+	text: Schema.String,
+	source: Schema.String,
+	audience: Schema.Literals([
+		"all",
+		"agents",
+		"humans"
+	])
+})]);
+const PageDocument = Schema.Struct({
+	path: Schema.String,
+	hash: Schema.String,
+	title: Schema.String,
+	description: Schema.String,
+	sections: Schema.Array(Schema.Struct({
+		claimsMarkdown: Schema.optionalKey(Schema.String),
+		evidence: Schema.optionalKey(Schema.Boolean),
+		kind: Schema.String,
+		id: Schema.String,
+		title: Schema.optionalKey(Message),
+		language: Schema.optionalKey(Schema.String),
+		body: Schema.Array(BodyEntry),
+		items: Schema.Array(Schema.Struct({
+			title: Schema.optionalKey(Message),
+			href: Schema.optionalKey(Schema.String),
+			body: Schema.Array(BodyEntry),
+			cells: Schema.Array(Message),
+			source: Schema.String,
+			audience: Schema.Literals([
+				"all",
+				"agents",
+				"humans"
+			])
+		})),
+		source: Schema.String,
+		audience: Schema.Literals([
+			"all",
+			"agents",
+			"humans"
+		])
+	})),
+	messages: Schema.Array(Message),
+	facts: Schema.Array(Schema.String)
+});
+const CaptureBundle = Schema.Struct({
+	origin: Schema.String,
+	documents: Schema.Array(PageDocument),
+	heads: Schema.Array(Schema.Struct({
+		path: Schema.String,
+		title: Schema.String,
+		description: Schema.String
+	}))
+});
+//#endregion
+//#region src/tanstack-start/persist-markdown.ts
+/** File names must remain inside the package's capture and the client's output trees. */
+function documentName(path) {
+	if (!path.startsWith("/") || path.startsWith("//") || /[?#\\$\u0000-\u001f\u007f]/.test(path) || path !== "/" && path.endsWith("/") || path.slice(1).split("/").some((part) => part === "." || part === ".." || part === "*" || part === "" && path !== "/")) throw new Error(`Invalid captured document path "${path}"`);
+	return path === "/" ? "index" : path.slice(1);
+}
+function verifyDocument(document) {
+	const name = documentName(document.path);
+	const { hash, ...content } = document;
+	if (!/^[0-9a-f]{64}$/.test(hash) || hashDocument(content) !== hash) throw new Error(`Invalid captured document hash for "${document.path}"`);
+	return name;
+}
+/** Only valid captures at their derived paths belong to pagegraph; preserve unrelated files. */
+async function pruneDocuments(directory, paths) {
+	const visit = async (folder) => {
+		const entries = await readdir(folder, { withFileTypes: true });
+		for (const entry of entries) {
+			const file = resolve(folder, entry.name);
+			if (entry.isDirectory()) {
+				await visit(file);
+				continue;
+			}
+			if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+			const contents = await readFile(file, "utf8");
+			let document;
+			let name;
+			try {
+				document = Schema.decodeUnknownSync(Schema.fromJsonString(PageDocument))(contents, { onExcessProperty: "error" });
+				name = verifyDocument(document);
+			} catch {
+				continue;
+			}
+			if (file === resolve(directory, `${name}.json`) && !paths.has(document.path)) await unlink(file);
+		}
+	};
+	await visit(directory);
+}
+/** Documents, twins, and graph heads are persisted before prerender onSuccess returns. */
+async function persistMarkdownCapture(html, root, clientOutDir, claims, facts = {}) {
+	const bundle = Schema.decodeUnknownSync(Schema.fromJsonString(CaptureBundle))(html, { onExcessProperty: "error" });
+	const origin = new URL(bundle.origin);
+	if (origin.protocol !== "https:" && origin.protocol !== "http:" || origin.origin !== bundle.origin) throw new Error(`Invalid captured markdown origin "${bundle.origin}"`);
+	const active = /* @__PURE__ */ new Set();
+	const destinations = /* @__PURE__ */ new Set();
+	const names = bundle.documents.map((document) => {
+		if (active.has(document.path)) throw new Error(`Duplicate captured document path "${document.path}"`);
+		active.add(document.path);
+		const name = verifyDocument(document);
+		if (destinations.has(name)) throw new Error(`Captured document paths share the output name "${name}"`);
+		destinations.add(name);
+		return name;
+	});
+	await unlink(resolve(clientOutDir, MARKDOWN_CAPTURE_PATH.slice(1)));
+	const directory = resolve(root, ".pagegraph/documents");
+	await mkdir(directory, { recursive: true });
+	for (const [index, document] of bundle.documents.entries()) {
+		const name = names[index];
+		const destination = resolve(directory, `${name}.json`);
+		const twin = resolve(clientOutDir, `${name}.md`);
+		await mkdir(dirname(destination), { recursive: true });
+		await writeFile(destination, JSON.stringify(document));
+		await mkdir(dirname(twin), { recursive: true });
+		await writeFile(twin, documentMarkdown(document, bundle.origin));
+	}
+	await pruneDocuments(directory, active);
+	await writeFile(resolve(root, ".pagegraph/heads.json"), `${JSON.stringify(bundle.heads)}\n`);
+	if (claims !== void 0) await Effect.runPromise(replayClaims(root, bundle.documents, bundle.heads, facts, claims));
+}
+//#endregion
+//#region src/tanstack-start/source.ts
+var DocumentSourceError = class extends Schema.TaggedError()("DocumentSourceError", { message: Schema.String }) {};
+const SOURCE_COMPONENTS = /* @__PURE__ */ new Set([
+	"T",
+	"Title",
+	"Section",
+	"Visual",
+	"ForAgents",
+	"ForHumans"
+]);
+const parse = Effect.fn("DocumentSource.parse")(function* (code, id) {
+	return yield* Effect.try({
+		try: () => parseAst(code, { lang: id.endsWith(".tsx") ? "tsx" : id.endsWith(".ts") ? "ts" : id.endsWith(".jsx") ? "jsx" : "js" }, id),
+		catch: (cause) => new DocumentSourceError({ message: `Cannot parse document source ${id}: ${cause instanceof Error ? cause.message : String(cause)}` })
+	});
+});
+function componentNames(program) {
+	const named = /* @__PURE__ */ new Set();
+	const sections = /* @__PURE__ */ new Set();
+	const namespaces = /* @__PURE__ */ new Set();
+	for (const node of program.body) {
+		if (node.type !== "ImportDeclaration" || node.source.value !== "pagegraph/react" || node.importKind === "type") continue;
+		for (const specifier of node.specifiers) if (specifier.type === "ImportSpecifier") {
+			if (specifier.importKind === "type") continue;
+			const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+			if (SOURCE_COMPONENTS.has(imported)) named.add(specifier.local.name);
+			if (imported === "Section") sections.add(specifier.local.name);
+		} else if (specifier.type === "ImportNamespaceSpecifier") namespaces.add(specifier.local.name);
+	}
+	return {
+		named,
+		sections,
+		namespaces
+	};
+}
+function memberParts(name) {
+	if (name.type === "JSXIdentifier") return [name.name];
+	if (name.type !== "JSXMemberExpression") return [];
+	return [...memberParts(name.object), name.property.name];
+}
+function isSourceComponent(name, names) {
+	const [base, ...members] = memberParts(name);
+	if (base === void 0) return false;
+	if (members.length === 0) return names.named.has(base);
+	if (names.namespaces.has(base)) return members.length === 1 && members[0] !== void 0 && SOURCE_COMPONENTS.has(members[0]) || members.length === 2 && members[0] === "Section" && members[1] === "Item";
+	return names.sections.has(base) && members.length === 1 && members[0] === "Item";
+}
+function walk(value, visit) {
+	if (Array.isArray(value)) for (const child of value) walk(child, visit);
+	else if (typeof value === "object" && value !== null) {
+		if (isOpeningElement(value)) visit(value);
+		for (const child of Object.values(value)) walk(child, visit);
+	}
+}
+function isOpeningElement(node) {
+	return "type" in node && node.type === "JSXOpeningElement";
+}
+function transformDocumentSource(code, id, root) {
+	const program = Effect.runSync(parse(code, id));
+	const names = componentNames(program);
+	const edits = [];
+	const file = relative(resolve(root), resolve(id)).split(sep).join("/");
+	walk(program, (node) => {
+		if (!isSourceComponent(node.name, names)) return;
+		if (node.attributes.some((attribute) => attribute.type === "JSXAttribute" && attribute.name.type === "JSXIdentifier" && attribute.name.name === "source")) return;
+		const line = code.slice(0, node.start).split("\n").length;
+		edits.push({
+			start: node.name.end,
+			end: node.name.end,
+			value: ` source=${JSON.stringify(`${file}:${line}`)}`
+		});
+	});
+	if (edits.length === 0) return void 0;
+	edits.sort((a, b) => b.start - a.start);
+	let transformed = code;
+	for (const edit of edits) transformed = transformed.slice(0, edit.start) + edit.value + transformed.slice(edit.end);
+	return { code: transformed };
+}
+//#endregion
+//#region src/tanstack-start/plugin.ts
+/**
+* The `pagegraph()` Vite plugin for TanStack Start.
+*
+* The graph is built once per build (and on change in dev) inside the app's own
+* Vite pipeline, then shipped to the server runtime as `virtual:pagegraph/runtime`.
+* The Worker never rebuilds it and never imports build code.
+*
+* Route modules and content collections are evaluated in a dedicated Node
+* environment, `pagegraph`, that shares the app's plugins, aliases, and
+* `define`s. Two settings make that safe:
+* - its `resolve.noExternal` is cleared, so TanStack Start's packages load from
+*   node_modules, where their virtual router entry is an inert stub. Bundled (as
+*   the app's server bundles them), they would pull in the whole route tree.
+* - only route files that declare `staticData` are evaluated, one by one, never
+*   `routeTree.gen.ts`.
+*
+* Dev imports those modules through the environment's module runner and
+* re-evaluates after a change reaches it. A build builds the environment first
+* (a `buildApp` hook that runs before the framework's) with the build's own
+* config and plugins, then imports the output. The CLI and `loadPageHeads` use
+* {@link evaluateAppGraph}, which runs the dev path without a server.
+*/
+const GRAPH_ENVIRONMENT$1 = "pagegraph";
+const PLUGIN_NAME = "pagegraph";
+const RESOLVED_RUNTIME_ID = `\0virtual:pagegraph/runtime`;
+const ENTRY_ID = "virtual:pagegraph/entry";
+const RESOLVED_ENTRY_ID = `\0${ENTRY_ID}`;
+/** The runtime entry imports the virtual module, so dep pre-bundling must leave it to this plugin. */
+const RUNTIME_ENTRIES = [
+	"pagegraph/tanstack-start/server",
+	"pagegraph/tanstack-start/markdown",
+	"pagegraph/tanstack-start/react"
+];
+/** Where a build writes the graph environment's output, relative to the Vite root. */
+const BUILD_DIRECTORY = "node_modules/.cache/pagegraph/build";
+const runtimeModulesPlugin = {
+	name: "pagegraph:runtime-modules",
+	enforce: "post",
+	applyToEnvironment: (environment) => environment.name === GRAPH_ENVIRONMENT$1,
+	resolveId: {
+		filter: { id: /^(?!node:|data:|file:|virtual:)[a-z][a-z0-9+.-]*:/ },
+		handler: (id) => ({
+			id,
+			external: true
+		})
+	}
+};
+const runtimeModule = ({ graph, site, markdown, facts }) => `export const graph = ${JSON.stringify(graphToJson(graph))};\nexport const site = ${JSON.stringify(site)};\nexport const markdown = ${JSON.stringify(markdown)};\nexport const facts = ${JSON.stringify(facts) ?? "undefined"};\n`;
+/** The graph environment's build entry: a loader per module the plan evaluates. */
+const entryModule = (plan) => {
+	return `export const modules = {\n${[
+		...plan.routeFiles,
+		...plan.collectionsFile === void 0 ? [] : [plan.collectionsFile],
+		...plan.factsFile === void 0 ? [] : [plan.factsFile]
+	].map((file) => `  ${JSON.stringify(file)}: () => import(${JSON.stringify(file)}),`).join("\n")}\n};\n`;
+};
+/** Build the graph environment with the build's config, import its output, and evaluate. */
+const buildGraph = async (builder, environment, plan) => {
+	await builder.build(environment);
+	const entry = join(resolve(environment.config.root, environment.config.build.outDir), "entry.mjs");
+	const { modules } = await import(pathToFileURL(entry).href);
+	return evaluateGraph({ import: (file) => {
+		const load = modules[file];
+		if (load === void 0) throw new Error(`${file} is not in the graph build`);
+		return load();
+	} }, plan);
+};
+function pagegraph(options) {
+	if (options.claims !== void 0 && options.markdown === void 0) throw new Error("Claims require pagegraph({ markdown: { origin }, claims: { rules, model } }) so the build captures documents.");
+	const api = { options };
+	let root = process.cwd();
+	let clientOutDir = resolve(root, "dist/client");
+	let server;
+	let devEnvironment;
+	/** The plan the graph environment's build entry is generated from. */
+	let buildPlan;
+	let current;
+	/** Bumped by every change that reaches the graph; an evaluation that spans one is discarded. */
+	let generation = 0;
+	const evaluateInDev = async (environment) => {
+		for (;;) {
+			const started = generation;
+			environment.runner.clearCache();
+			const result = await evaluateGraph(environment.runner, await planGraph(root, options));
+			if (started === generation) return result;
+		}
+	};
+	return Object.assign([
+		{
+			name: PLUGIN_NAME,
+			api,
+			sharedDuringBuild: true,
+			config() {
+				return { environments: { [GRAPH_ENVIRONMENT$1]: {
+					consumer: "server",
+					dev: { createEnvironment: (name, environmentConfig) => createRunnableDevEnvironment(name, environmentConfig) },
+					build: {
+						outDir: BUILD_DIRECTORY,
+						emptyOutDir: true,
+						copyPublicDir: false,
+						minify: false,
+						rolldownOptions: {
+							input: { entry: ENTRY_ID },
+							output: {
+								entryFileNames: "[name].mjs",
+								chunkFileNames: "chunks/[name]-[hash].mjs"
+							}
+						}
+					}
+				} } };
+			},
+			configEnvironment(name, environmentConfig) {
+				if (name === "pagegraph") {
+					environmentConfig.resolve ??= {};
+					environmentConfig.resolve.noExternal = [];
+					return;
+				}
+				environmentConfig.optimizeDeps ??= {};
+				environmentConfig.optimizeDeps.exclude = [...environmentConfig.optimizeDeps.exclude ?? [], ...RUNTIME_ENTRIES];
+			},
+			configResolved(resolved) {
+				root = resolved.root;
+				clientOutDir = resolve(root, resolved.environments.client?.build.outDir ?? "dist/client");
+			},
+			configureServer: {
+				order: "pre",
+				handler(devServer) {
+					server = devServer;
+					devEnvironment = devServer.environments[GRAPH_ENVIRONMENT$1];
+				}
+			},
+			hotUpdate({ file, modules }) {
+				if (this.environment.name !== "pagegraph") return;
+				const routesDirectory = resolve(root, options.routesDirectory ?? "src/routes");
+				if (modules.length === 0 && !file.startsWith(`${routesDirectory}/`)) return;
+				generation += 1;
+				current = void 0;
+				for (const other of Object.values(server?.environments ?? {})) {
+					if (other.name === "pagegraph") continue;
+					const runtime = other.moduleGraph.getModuleById(RESOLVED_RUNTIME_ID);
+					if (runtime !== void 0) other.reloadModule(runtime);
+				}
+			},
+			buildApp: {
+				order: "pre",
+				async handler(builder) {
+					const environment = builder.environments[GRAPH_ENVIRONMENT$1];
+					if (environment === void 0) return;
+					buildPlan = await planGraph(environment.config.root, options);
+					const built = buildGraph(builder, environment, buildPlan);
+					current = built;
+					await built;
+					environment.isBuilt = false;
+				}
+			},
+			resolveId: {
+				filter: { id: /^virtual:pagegraph\/(runtime|entry)$/ },
+				handler: (id) => `\0${id}`
+			},
+			load: {
+				filter: { id: /^\0virtual:pagegraph\/(runtime|entry)$/ },
+				async handler(id) {
+					if (id === RESOLVED_ENTRY_ID) {
+						if (buildPlan === void 0) throw new Error(`[${PLUGIN_NAME}] ${ENTRY_ID} is only built by the pagegraph buildApp hook`);
+						return entryModule(buildPlan);
+					}
+					if (this.environment.name === "pagegraph") return "export const graph = null;\nexport const site = null;\nexport const markdown = null;\nexport const facts = undefined;\n";
+					if (current === void 0) {
+						if (devEnvironment === void 0) throw new Error(`[${PLUGIN_NAME}] the graph was not built before ${this.environment.name} imported it; build with Vite's app builder (\`vite build\`).`);
+						current = evaluateInDev(devEnvironment);
+					}
+					return runtimeModule(await current);
+				}
+			}
+		},
+		{
+			name: "pagegraph:markdown",
+			enforce: "pre",
+			applyToEnvironment: (environment) => environment.name !== GRAPH_ENVIRONMENT$1,
+			resolveId: {
+				filter: { id: /^virtual:pagegraph\/prerender-server$/ },
+				handler: (id) => `\0${id}`
+			},
+			load: {
+				filter: { id: /^\0virtual:pagegraph\/prerender-server$/ },
+				handler: () => `export { default } from ${JSON.stringify(resolve(root, options.markdown?.serverEntry ?? "dist/server/index.js"))};`
+			},
+			transform: {
+				filter: {
+					id: /\.[jt]sx?(\?|$)/,
+					code: /pagegraph\/react/
+				},
+				handler(code, id) {
+					const file = id.split("?")[0];
+					if (file === void 0 || file.includes("/node_modules/") || file.endsWith(".gen.ts") || !file.startsWith(`${root}/`)) return;
+					return transformDocumentSource(code, file, root);
+				}
+			},
+			configurePreviewServer(previewServer) {
+				previewServer.middlewares.use((_request, response, next) => {
+					response.on("finish", () => {
+						const error = response.getHeader("x-pagegraph-error");
+						if (typeof error === "string") previewServer.config.logger.error(decodeURIComponent(error));
+					});
+					next();
+				});
+			}
+		},
+		runtimeModulesPlugin,
+		...options.routeConfig === void 0 ? [] : [seoRouteConfig({
+			...options.routeConfig,
+			routesDirectory: options.routesDirectory
+		})]
+	], { prerenderPages: options.markdown === void 0 ? [] : [{
+		path: MARKDOWN_CAPTURE_PATH,
+		sitemap: { exclude: true },
+		prerender: { onSuccess: async ({ html }) => {
+			if (current === void 0) throw new Error("The pagegraph graph must be evaluated before Markdown persistence.");
+			const app = await current;
+			await persistMarkdownCapture(html, root, clientOutDir, options.claims, app.facts);
+		} }
+	}] });
+}
+//#endregion
+//#region src/tanstack-start/load.ts
+/**
+* Evaluate an app's graph outside a running dev server — for a build, the
+* CLI (`pagegraph.config.ts`), and build-time head loading — through the same
+* `pagegraph` environment the dev server uses.
+*/
+const GRAPH_ENVIRONMENT = "pagegraph";
+const cliEnvironmentOverride = (command) => command === "build" ? { [GRAPH_ENVIRONMENT]: { isBundled: false } } : void 0;
+/** Locate the config without overriding its authored root with an inline root. */
+const appConfig = (options) => ({
+	configFile: options.configFile ?? [
+		"js",
+		"mjs",
+		"ts",
+		"cjs",
+		"mts",
+		"cts"
+	].map((extension) => resolve(options.root, `vite.config.${extension}`)).find(existsSync) ?? false,
+	logLevel: "error",
+	plugins: [{
+		name: "pagegraph:loader-root",
+		enforce: "pre",
+		config(config) {
+			config.root ??= options.root;
+		}
+	}]
+});
+const pluginApi = (plugins, configFile) => {
+	const plugin = plugins.find((candidate) => candidate.name === "pagegraph");
+	if (plugin?.api === void 0) throw new Error(`${configFile ?? "The Vite config"} does not register pagegraph() from "pagegraph/tanstack-start".`);
+	return plugin.api;
+};
+/**
+* Resolve the app's Vite config, evaluate the graph in its `pagegraph`
+* environment, and release it. The command defaults to `serve`; callers can
+* request `build` to match the deployed site configuration.
+*/
+async function evaluateAppGraph(options) {
+	const command = options.command ?? "serve";
+	const config = await resolveConfig({
+		...appConfig(options),
+		mode: options.mode,
+		environments: cliEnvironmentOverride(command)
+	}, command);
+	const api = pluginApi(config.plugins, config.configFile);
+	const environment = createRunnableDevEnvironment(GRAPH_ENVIRONMENT, config, { hot: false });
+	await environment.init();
+	try {
+		await environment.pluginContainer.buildStart({});
+		const app = await evaluateGraph(environment.runner, await planGraph(config.root, api.options));
+		return {
+			...app,
+			pagegraph: {
+				root: config.root,
+				options: api.options,
+				facts: app.facts ?? {}
+			}
+		};
+	} finally {
+		await environment.close();
+	}
+}
+/**
+* A `pagegraph.config.ts` graph loader for a TanStack Start app. It uses the
+* built site's identity by default; pass `command: "serve"` for a dev host.
+*
+* ```ts
+* export default defineSeoConfig({
+*   loadGraph: tanstackStartGraph({ root: import.meta.dirname }),
+* });
+* ```
+*/
+const tanstackStartGraph = (options) => async (_input, environment) => {
+	const { graph, site, pagegraph } = await withCleanStdout(() => evaluateAppGraph({
+		...options,
+		command: environment?.command ?? options.command ?? "build",
+		mode: environment?.mode ?? options.mode ?? "production"
+	}));
+	return {
+		graph,
+		site,
+		pagegraph,
+		dispose: async () => {}
+	};
+};
+//#endregion
+export { evaluateAppGraph, pagegraph, tanstackStartGraph };
+
+//# sourceMappingURL=index.js.map