pagegraph 0.12.0 → 0.14.0

package/dist/tanstack-start/index.js

@@ -1,11 +1,20 @@
-import { t as buildSeoGraph } from "../graph-Bcsourlv.js";
+import { t as buildSeoGraph } from "../graph-DMNOLXLu.js";
 import { n as graphToJson } from "../wire-B4RQMc4e.js";
-import { a as globToRegExp } from "../checks-uZk5Em9A.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-01p1WxEq.js";
-import { join, relative, resolve } from "node:path";
+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, resolveConfig } from "vite";
+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
 /**
@@ -60,7 +69,12 @@ const messageOf = (cause) => cause instanceof Error ? cause.message : String(cau
 const routeStaticData = (module, file) => {
 	const route = module["Route"];
 	if (route?.options === void 0) throw new Error(`${file} has no \`Route\` export`);
-	return route.options.staticData;
+	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);
@@ -82,7 +96,8 @@ async function planGraph(root, options) {
 		options,
 		scan,
 		routeFiles: [scan.root, ...scan.nodes].filter(participates).map((node) => node.fullPath),
-		collectionsFile: options.collections === void 0 ? void 0 : resolve(root, options.collections)
+		collectionsFile: options.collections === void 0 ? void 0 : resolve(root, options.collections),
+		factsFile: options.facts === void 0 ? void 0 : resolve(root, options.facts)
 	};
 }
 /**
@@ -121,18 +136,269 @@ async function evaluateGraph(runner, plan) {
 		...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: {
-			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
+		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
@@ -164,7 +430,11 @@ 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_ENTRY = "pagegraph/tanstack-start/server";
+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 = {
@@ -179,10 +449,14 @@ const runtimeModulesPlugin = {
 		})
 	}
 };
-const runtimeModule = ({ graph, site }) => `export const graph = ${JSON.stringify(graphToJson(graph))};\nexport const site = ${JSON.stringify(site)};\n`;
+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]].map((file) => `  ${JSON.stringify(file)}: () => import(${JSON.stringify(file)}),`).join("\n")}\n};\n`;
+	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) => {
@@ -196,8 +470,10 @@ const buildGraph = async (builder, environment, plan) => {
 	} }, 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 = "";
+	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. */
@@ -213,7 +489,7 @@ function pagegraph(options) {
 			if (started === generation) return result;
 		}
 	};
-	return [
+	return Object.assign([
 		{
 			name: PLUGIN_NAME,
 			api,
@@ -244,14 +520,18 @@ function pagegraph(options) {
 					return;
 				}
 				environmentConfig.optimizeDeps ??= {};
-				environmentConfig.optimizeDeps.exclude = [...environmentConfig.optimizeDeps.exclude ?? [], RUNTIME_ENTRY];
+				environmentConfig.optimizeDeps.exclude = [...environmentConfig.optimizeDeps.exclude ?? [], ...RUNTIME_ENTRIES];
 			},
 			configResolved(resolved) {
 				root = resolved.root;
+				clientOutDir = resolve(root, resolved.environments.client?.build.outDir ?? "dist/client");
 			},
-			configureServer(devServer) {
-				server = devServer;
-				devEnvironment = devServer.environments[GRAPH_ENVIRONMENT$1];
+			configureServer: {
+				order: "pre",
+				handler(devServer) {
+					server = devServer;
+					devEnvironment = devServer.environments[GRAPH_ENVIRONMENT$1];
+				}
 			},
 			hotUpdate({ file, modules }) {
 				if (this.environment.name !== "pagegraph") return;
@@ -288,7 +568,7 @@ function pagegraph(options) {
 						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;\n";
+					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);
@@ -297,68 +577,137 @@ function pagegraph(options) {
 				}
 			}
 		},
+		{
+			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 (`seo.config.ts`), and build-time head loading — through the same
+* 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 in serve mode, evaluate the graph in its
-* `pagegraph` environment, and release it — the dev server's evaluation path
-* without a server. A config that branches on `command` sees `serve`; pass
-* `mode` for the deployment the graph should describe.
+* 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({
-		root: options.root,
-		configFile: options.configFile,
+		...appConfig(options),
 		mode: options.mode,
-		logLevel: "error"
-	}, "serve");
+		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({});
-		return await evaluateGraph(environment.runner, await planGraph(config.root, api.options));
+		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 `seo.config.ts` graph loader for a TanStack Start app: the same graph the
-* `pagegraph()` plugin ships to the runtime, with its robots policy.
+* 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({
-*   origin: "https://example.com",
 *   loadGraph: tanstackStartGraph({ root: import.meta.dirname }),
 * });
 * ```
 */
-const tanstackStartGraph = (options) => async () => {
-	const { graph, site } = await withCleanStdout(() => evaluateAppGraph({
+const tanstackStartGraph = (options) => async (_input, environment) => {
+	const { graph, site, pagegraph } = await withCleanStdout(() => evaluateAppGraph({
 		...options,
-		mode: options.mode ?? "production"
+		command: environment?.command ?? options.command ?? "build",
+		mode: environment?.mode ?? options.mode ?? "production"
 	}));
 	return {
 		graph,
-		robots: site.robots,
+		site,
+		pagegraph,
 		dispose: async () => {}
 	};
 };