@pracht/cli 1.1.5 → 1.2.0

package/dist/generate-BXkePCIx.mjs

@@ -0,0 +1,404 @@
+import { a as toManifestModulePath, i as insertArrayItem, n as extractRegistryEntries, o as upsertObjectEntry, t as ensureCoreNamedImport } from "./manifest-DGq1n5LT.mjs";
+import { _ as requireEnum, a as readProjectConfig, c as resolveProjectPath, d as writeGeneratedFile, f as ensureTrailingNewline, g as quote, h as parseCommaList, l as resolveRouteModulePath, m as parseApiMethods, n as displayPath, o as resolveApiModulePath, s as resolvePagesRouteModulePath, t as assertFileExists, u as resolveScopedFile, v as requirePositiveInteger } from "./project-DydjqBoS.mjs";
+import { defineCommand } from "citty";
+import { readFileSync, writeFileSync } from "node:fs";
+var generate_default = defineCommand({
+	meta: {
+		name: "generate",
+		description: "Scaffold framework files"
+	},
+	subCommands: {
+		route: defineCommand({
+			meta: {
+				name: "route",
+				description: "Scaffold a route module"
+			},
+			args: {
+				path: {
+					type: "string",
+					required: true,
+					description: "Route path (e.g. /dashboard)"
+				},
+				render: {
+					type: "string",
+					description: "Render mode: ssr, spa, ssg, or isg"
+				},
+				shell: {
+					type: "string",
+					description: "Shell name"
+				},
+				middleware: {
+					type: "string",
+					description: "Middleware names (comma-separated)"
+				},
+				loader: {
+					type: "boolean",
+					description: "Include loader"
+				},
+				"error-boundary": {
+					type: "boolean",
+					description: "Include error boundary"
+				},
+				"static-paths": {
+					type: "boolean",
+					description: "Include static paths"
+				},
+				title: {
+					type: "string",
+					description: "Page title"
+				},
+				revalidate: {
+					type: "string",
+					description: "ISG revalidation seconds"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON"
+				}
+			},
+			async run({ args }) {
+				outputResult(generateRoute(args, readProjectConfig(process.cwd())), Boolean(args.json));
+			}
+		}),
+		shell: defineCommand({
+			meta: {
+				name: "shell",
+				description: "Scaffold a shell component"
+			},
+			args: {
+				name: {
+					type: "string",
+					required: true,
+					description: "Shell name"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON"
+				}
+			},
+			async run({ args }) {
+				const project = readProjectConfig(process.cwd());
+				outputResult(generateShell(args.name, project), Boolean(args.json));
+			}
+		}),
+		middleware: defineCommand({
+			meta: {
+				name: "middleware",
+				description: "Scaffold a middleware function"
+			},
+			args: {
+				name: {
+					type: "string",
+					required: true,
+					description: "Middleware name"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON"
+				}
+			},
+			async run({ args }) {
+				const project = readProjectConfig(process.cwd());
+				outputResult(generateMiddleware(args.name, project), Boolean(args.json));
+			}
+		}),
+		api: defineCommand({
+			meta: {
+				name: "api",
+				description: "Scaffold an API route"
+			},
+			args: {
+				path: {
+					type: "string",
+					required: true,
+					description: "API endpoint path"
+				},
+				methods: {
+					type: "string",
+					description: "HTTP methods (comma-separated, e.g. GET,POST)"
+				},
+				json: {
+					type: "boolean",
+					description: "Output as JSON"
+				}
+			},
+			async run({ args }) {
+				outputResult(generateApi(args, readProjectConfig(process.cwd())), Boolean(args.json));
+			}
+		})
+	}
+});
+function outputResult(result, json) {
+	if (json) {
+		console.log(JSON.stringify({
+			ok: true,
+			...result
+		}, null, 2));
+		return;
+	}
+	console.log(`Created ${result.kind}:`);
+	for (const file of result.created) console.log(`  ${file}`);
+	for (const file of result.updated) console.log(`  updated ${file}`);
+}
+function generateRoute(args, project) {
+	const routePath = normalizeRoutePathString(args.path);
+	const render = requireEnum(args.render, "render", [
+		"spa",
+		"ssr",
+		"ssg",
+		"isg"
+	], "ssr");
+	const includeLoader = Boolean(args.loader);
+	const includeErrorBoundary = Boolean(args["error-boundary"]);
+	const middleware = parseCommaList(args.middleware);
+	const includeStaticPaths = Boolean(args["static-paths"]) || hasDynamicSegments(routePath) && (render === "ssg" || render === "isg");
+	const title = args.title ?? titleFromPath(routePath);
+	if (project.mode === "pages") {
+		if (args.shell) throw new Error("`pracht generate route --shell` is only available for manifest apps.");
+		if (middleware.length > 0) throw new Error("`pracht generate route --middleware` is only available for manifest apps.");
+		return generatePagesRoute({
+			includeErrorBoundary,
+			includeLoader,
+			includeStaticPaths,
+			project,
+			render,
+			routePath,
+			title
+		});
+	}
+	const manifestPath = resolveProjectPath(project.root, project.appFile);
+	assertFileExists(manifestPath, `App manifest not found at ${project.appFile}.`);
+	const manifestSource = readFileSync(manifestPath, "utf-8");
+	const registeredShells = new Set(extractRegistryEntries(manifestSource, "shells").map((entry) => entry.name));
+	const registeredMiddleware = new Set(extractRegistryEntries(manifestSource, "middleware").map((entry) => entry.name));
+	const shellName = args.shell;
+	if (shellName && !registeredShells.has(shellName)) throw new Error(`Shell "${shellName}" is not registered in ${project.appFile}.`);
+	for (const name of middleware) if (!registeredMiddleware.has(name)) throw new Error(`Middleware "${name}" is not registered in ${project.appFile}.`);
+	const routeFile = resolveRouteModulePath(project, routePath, ".tsx");
+	writeGeneratedFile(routeFile.absolutePath, buildManifestRouteModuleSource({
+		includeErrorBoundary,
+		includeLoader,
+		includeStaticPaths,
+		routePath,
+		title
+	}));
+	let nextManifestSource = ensureCoreNamedImport(manifestSource, "route");
+	if (render === "isg") nextManifestSource = ensureCoreNamedImport(nextManifestSource, "timeRevalidate");
+	const routeModulePath = toManifestModulePath(manifestPath, routeFile.absolutePath);
+	const meta = [`id: ${quote(routeIdFromPath(routePath))}`, `render: ${quote(render)}`];
+	if (shellName) meta.push(`shell: ${quote(shellName)}`);
+	if (middleware.length > 0) meta.push(`middleware: [${middleware.map((item) => quote(item)).join(", ")}]`);
+	if (render === "isg") {
+		const seconds = requirePositiveInteger(args.revalidate, "revalidate", 3600);
+		meta.push(`revalidate: timeRevalidate(${seconds})`);
+	}
+	nextManifestSource = insertArrayItem(nextManifestSource, "routes", [
+		`route(${quote(routePath)}, ${quote(routeModulePath)}, {`,
+		...meta.map((line) => `  ${line},`),
+		"})"
+	].join("\n"));
+	writeFileSync(manifestPath, ensureTrailingNewline(nextManifestSource), "utf-8");
+	return {
+		created: [displayPath(project.root, routeFile.absolutePath)],
+		kind: "route",
+		updated: [displayPath(project.root, manifestPath)]
+	};
+}
+function generatePagesRoute({ includeErrorBoundary, includeLoader, includeStaticPaths, project, render, routePath, title }) {
+	const routeFile = resolvePagesRouteModulePath(project, routePath, ".tsx");
+	writeGeneratedFile(routeFile.absolutePath, buildPagesRouteModuleSource({
+		includeErrorBoundary,
+		includeLoader,
+		includeStaticPaths,
+		render,
+		routePath,
+		title
+	}));
+	return {
+		created: [displayPath(project.root, routeFile.absolutePath)],
+		kind: "route",
+		updated: []
+	};
+}
+function generateShell(name, project) {
+	if (project.mode === "pages") throw new Error("Pages router apps use a single `_app` shell. `pracht generate shell` is only available for manifest apps.");
+	const manifestPath = resolveProjectPath(project.root, project.appFile);
+	assertFileExists(manifestPath, `App manifest not found at ${project.appFile}.`);
+	const shellFile = resolveScopedFile(project.root, project.shellsDir, `${name}.tsx`);
+	writeGeneratedFile(shellFile, buildShellModuleSource(name));
+	writeFileSync(manifestPath, ensureTrailingNewline(upsertObjectEntry(readFileSync(manifestPath, "utf-8"), "shells", `${name}: ${quote(toManifestModulePath(manifestPath, shellFile))}`)), "utf-8");
+	return {
+		created: [displayPath(project.root, shellFile)],
+		kind: "shell",
+		updated: [displayPath(project.root, manifestPath)]
+	};
+}
+function generateMiddleware(name, project) {
+	if (project.mode === "pages") throw new Error("Pages router apps do not use manifest middleware registration. `pracht generate middleware` is only available for manifest apps.");
+	const manifestPath = resolveProjectPath(project.root, project.appFile);
+	assertFileExists(manifestPath, `App manifest not found at ${project.appFile}.`);
+	const middlewareFile = resolveScopedFile(project.root, project.middlewareDir, `${name}.ts`);
+	writeGeneratedFile(middlewareFile, buildMiddlewareModuleSource());
+	writeFileSync(manifestPath, ensureTrailingNewline(upsertObjectEntry(readFileSync(manifestPath, "utf-8"), "middleware", `${name}: ${quote(toManifestModulePath(manifestPath, middlewareFile))}`)), "utf-8");
+	return {
+		created: [displayPath(project.root, middlewareFile)],
+		kind: "middleware",
+		updated: [displayPath(project.root, manifestPath)]
+	};
+}
+function generateApi(args, project) {
+	const endpointPath = normalizeApiPath(args.path);
+	const methods = parseApiMethods(args.methods);
+	const apiFile = resolveApiModulePath(project, endpointPath);
+	writeGeneratedFile(apiFile.absolutePath, buildApiRouteSource({
+		endpointPath,
+		methods
+	}));
+	return {
+		created: [displayPath(project.root, apiFile.absolutePath)],
+		kind: "api",
+		updated: []
+	};
+}
+function buildManifestRouteModuleSource({ includeErrorBoundary, includeLoader, includeStaticPaths, routePath, title }) {
+	const params = dynamicParamNames(routePath);
+	const imports = [];
+	const sections = [];
+	if (includeLoader) imports.push("LoaderArgs", "RouteComponentProps");
+	if (includeErrorBoundary) imports.push("ErrorBoundaryProps");
+	if (imports.length > 0) {
+		sections.push(`import type { ${imports.join(", ")} } from "@pracht/core";`);
+		sections.push("");
+	}
+	if (includeLoader) sections.push("export async function loader(_args: LoaderArgs) {", `  return { message: ${quote(`Welcome to ${title}.`)} };`, "}", "");
+	if (includeStaticPaths) sections.push("export function getStaticPaths() {", `  return [${buildStaticPathsStub(params)}];`, "}", "");
+	sections.push("export function head() {", `  return { title: ${quote(title)} };`, "}", "");
+	if (includeLoader) sections.push("export function Component({ data }: RouteComponentProps<typeof loader>) {", "  return (", "    <section>", `      <h1>${escapeJsxText(title)}</h1>`, "      <p>{data.message}</p>", "    </section>", "  );", "}");
+	else sections.push("export function Component() {", "  return (", "    <section>", `      <h1>${escapeJsxText(title)}</h1>`, "    </section>", "  );", "}");
+	if (includeErrorBoundary) sections.push("", "export function ErrorBoundary({ error }: ErrorBoundaryProps) {", "  return <p>{error.message}</p>;", "}");
+	return `${sections.join("\n")}\n`;
+}
+function buildPagesRouteModuleSource({ includeErrorBoundary, includeLoader, includeStaticPaths, render, routePath, title }) {
+	const params = dynamicParamNames(routePath);
+	const imports = [];
+	const sections = [];
+	if (includeLoader) imports.push("LoaderArgs", "RouteComponentProps");
+	if (includeErrorBoundary) imports.push("ErrorBoundaryProps");
+	if (imports.length > 0) {
+		sections.push(`import type { ${imports.join(", ")} } from "@pracht/core";`);
+		sections.push("");
+	}
+	sections.push(`export const RENDER_MODE = ${quote(render)};`, "");
+	if (includeLoader) sections.push("export async function loader(_args: LoaderArgs) {", `  return { message: ${quote(`Welcome to ${title}.`)} };`, "}", "");
+	if (includeStaticPaths) sections.push("export function getStaticPaths() {", `  return [${buildStaticPathsStub(params)}];`, "}", "");
+	if (includeLoader) sections.push("export function Component({ data }: RouteComponentProps<typeof loader>) {", "  return (", "    <section>", `      <h1>${escapeJsxText(title)}</h1>`, "      <p>{data.message}</p>", "    </section>", "  );", "}");
+	else sections.push("export function Component() {", "  return (", "    <section>", `      <h1>${escapeJsxText(title)}</h1>`, "    </section>", "  );", "}");
+	if (includeErrorBoundary) sections.push("", "export function ErrorBoundary({ error }: ErrorBoundaryProps) {", "  return <p>{error.message}</p>;", "}");
+	return `${sections.join("\n")}\n`;
+}
+function buildShellModuleSource(name) {
+	const title = titleCase(name);
+	return [
+		"import type { ShellProps } from \"@pracht/core\";",
+		"",
+		"export function Shell({ children }: ShellProps) {",
+		"  return (",
+		`    <div class=${quote(`${name}-shell`)}>`,
+		"      <main>{children}</main>",
+		"    </div>",
+		"  );",
+		"}",
+		"",
+		"export function head() {",
+		`  return { title: ${quote(title)} };`,
+		"}",
+		""
+	].join("\n");
+}
+function buildMiddlewareModuleSource() {
+	return [
+		"import type { MiddlewareFn } from \"@pracht/core\";",
+		"",
+		"export const middleware: MiddlewareFn = async (_args) => {",
+		"  return;",
+		"};",
+		""
+	].join("\n");
+}
+function buildApiRouteSource({ endpointPath, methods }) {
+	return [
+		"import type { BaseRouteArgs } from \"@pracht/core\";",
+		"",
+		...methods.flatMap((method, index) => {
+			const lines = buildApiMethodSource(method, methods, endpointPath);
+			if (index === methods.length - 1) return lines;
+			return [...lines, ""];
+		}),
+		""
+	].join("\n");
+}
+function buildApiMethodSource(method, methods, endpointPath) {
+	if (method === "DELETE" || method === "HEAD") return [
+		`export function ${method}(_args: BaseRouteArgs) {`,
+		"  return new Response(null, { status: 204 });",
+		"}"
+	];
+	if (method === "OPTIONS") return [
+		`export function ${method}(_args: BaseRouteArgs) {`,
+		"  return new Response(null, {",
+		`    headers: { allow: ${quote(methods.join(", "))} },`,
+		"    status: 204,",
+		"  });",
+		"}"
+	];
+	if (method === "GET") return [
+		`export function ${method}(_args: BaseRouteArgs) {`,
+		`  return Response.json({ endpoint: ${quote(`/api${endpointPath}`)}, ok: true });`,
+		"}"
+	];
+	const status = method === "POST" ? 201 : 200;
+	return [
+		`export async function ${method}({ request }: BaseRouteArgs) {`,
+		"  const body = await request.json();",
+		`  return Response.json({ body, ok: true }, { status: ${status} });`,
+		"}"
+	];
+}
+function normalizeRoutePathString(value) {
+	if (!value || value === "/") return "/";
+	const normalized = `/${value}`.replace(/\/+/g, "/");
+	return normalized !== "/" && normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function normalizeApiPath(value) {
+	return normalizeRoutePathString(value).replace(/^\/api(?=\/|$)/, "") || "/";
+}
+function hasDynamicSegments(routePath) {
+	return routePath.split("/").some((segment) => segment.startsWith(":") || segment === "*");
+}
+function dynamicParamNames(routePath) {
+	return routePath.split("/").filter(Boolean).map((segment) => {
+		if (segment.startsWith(":")) return segment.slice(1);
+		if (segment === "*") return "slug";
+		return null;
+	}).filter((s) => s !== null);
+}
+function routeIdFromPath(routePath) {
+	if (routePath === "/") return "index";
+	return routePath.split("/").filter(Boolean).map((segment) => segment.replace(/^:/, "").replace(/\*/g, "splat")).join("-");
+}
+function titleFromPath(routePath) {
+	if (routePath === "/") return "Home";
+	return titleCase((routePath.split("/").filter(Boolean).at(-1) ?? "Page").replace(/^:/, "").replace(/\*/g, "slug"));
+}
+function titleCase(value) {
+	return value.split(/[-_/]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join(" ");
+}
+function buildStaticPathsStub(params) {
+	if (params.length === 0) return "{}";
+	return `{ ${params.map((name) => `${name}: ${quote(`example-${name}`)}`).join(", ")} }`;
+}
+function escapeJsxText(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+//#endregion
+export { generate_default as default };

package/dist/index.mjs

@@ -0,0 +1,41 @@
+import { defineCommand, runMain } from "citty";
+//#region src/constants.ts
+const VERSION = "0.0.0";
+const PROJECT_DEFAULTS = {
+	apiDir: "/src/api",
+	appFile: "/src/routes.ts",
+	middlewareDir: "/src/middleware",
+	pagesDefaultRender: "ssr",
+	pagesDir: "",
+	routesDir: "/src/routes",
+	serverDir: "/src/server",
+	shellsDir: "/src/shells"
+};
+const HTTP_METHODS = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE",
+	"HEAD",
+	"OPTIONS"
+]);
+//#endregion
+//#region src/index.ts
+runMain(defineCommand({
+	meta: {
+		name: "pracht",
+		version: VERSION,
+		description: "The pracht CLI"
+	},
+	subCommands: {
+		build: () => import("./build-BzQAQjuy.mjs").then((m) => m.default),
+		dev: () => import("./dev-BCFe3g38.mjs").then((m) => m.default),
+		doctor: () => import("./doctor-BcoqyBk-.mjs").then((m) => m.default),
+		generate: () => import("./generate-BXkePCIx.mjs").then((m) => m.default),
+		inspect: () => import("./inspect-DIjjCfs3.mjs").then((m) => m.default),
+		verify: () => import("./verify-CObGxWtW.mjs").then((m) => m.default)
+	}
+}));
+//#endregion
+export { PROJECT_DEFAULTS as n, VERSION as r, HTTP_METHODS as t };

package/dist/inspect-DIjjCfs3.mjs

@@ -0,0 +1,128 @@
+import { t as HTTP_METHODS } from "./index.mjs";
+import { t as readClientBuildAssets } from "./build-metadata-IABPFFKk.mjs";
+import { a as readProjectConfig, c as resolveProjectPath, p as handleCliError } from "./project-DydjqBoS.mjs";
+import { defineCommand } from "citty";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createServer } from "vite";
+//#region src/commands/inspect.ts
+const INSPECT_TARGETS = new Set([
+	"routes",
+	"api",
+	"build",
+	"all"
+]);
+const METHOD_ORDER = [...HTTP_METHODS];
+var inspect_default = defineCommand({
+	meta: {
+		name: "inspect",
+		description: "Inspect resolved app graph"
+	},
+	args: {
+		target: {
+			type: "positional",
+			description: "Inspect target: routes, api, build, or all",
+			required: false
+		},
+		json: {
+			type: "boolean",
+			description: "Output as JSON"
+		}
+	},
+	async run({ args }) {
+		const target = args.target || "all";
+		if (!INSPECT_TARGETS.has(target)) handleCliError(/* @__PURE__ */ new Error(`Unknown inspect target: ${target}`), { json: Boolean(args.json) });
+		const report = await runInspect(process.cwd(), { target });
+		if (args.json) {
+			console.log(JSON.stringify(report, null, 2));
+			return;
+		}
+		printInspectReport(report);
+	}
+});
+async function runInspect(root, { target = "all" } = {}) {
+	const project = readProjectConfig(root);
+	if (!project.configFile) throw new Error("Missing vite config. `pracht inspect` requires a project with pracht configured.");
+	if (!project.hasPrachtPlugin) throw new Error("vite.config does not appear to register the pracht plugin.");
+	if (project.mode === "manifest") {
+		const manifestPath = resolveProjectPath(project.root, project.appFile);
+		try {
+			readFileSync(manifestPath, "utf-8");
+		} catch {
+			throw new Error(`App manifest is missing at ${project.appFile}.`);
+		}
+	}
+	const server = await createServer({
+		root,
+		logLevel: "silent",
+		server: { middlewareMode: true }
+	});
+	try {
+		const serverModule = await server.ssrLoadModule("virtual:pracht/server");
+		const report = { mode: project.mode };
+		if (target === "routes" || target === "all") report.routes = serializeRoutes(serverModule.resolvedApp.routes);
+		if (target === "api" || target === "all") report.api = await Promise.all(serverModule.apiRoutes.map(async (route) => ({
+			file: route.file,
+			methods: await detectApiMethods(server, root, route.file),
+			path: route.path
+		})));
+		if (target === "build" || target === "all") {
+			const buildAssets = readClientBuildAssets(root);
+			report.build = {
+				adapterTarget: serverModule.buildTarget,
+				clientEntryUrl: buildAssets.clientEntryUrl,
+				cssManifest: buildAssets.cssManifest,
+				jsManifest: buildAssets.jsManifest
+			};
+		}
+		return report;
+	} finally {
+		await server.close();
+	}
+}
+function serializeRoutes(routes) {
+	return routes.map((route) => ({
+		file: route.file,
+		id: route.id,
+		loaderFile: route.loaderFile ?? null,
+		middleware: route.middleware,
+		path: route.path,
+		render: route.render ?? null,
+		revalidate: route.revalidate ?? null,
+		shell: route.shell ?? null,
+		shellFile: route.shellFile ?? null
+	}));
+}
+async function detectApiMethods(server, root, file) {
+	const source = readFileSync(resolve(root, `.${file}`), "utf-8");
+	try {
+		const module = await server.ssrLoadModule(file);
+		return METHOD_ORDER.filter((method) => typeof module[method] === "function");
+	} catch {
+		return METHOD_ORDER.filter((method) => new RegExp(`export\\s+(?:async\\s+)?(?:function|const|let|var)\\s+${method}\\b`).test(source));
+	}
+}
+function printInspectReport(report) {
+	console.log(`Pracht inspect (${report.mode} mode)`);
+	if (report.routes) {
+		console.log("\nRoutes");
+		for (const route of report.routes) console.log(`  ${route.path}  id=${route.id}  render=${route.render ?? "n/a"}  file=${route.file}`);
+	}
+	if (report.api) {
+		console.log("\nAPI");
+		if (report.api.length === 0) console.log("  No API routes found.");
+		else for (const route of report.api) {
+			const methods = route.methods.length > 0 ? route.methods.join(",") : "none";
+			console.log(`  ${route.path}  methods=${methods}  file=${route.file}`);
+		}
+	}
+	if (report.build) {
+		console.log("\nBuild");
+		console.log(`  adapterTarget=${report.build.adapterTarget}`);
+		console.log(`  clientEntryUrl=${report.build.clientEntryUrl ?? "null"}`);
+		console.log(`  cssManifestKeys=${Object.keys(report.build.cssManifest).length}`);
+		console.log(`  jsManifestKeys=${Object.keys(report.build.jsManifest).length}`);
+	}
+}
+//#endregion
+export { inspect_default as default };

package/dist/manifest-DGq1n5LT.mjs

@@ -0,0 +1,99 @@
+//#region src/manifest.ts
+function ensureCoreNamedImport(source, name) {
+	const match = source.match(/import\s*\{([^}]+)\}\s*from\s*["']@pracht\/core["'];?/);
+	if (!match) return `import { ${name} } from "@pracht/core";\n${source}`;
+	const names = match[1].split(",").map((item) => item.trim()).filter(Boolean);
+	if (!names.includes(name)) names.push(name);
+	return source.replace(match[0], `import { ${names.join(", ")} } from "@pracht/core";`);
+}
+function upsertObjectEntry(source, key, entry) {
+	const property = findNamedBlock(source, key, "{", "}");
+	if (!property) {
+		const routesMatch = source.match(/^(\s*)routes\s*:/m);
+		if (!routesMatch || routesMatch.index == null) throw new Error(`Could not find a "${key}" or "routes" block in the app manifest.`);
+		const indent = routesMatch[1];
+		const block = `${indent}${key}: {\n${indent}  ${entry},\n${indent}},\n`;
+		return `${source.slice(0, routesMatch.index)}${block}${source.slice(routesMatch.index)}`;
+	}
+	return insertBlockEntry(source, property, entry);
+}
+function insertArrayItem(source, key, item) {
+	const property = findNamedBlock(source, key, "[", "]");
+	if (!property) throw new Error(`Could not find "${key}" in the app manifest.`);
+	return insertBlockEntry(source, property, item);
+}
+function toManifestModulePath(manifestPath, targetFilePath) {
+	const relativePath = targetFilePath.replaceAll("\\", "/").replace(manifestPath.replaceAll("\\", "/").replace(/\/[^/]+$/, ""), "").replace(/^\//, "");
+	return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function extractRegistryEntries(source, key) {
+	const block = findNamedBlock(source, key, "{", "}");
+	if (!block) return [];
+	const inner = source.slice(block.openIndex + 1, block.closeIndex);
+	const entries = [];
+	for (const match of inner.matchAll(/([A-Za-z0-9_-]+)\s*:\s*(?:(["'`])([^"'`]+)\2|\(\)\s*=>\s*import\(\s*(["'`])([^"'`]+)\4\s*\))/g)) entries.push({
+		name: match[1],
+		path: match[3] ?? match[5]
+	});
+	return entries;
+}
+function extractRelativeModulePaths(source) {
+	const results = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(/["'`]((?:\.\.\/|\.\/)[^"'`]+)["'`]/g)) results.add(match[1]);
+	return results;
+}
+function insertBlockEntry(source, block, entry) {
+	const inner = source.slice(block.openIndex + 1, block.closeIndex);
+	const closingIndent = block.indent;
+	const childIndent = `${closingIndent}  `;
+	const trimmed = inner.trim();
+	if (!trimmed) return `${source.slice(0, block.openIndex + 1)}\n${indentMultiline(entry, childIndent)}\n${closingIndent}${source.slice(block.closeIndex)}`;
+	const insertPrefix = !/[,[{(]\s*$/.test(inner) && !/,\s*$/.test(trimmed) ? "," : "";
+	return `${source.slice(0, block.closeIndex)}${insertPrefix}\n${indentMultiline(entry, childIndent)}\n${closingIndent}${source.slice(block.closeIndex)}`;
+}
+function findNamedBlock(source, key, openChar, closeChar) {
+	const pattern = new RegExp(`^([ \\t]*)${key}\\s*:\\s*\\${openChar}`, "m");
+	const match = source.match(pattern);
+	if (!match || match.index == null) return null;
+	const openIndex = source.indexOf(openChar, match.index);
+	return {
+		closeIndex: findMatchingDelimiter(source, openIndex, openChar, closeChar),
+		indent: match[1],
+		openIndex
+	};
+}
+function findMatchingDelimiter(source, openIndex, openChar, closeChar) {
+	let depth = 0;
+	let quoteChar = null;
+	let escaping = false;
+	for (let index = openIndex; index < source.length; index += 1) {
+		const current = source[index];
+		if (quoteChar) {
+			if (escaping) {
+				escaping = false;
+				continue;
+			}
+			if (current === "\\") {
+				escaping = true;
+				continue;
+			}
+			if (current === quoteChar) quoteChar = null;
+			continue;
+		}
+		if (current === "\"" || current === "'" || current === "`") {
+			quoteChar = current;
+			continue;
+		}
+		if (current === openChar) depth += 1;
+		if (current === closeChar) {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+	}
+	throw new Error(`Could not find matching ${closeChar} for ${openChar}.`);
+}
+function indentMultiline(value, indent) {
+	return value.split("\n").map((line) => `${indent}${line}`).join("\n");
+}
+//#endregion
+export { toManifestModulePath as a, insertArrayItem as i, extractRegistryEntries as n, upsertObjectEntry as o, extractRelativeModulePaths as r, ensureCoreNamedImport as t };