@askrjs/askr 0.0.52 → 0.0.53

package/dist/ssg/create-static-gen.js

@@ -1,250 +0,0 @@
-import { addPerfDuration, incrementPerfMetric } from "../runtime/perf-metrics.js";
-import "../runtime/index.js";
-import { resolveRouteDescriptor } from "./route-utils.js";
-import { resolveSsgData, resolveSsgRouteData, validateRoutes } from "./resolve-ssg-data.js";
-import { batchRenderRoutes } from "./batch-render.js";
-import { writeStaticFiles } from "./write-static-files.js";
-import { generateSSGResult, resultToMetadata, writeMetadata } from "./generate-metadata.js";
-import { getExistingOutputFileSize, hashHtml, outputFileExists, readIncrementalManifest, writeIncrementalManifest } from "./incremental-manifest.js";
-import { collectRemovedRouteResults, dedupeStrings, getRoutesToRender, selectRouteForGeneration } from "./generation-plan.js";
-import { normalizeStaticRoutes, splitStaticRoutes } from "./static-routes.js";
-import * as fs from "node:fs/promises";
-import * as pathModule from "node:path";
-import * as os from "node:os";
-//#region src/ssg/create-static-gen.ts
-function resolveParallelism(requested) {
-	if (requested !== "auto") return Math.max(1, requested ?? 1);
-	const maybeNavigator = globalThis;
-	const envWorkers = Number(maybeNavigator.process?.env?.ASKR_SSG_WORKERS ?? maybeNavigator.process?.env?.NUMBER_OF_PROCESSORS ?? maybeNavigator.process?.env?.UV_THREADPOOL_SIZE);
-	if (Number.isFinite(envWorkers) && envWorkers > 0) return Math.max(1, Math.trunc(envWorkers));
-	if (typeof maybeNavigator.navigator?.hardwareConcurrency === "number") return Math.max(1, maybeNavigator.navigator.hardwareConcurrency);
-	const availableParallelism = os.availableParallelism;
-	return Math.max(1, availableParallelism?.() ?? os.cpus().length ?? 1);
-}
-async function createStagingDirectory(outputDir) {
-	const parent = pathModule.dirname(outputDir);
-	const base = pathModule.basename(outputDir);
-	await fs.mkdir(parent, { recursive: true });
-	return fs.mkdtemp(pathModule.join(parent, `.${base}.askr-staging-`));
-}
-async function replaceOutputDirectory(stagingDir, outputDir, fileOperations = fs) {
-	const parent = pathModule.dirname(outputDir);
-	const backupDir = pathModule.join(parent, `.${pathModule.basename(outputDir)}.askr-backup-${Date.now()}`);
-	let backedUp = false;
-	try {
-		try {
-			await fileOperations.rename(outputDir, backupDir);
-			backedUp = true;
-		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
-		}
-		await fileOperations.rename(stagingDir, outputDir);
-		await fileOperations.rm(backupDir, {
-			recursive: true,
-			force: true
-		});
-	} catch (error) {
-		if (backedUp) {
-			await fileOperations.rm(outputDir, {
-				recursive: true,
-				force: true
-			});
-			await fileOperations.rename(backupDir, outputDir);
-		}
-		throw error;
-	} finally {
-		await fileOperations.rm(stagingDir, {
-			recursive: true,
-			force: true
-		});
-	}
-}
-/**
-* Create a Static Site Generator
-*
-* Usage:
-* ```ts
-* const ssg = createStaticGen({
-*   routes: [
-*     { path: '/', component: HomePage },
-*     { path: '/about', component: AboutPage },
-*   ],
-*   outputDir: './dist',
-*   dataOverrides: {
-*     '/api/posts': { posts: [...] }
-*   }
-* });
-*
-* const result = await ssg.generate();
-* console.log(`Generated ${result.successful}/${result.totalRoutes} routes`);
-* ```
-*/
-function createStaticGen(options) {
-	let result = null;
-	const configuredRoutes = normalizeStaticRoutes(options);
-	const seed = options.seed ?? 12345;
-	const resolvedParallelism = resolveParallelism(options.parallelism);
-	const resolvedConcurrency = Math.max(1, options.concurrency ?? resolvedParallelism);
-	if (configuredRoutes.length === 0) throw new Error("routes array or route registry is required");
-	if (!options.outputDir || options.outputDir.trim().length === 0) throw new Error("outputDir is required");
-	return {
-		/**
-		* Generate static HTML for all routes
-		* Writes to outputDir with metadata.json
-		* Returns detailed results
-		*/
-		async generate(generateOptions = {}) {
-			const splitRoutes = await splitStaticRoutes(configuredRoutes);
-			const routes = splitRoutes.routes;
-			validateRoutes(routes);
-			const changedKeys = dedupeStrings(generateOptions.changedKeys);
-			const changedRoutes = dedupeStrings(generateOptions.changedRoutes);
-			const requestedMode = generateOptions.mode ?? "full";
-			const previousManifest = !generateOptions.forceFull && requestedMode === "incremental" ? readIncrementalManifest(options.outputDir, seed) : null;
-			const effectiveMode = generateOptions.forceFull || requestedMode !== "incremental" || previousManifest === null ? "full" : "incremental";
-			const dataMap = resolveSsgData(routes, { dataOverrides: options.dataOverrides });
-			const descriptors = routes.map(resolveRouteDescriptor);
-			const routeResultsById = /* @__PURE__ */ new Map();
-			for (const runtimeRoute of splitRoutes.runtimeOnly) routeResultsById.set(runtimeRoute.routeId, runtimeRoute.result);
-			const eligibleDescriptors = descriptors;
-			const previousEntries = new Map((previousManifest?.routes ?? []).map((entry) => [entry.routeId, entry]));
-			const currentRouteIds = new Set(eligibleDescriptors.map((descriptor) => descriptor.routeId));
-			const selected = [];
-			const routesToRender = [];
-			for (let index = 0; index < eligibleDescriptors.length; index += 1) {
-				const descriptor = eligibleDescriptors[index];
-				const entry = selectRouteForGeneration(descriptor, previousEntries.get(descriptor.routeId) ?? null, effectiveMode, changedKeys, changedRoutes);
-				selected.push(entry);
-				if (entry.reason !== "unchanged") routesToRender.push(entry);
-			}
-			const renderStartTime = performance.now();
-			incrementPerfMetric("ssgWorkerCount", resolvedParallelism);
-			const renderedResults = routesToRender.length > 0 ? await batchRenderRoutes(getRoutesToRender(routesToRender), {
-				seed,
-				dataMap,
-				concurrency: resolvedConcurrency,
-				document: options.document
-			}) : [];
-			addPerfDuration("ssgRenderTimeMs", performance.now() - renderStartTime);
-			const renderedByRouteId = /* @__PURE__ */ new Map();
-			for (let index = 0; index < renderedResults.length; index += 1) renderedByRouteId.set(routesToRender[index].descriptor.routeId, renderedResults[index]);
-			let cacheHits = 0;
-			const nextManifestRoutes = [];
-			for (const entry of selected) {
-				const { descriptor, previous, reason } = entry;
-				const resolvedData = resolveSsgRouteData(dataMap, descriptor.route.path, descriptor.path);
-				const baseData = resolvedData.hasData ? resolvedData.data : void 0;
-				const resourceCount = resolvedData.hasData && baseData ? Object.keys(baseData).length : 0;
-				if (reason === "unchanged") {
-					routeResultsById.set(descriptor.routeId, {
-						path: descriptor.path,
-						filePath: descriptor.filePath,
-						html: "",
-						fileSize: previous?.htmlHash !== null && previous !== null ? getExistingOutputFileSize(options.outputDir, descriptor.filePath) : 0,
-						renderDuration: 0,
-						resourceCount,
-						status: "skipped",
-						reason: "unchanged",
-						written: false
-					});
-					if (previous) nextManifestRoutes.push({
-						...previous,
-						path: descriptor.path,
-						filePath: descriptor.filePath,
-						invalidationKeys: descriptor.invalidationKeys.slice()
-					});
-					continue;
-				}
-				const rendered = renderedByRouteId.get(descriptor.routeId);
-				if (!rendered) throw new Error(`Missing rendered result for route "${descriptor.path}"`);
-				const nextResult = {
-					...rendered,
-					path: descriptor.path,
-					filePath: descriptor.filePath,
-					resourceCount,
-					reason,
-					written: false
-				};
-				if (nextResult.status === "success") {
-					const htmlDigest = hashHtml(nextResult.html);
-					const shouldWrite = effectiveMode === "full" || !previous || previous.htmlHash !== htmlDigest || !outputFileExists(options.outputDir, descriptor.filePath);
-					nextResult.written = shouldWrite;
-					if (!shouldWrite) cacheHits += 1;
-					nextManifestRoutes.push({
-						routeId: descriptor.routeId,
-						path: descriptor.path,
-						filePath: descriptor.filePath,
-						invalidationKeys: descriptor.invalidationKeys.slice(),
-						htmlHash: htmlDigest,
-						lastStatus: "success"
-					});
-				} else nextManifestRoutes.push({
-					routeId: descriptor.routeId,
-					path: descriptor.path,
-					filePath: descriptor.filePath,
-					invalidationKeys: descriptor.invalidationKeys.slice(),
-					htmlHash: previous?.htmlHash ?? null,
-					lastStatus: "error"
-				});
-				routeResultsById.set(descriptor.routeId, nextResult);
-			}
-			const removedResults = collectRemovedRouteResults(previousManifest, currentRouteIds);
-			const routeResults = [];
-			for (const routeId of splitRoutes.outputRouteIds) {
-				const routeResult = routeResultsById.get(routeId);
-				if (routeResult) routeResults.push(routeResult);
-			}
-			routeResults.push(...removedResults);
-			result = generateSSGResult(routeResults, {
-				mode: effectiveMode,
-				cacheHits,
-				invalidatedKeys: changedKeys,
-				invalidatedRoutes: changedRoutes
-			});
-			if (effectiveMode === "full" && result.failed > 0) return result;
-			const targetOutputDir = effectiveMode === "full" ? await createStagingDirectory(options.outputDir) : options.outputDir;
-			try {
-				const writeStartTime = performance.now();
-				await writeStaticFiles(routeResults, targetOutputDir, { concurrency: resolvedConcurrency });
-				addPerfDuration("ssgWriteTimeMs", performance.now() - writeStartTime);
-				await writeMetadata(resultToMetadata(result), targetOutputDir);
-				await writeIncrementalManifest({
-					schemaVersion: 1,
-					seed,
-					mode: effectiveMode,
-					routes: nextManifestRoutes
-				}, targetOutputDir);
-				if (effectiveMode === "full") await replaceOutputDirectory(targetOutputDir, options.outputDir);
-			} catch (error) {
-				if (effectiveMode === "full") await fs.rm(targetOutputDir, {
-					recursive: true,
-					force: true
-				});
-				throw error;
-			}
-			return result;
-		},
-		/**
-		* Get effective config in a serializable form for diagnostics.
-		*/
-		getConfig() {
-			return {
-				routeCount: configuredRoutes.length,
-				outputDir: options.outputDir,
-				seed,
-				concurrency: resolvedConcurrency,
-				parallelism: resolvedParallelism,
-				hasDataOverrides: !!options.dataOverrides
-			};
-		},
-		/**
-		* Get the last generation result
-		* Returns null if generate() hasn't been called
-		*/
-		getResult() {
-			return result;
-		}
-	};
-}
-//#endregion
-export { createStaticGen, replaceOutputDirectory };

package/dist/ssg/generate-metadata.js

@@ -1,92 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as pathModule from "node:path";
-//#region src/ssg/generate-metadata.ts
-/**
-* Metadata generation for SSG
-*
-* Generates and serializes metadata about generated static files.
-* This module is Node-only and not intended for browser builds.
-*/
-/**
-* Generate SSGResult from render results
-*/
-function generateSSGResult(results, options = {}) {
-	let successful = 0;
-	let failed = 0;
-	let totalDuration = 0;
-	let rebuilt = 0;
-	let skipped = 0;
-	let removed = 0;
-	for (let index = 0; index < results.length; index += 1) {
-		const result = results[index];
-		totalDuration += result.renderDuration;
-		if (result.status === "success") {
-			successful += 1;
-			rebuilt += 1;
-		} else if (result.status === "error") {
-			failed += 1;
-			rebuilt += 1;
-		} else if (result.status === "skipped") skipped += 1;
-		else if (result.status === "removed") removed += 1;
-	}
-	return {
-		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		totalRoutes: results.length,
-		successful,
-		failed,
-		totalDuration: Math.round(totalDuration),
-		mode: options.mode ?? "full",
-		rebuilt,
-		skipped,
-		removed,
-		cacheHits: options.cacheHits ?? 0,
-		invalidatedKeys: options.invalidatedKeys?.slice() ?? [],
-		invalidatedRoutes: options.invalidatedRoutes?.slice() ?? [],
-		routes: results
-	};
-}
-/**
-* Convert SSGResult to metadata for JSON serialization
-*/
-function resultToMetadata(result) {
-	const routes = [];
-	for (let index = 0; index < result.routes.length; index += 1) {
-		const route = result.routes[index];
-		routes.push({
-			path: route.path,
-			filePath: route.filePath,
-			fileSize: route.fileSize,
-			renderDuration: route.renderDuration,
-			resourceCount: route.resourceCount,
-			status: route.status,
-			reason: route.reason,
-			written: route.written,
-			error: route.error
-		});
-	}
-	return {
-		generatedAt: result.generatedAt,
-		totalRoutes: result.totalRoutes,
-		successful: result.successful,
-		failed: result.failed,
-		totalDuration: result.totalDuration,
-		mode: result.mode,
-		rebuilt: result.rebuilt,
-		skipped: result.skipped,
-		removed: result.removed,
-		cacheHits: result.cacheHits,
-		invalidatedKeys: result.invalidatedKeys.slice(),
-		invalidatedRoutes: result.invalidatedRoutes.slice(),
-		routes
-	};
-}
-/**
-* Write metadata.json to output directory
-*/
-async function writeMetadata(metadata, outputDir) {
-	const filePath = pathModule.join(outputDir, "metadata.json");
-	await fs.mkdir(outputDir, { recursive: true });
-	await fs.writeFile(filePath, JSON.stringify(metadata, null, 2), "utf8");
-}
-//#endregion
-export { generateSSGResult, resultToMetadata, writeMetadata };

package/dist/ssg/generation-plan.js

@@ -1,68 +0,0 @@
-//#region src/ssg/generation-plan.ts
-function dedupeStrings(values) {
-	return values ? Array.from(new Set(values)) : [];
-}
-function getRoutesToRender(selected) {
-	const routes = [];
-	for (let index = 0; index < selected.length; index += 1) routes.push(selected[index].descriptor.route);
-	return routes;
-}
-function selectRouteForGeneration(descriptor, previous, mode, changedKeys, changedRoutes) {
-	if (mode === "full") return {
-		descriptor,
-		reason: "full",
-		previous
-	};
-	if (!previous) return {
-		descriptor,
-		reason: "new-route",
-		previous
-	};
-	if (previous.lastStatus === "error" || previous.htmlHash === null) return {
-		descriptor,
-		reason: "new-route",
-		previous
-	};
-	if (descriptor.invalidationKeys.length === 0) return {
-		descriptor,
-		reason: "no-keys",
-		previous
-	};
-	if (changedRoutes.includes(descriptor.path)) return {
-		descriptor,
-		reason: "changed-route",
-		previous
-	};
-	if (descriptor.invalidationKeys.some((key) => changedKeys.includes(key))) return {
-		descriptor,
-		reason: "changed-key",
-		previous
-	};
-	return {
-		descriptor,
-		reason: "unchanged",
-		previous
-	};
-}
-function collectRemovedRouteResults(manifest, currentRouteIds) {
-	if (!manifest) return [];
-	const results = [];
-	for (let index = 0; index < manifest.routes.length; index += 1) {
-		const entry = manifest.routes[index];
-		if (currentRouteIds.has(entry.routeId)) continue;
-		results.push({
-			path: entry.path,
-			filePath: entry.filePath,
-			html: "",
-			fileSize: 0,
-			renderDuration: 0,
-			resourceCount: 0,
-			status: "removed",
-			reason: "deleted",
-			written: false
-		});
-	}
-	return results;
-}
-//#endregion
-export { collectRemovedRouteResults, dedupeStrings, getRoutesToRender, selectRouteForGeneration };

package/dist/ssg/incremental-manifest.js

@@ -1,54 +0,0 @@
-import * as fsPromises from "node:fs/promises";
-import * as pathModule from "node:path";
-import * as fs from "node:fs";
-const MANIFEST_DIR = ".askr";
-const MANIFEST_FILE = "ssg-manifest.json";
-function hashHtml(html) {
-	let hash = 2166136261;
-	for (let index = 0; index < html.length; index += 1) {
-		hash ^= html.charCodeAt(index);
-		hash = Math.imul(hash, 16777619);
-	}
-	return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function getIncrementalManifestPath(outputDir) {
-	return pathModule.join(outputDir, MANIFEST_DIR, MANIFEST_FILE);
-}
-function readIncrementalManifest(outputDir, seed) {
-	const manifestPath = getIncrementalManifestPath(outputDir);
-	if (!fs.existsSync(manifestPath)) return null;
-	try {
-		const raw = fs.readFileSync(manifestPath, "utf8");
-		const parsed = JSON.parse(raw);
-		if (parsed.schemaVersion !== 1 || parsed.seed !== seed || !Array.isArray(parsed.routes)) return null;
-		const routes = parsed.routes.filter((entry) => !!entry && typeof entry.routeId === "string" && typeof entry.path === "string" && typeof entry.filePath === "string" && Array.isArray(entry.invalidationKeys) && (entry.htmlHash === null || typeof entry.htmlHash === "string") && (entry.lastStatus === "success" || entry.lastStatus === "error"));
-		if (routes.length !== parsed.routes.length) return null;
-		return {
-			schemaVersion: 1,
-			seed,
-			mode: parsed.mode === "incremental" ? "incremental" : "full",
-			routes
-		};
-	} catch {
-		return null;
-	}
-}
-async function writeIncrementalManifest(manifest, outputDir) {
-	const manifestPath = getIncrementalManifestPath(outputDir);
-	await fsPromises.mkdir(pathModule.dirname(manifestPath), { recursive: true });
-	await fsPromises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
-}
-function getExistingOutputFileSize(outputDir, filePath) {
-	const fullPath = pathModule.join(outputDir, filePath);
-	if (!fs.existsSync(fullPath)) return 0;
-	try {
-		return fs.statSync(fullPath).size;
-	} catch {
-		return 0;
-	}
-}
-function outputFileExists(outputDir, filePath) {
-	return fs.existsSync(pathModule.join(outputDir, filePath));
-}
-//#endregion
-export { getExistingOutputFileSize, getIncrementalManifestPath, hashHtml, outputFileExists, readIncrementalManifest, writeIncrementalManifest };

package/dist/ssg/resolve-ssg-data.js

@@ -1,103 +0,0 @@
-import { interpolateRoutePath } from "./route-utils.js";
-//#region src/ssg/resolve-ssg-data.ts
-function hasOwnRouteData(dataMap, path) {
-	return Object.prototype.hasOwnProperty.call(dataMap, path);
-}
-/**
-* Resolve and validate data for SSG routes
-* Returns a map of route path -> SSRData
-*
-* In phase 1: accepts user-supplied dataOverrides
-* In phase 2: can be extended to auto-discover resources
-*/
-function resolveSsgData(routes, options = {}) {
-	const { dataOverrides = {} } = options;
-	const dataMap = {};
-	for (const route of routes) {
-		const concretePath = interpolateRoutePath(route.path, route.params);
-		const overridePath = concretePath in dataOverrides ? concretePath : route.path in dataOverrides ? route.path : null;
-		if (overridePath) {
-			const data = dataOverrides[overridePath];
-			if (typeof data !== "object" || data === null || Array.isArray(data)) throw new Error(`data for route "${overridePath}" must be an object, got ${typeof data}`);
-			dataMap[overridePath] = data;
-		}
-	}
-	return dataMap;
-}
-function resolveSsgRouteData(dataMap, routePath, concretePath) {
-	if (hasOwnRouteData(dataMap, concretePath)) return {
-		hasData: true,
-		data: dataMap[concretePath]
-	};
-	if (hasOwnRouteData(dataMap, routePath)) return {
-		hasData: true,
-		data: dataMap[routePath]
-	};
-	return {
-		hasData: false,
-		data: void 0
-	};
-}
-function isStringRecord(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	for (const recordValue of Object.values(value)) if (typeof recordValue !== "string") return false;
-	return true;
-}
-function validateRouteShape(route) {
-	if (typeof route.path !== "string" || !route.path.startsWith("/")) throw new Error(`route path must be a string starting with "/", got "${route.path}"`);
-	if (typeof (route.handler ?? route.component) !== "function") throw new Error(`route handler must be a function for path "${route.path}"`);
-	if (route.params !== void 0 && !isStringRecord(route.params)) throw new Error(`route "${route.path}" params must be an object containing only string values`);
-	if (route.invalidationKeys !== void 0) {
-		if (!Array.isArray(route.invalidationKeys)) throw new Error(`route "${route.path}" invalidationKeys must be an array of strings`);
-		for (const key of route.invalidationKeys) if (typeof key !== "string" || key.length === 0) throw new Error(`route "${route.path}" invalidationKeys must contain only non-empty strings`);
-	}
-}
-function validateEntriesResult(route, entries) {
-	if (!Array.isArray(entries)) throw new Error(`route "${route.path}" entries must return an array of param maps`);
-	return entries.map((entry, index) => {
-		if (!isStringRecord(entry)) throw new Error(`route "${route.path}" entries[${index}] must be an object containing only string values`);
-		return entry;
-	});
-}
-async function expandRoutes(routes) {
-	if (!Array.isArray(routes)) throw new Error("routes must be an array");
-	const expanded = [];
-	for (const route of routes) {
-		validateRouteShape(route);
-		if (route.params) expanded.push({
-			...route,
-			entries: void 0
-		});
-		if (!route.entries) {
-			if (!route.params) expanded.push(route);
-			continue;
-		}
-		const entries = validateEntriesResult(route, await route.entries());
-		for (const params of entries) expanded.push({
-			...route,
-			params,
-			entries: void 0
-		});
-	}
-	return expanded;
-}
-/**
-* Validate routes are properly configured
-*/
-function validateRoutes(routes) {
-	if (!Array.isArray(routes)) throw new Error("routes must be an array");
-	const seen = /* @__PURE__ */ new Set();
-	for (const route of routes) {
-		validateRouteShape(route);
-		const key = `${route.path}::${JSON.stringify(route.params || {})}`;
-		if (seen.has(key)) throw new Error(`duplicate route entry detected for path "${route.path}"`);
-		seen.add(key);
-		if (route.path.includes("{")) {
-			const paramNames = Array.from(route.path.matchAll(/\{([^}]+)\}/g)).map((m) => m[1]);
-			if (!route.params) throw new Error(`route "${route.path}" uses path parameters and requires params`);
-			for (const name of paramNames) if (!(name in route.params)) throw new Error(`route "${route.path}" missing required param "${name}"`);
-		}
-	}
-}
-//#endregion
-export { expandRoutes, resolveSsgData, resolveSsgRouteData, validateRoutes };

package/dist/ssg/route-utils.js

@@ -1,22 +0,0 @@
-//#region src/ssg/route-utils.ts
-function getOutputFilePath(pathStr) {
-	if (pathStr === "/") return "index.html";
-	return `${pathStr.replace(/^\/|\/$/g, "")}/index.html`;
-}
-function interpolateRoutePath(routePath, params) {
-	if (!params) return routePath;
-	return routePath.replace(/\{([^}]+)\}/g, (_, key) => params[key] ?? "");
-}
-function resolveRouteDescriptor(route) {
-	const path = interpolateRoutePath(route.path, route.params);
-	const filePath = getOutputFilePath(path);
-	return {
-		route,
-		path,
-		filePath,
-		routeId: `${path}::${filePath}`,
-		invalidationKeys: route.invalidationKeys?.slice() ?? []
-	};
-}
-//#endregion
-export { getOutputFilePath, interpolateRoutePath, resolveRouteDescriptor };

package/dist/ssg/static-routes.js

@@ -1,100 +0,0 @@
-import { _getBuiltInRoutePolicy } from "../router/policy.js";
-import "../router/route.js";
-import { getOutputFilePath, interpolateRoutePath, resolveRouteDescriptor } from "./route-utils.js";
-import { expandRoutes } from "./resolve-ssg-data.js";
-//#region src/ssg/static-routes.ts
-function getRuntimeOnlyDiagnostic(route, path) {
-	const policies = route.policies ?? [];
-	if (route.auth === true) return `Skipped prerender for "${path}": authenticated routes are runtime-only by default.`;
-	if (route.role) return `Skipped prerender for "${path}": role-gated routes are runtime-only by default.`;
-	if (route.permission) return `Skipped prerender for "${path}": permission-gated routes are runtime-only by default.`;
-	if (policies.length > 0) {
-		let hasAuthPolicy = false;
-		let hasRolePolicy = false;
-		let hasPermissionPolicy = false;
-		for (const policy of policies) {
-			const metadata = _getBuiltInRoutePolicy(policy);
-			if (!metadata) return `Skipped prerender for "${path}": routes with custom policies are runtime-only by default.`;
-			if (metadata.kind === "auth") hasAuthPolicy = true;
-			else if (metadata.kind === "role") hasRolePolicy = true;
-			else if (metadata.kind === "permission") hasPermissionPolicy = true;
-		}
-		if (hasAuthPolicy) return `Skipped prerender for "${path}": authenticated routes are runtime-only by default.`;
-		if (hasRolePolicy) return `Skipped prerender for "${path}": role-gated routes are runtime-only by default.`;
-		if (hasPermissionPolicy) return `Skipped prerender for "${path}": permission-gated routes are runtime-only by default.`;
-		return null;
-	}
-	return null;
-}
-function getRouteResultPath(route) {
-	return route.params ? interpolateRoutePath(route.path, route.params) : route.path;
-}
-function createRuntimeOnlyRoute(route, diagnostic) {
-	const path = getRouteResultPath(route);
-	const filePath = getOutputFilePath(path);
-	return {
-		routeId: `${path}::${filePath}`,
-		result: {
-			path,
-			filePath,
-			html: "",
-			fileSize: 0,
-			renderDuration: 0,
-			resourceCount: 0,
-			status: "skipped",
-			reason: "runtime-only",
-			written: false,
-			error: diagnostic
-		}
-	};
-}
-async function splitStaticRoutes(routes) {
-	const prerenderableRoutes = [];
-	const runtimeOnly = [];
-	const outputRouteIds = [];
-	for (const route of routes) {
-		const diagnostic = getRuntimeOnlyDiagnostic(route, getRouteResultPath(route));
-		if (diagnostic) {
-			const runtimeRoute = createRuntimeOnlyRoute(route, diagnostic);
-			runtimeOnly.push(runtimeRoute);
-			outputRouteIds.push(runtimeRoute.routeId);
-			continue;
-		}
-		const expanded = await expandRoutes([route]);
-		prerenderableRoutes.push(...expanded);
-		for (const expandedRoute of expanded) outputRouteIds.push(resolveRouteDescriptor(expandedRoute).routeId);
-	}
-	return {
-		routes: prerenderableRoutes,
-		runtimeOnly,
-		outputRouteIds
-	};
-}
-function normalizeStaticRoutes(options) {
-	if (options.registry) return routeRegistryToRouteConfigs(options.registry);
-	return [...options.routes ?? []];
-}
-function routeRegistryToRouteConfigs(registry) {
-	const routeConfigs = [];
-	for (const record of registry.manifest.records) {
-		if (record.isFallback) continue;
-		routeConfigs.push({
-			path: record.path,
-			handler: record.handler,
-			namespace: record.options.namespace,
-			auth: record.options.auth,
-			role: record.options.role,
-			permission: record.options.permission,
-			policies: stripRegistryGuestPolicies(record.options.policies),
-			entries: record.options.entries
-		});
-	}
-	return routeConfigs;
-}
-function stripRegistryGuestPolicies(policies) {
-	if (!policies || policies.length === 0) return;
-	const filtered = policies.filter((policy) => _getBuiltInRoutePolicy(policy)?.kind !== "guest");
-	return filtered.length > 0 ? filtered : void 0;
-}
-//#endregion
-export { normalizeStaticRoutes, splitStaticRoutes };