tachyon-dom 0.1.0

package/dist/cli.js

@@ -0,0 +1,711 @@
+#!/usr/bin/env node
+import { access, mkdir, readFile, realpath, writeFile } from "node:fs/promises";
+import { basename, dirname, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { generateTachyonModuleTypes, generateTemplateTypes, pagesFromRouteFiles } from "./app.js";
+import { generateClientModule, generateServerModule, generateServerStreamModule } from "./compiler/index.js";
+import { generateScriptOnlyModule, transformSfcScript } from "./compiler/sfc.js";
+import { diagnoseTachyonSfc, diagnosticFromCompilerError, formatDiagnostic } from "./diagnostics.js";
+import { scanFileRoutes } from "./router-node.js";
+import { appendInlineSourceMap, createSourceMap } from "./source-map.js";
+import { err, ok } from "./result.js";
+const usage = "Usage: tachyon-dom <compile|routes|dev|build|preview|add|typegen|init|language-server>. Use compile for templates, routes for file-route manifests, dev/build/preview with Vite, add for route files, typegen for template scopes, init for starters, and language-server for editor diagnostics.";
+const commandUsage = {
+    add: "Usage: tachyon-dom add page <name> [--routes-dir src/routes] [--force]. Existing files are preserved unless --force is explicit.",
+    build: "Usage: tachyon-dom build [--host 127.0.0.1] [--port 4173]",
+    compile: "Usage: tachyon-dom compile <input> [--target client|server|stream] [--out file] [--reactive] [--no-sourcemap]",
+    dev: "Usage: tachyon-dom dev [--host 127.0.0.1] [--port 5173]",
+    init: "Usage: tachyon-dom init [--out dir] [--template basic|ssr] [--force]. Any conflict aborts all writes unless --force is explicit.",
+    "language-server": "Usage: tachyon-dom language-server --stdio",
+    preview: "Usage: tachyon-dom preview [--host 127.0.0.1] [--port 4173]",
+    routes: "Usage: tachyon-dom routes <routes-dir> [--out route-manifest.json]",
+    typegen: "Usage: tachyon-dom typegen <input> [--out file] [--type TemplateScope] [--module]",
+};
+export const isCreateEntrypoint = (entrypoint) => {
+    if (!entrypoint) {
+        return false;
+    }
+    const name = basename(entrypoint).replace(/\.(cmd|ps1)$/i, "");
+    return name === "create-tachyon-dom";
+};
+export const normalizeCliArgv = (argv, entrypoint = process.argv[1]) => {
+    if (!isCreateEntrypoint(entrypoint)) {
+        return argv;
+    }
+    if (argv[0] === "--help" || argv[0] === "-h" || argv[0] === "help") {
+        return ["init", "--help"];
+    }
+    const [outDir, ...rest] = argv;
+    if (!outDir || outDir.startsWith("-")) {
+        return ["init", ...argv];
+    }
+    return ["init", "--out", outDir, ...rest];
+};
+const packageVersion = async () => {
+    const packageUrl = new URL("../package.json", import.meta.url);
+    const packagePath = packageUrl.protocol === "file:" ? packageUrl : join(process.cwd(), "package.json");
+    const packageJson = JSON.parse(await readFile(packagePath, "utf8"));
+    return packageJson.version ?? "0.0.0";
+};
+const parseCompileArgs = (input, rest) => {
+    if (!input) {
+        return err("Usage: tachyon-dom compile <input> [--target client|server|stream] [--out file] [--reactive] [--no-sourcemap]");
+    }
+    const options = {
+        command: "compile",
+        input,
+        target: "client",
+        reactive: false,
+        sourcemap: true,
+    };
+    for (let index = 0; index < rest.length; index++) {
+        const arg = rest[index];
+        if (arg === "--target") {
+            const target = rest[++index];
+            if (target !== "client" && target !== "server" && target !== "stream") {
+                return err("--target must be client, server, or stream.");
+            }
+            options.target = target;
+        }
+        else if (arg === "--out") {
+            const output = rest[++index];
+            if (!output) {
+                return err("--out requires a file path.");
+            }
+            options.output = output;
+        }
+        else if (arg === "--reactive") {
+            options.reactive = true;
+        }
+        else if (arg === "--no-sourcemap") {
+            options.sourcemap = false;
+        }
+        else {
+            return err(`Unknown argument: ${arg}`);
+        }
+    }
+    return ok(options);
+};
+const parseRoutesArgs = (routesDir, rest) => {
+    if (!routesDir) {
+        return err("Usage: tachyon-dom routes <routes-dir> [--out route-manifest.json]");
+    }
+    const options = { command: "routes", routesDir };
+    for (let index = 0; index < rest.length; index++) {
+        const arg = rest[index];
+        if (arg === "--out") {
+            const output = rest[++index];
+            if (!output) {
+                return err("--out requires a file path.");
+            }
+            options.output = output;
+        }
+        else {
+            return err(`Unknown argument: ${arg}`);
+        }
+    }
+    return ok(options);
+};
+const parseServerArgs = (command, rest) => {
+    const options = { command, host: "127.0.0.1", port: command === "dev" ? 5173 : 4173 };
+    for (let index = 0; index < rest.length; index++) {
+        const arg = rest[index];
+        if (arg === "--host") {
+            const host = rest[++index];
+            if (!host) {
+                return err("--host requires a value.");
+            }
+            options.host = host;
+        }
+        else if (arg === "--port") {
+            const port = Number.parseInt(rest[++index] ?? "", 10);
+            if (!Number.isFinite(port)) {
+                return err("--port requires a number.");
+            }
+            options.port = port;
+        }
+        else {
+            return err(`Unknown argument: ${arg}`);
+        }
+    }
+    return ok(options);
+};
+const parseAddArgs = (kind, name, rest) => {
+    if (kind !== "page" || !name) {
+        return err("Usage: tachyon-dom add page <name> [--routes-dir src/routes]");
+    }
+    const options = { command: "add-page", name, routesDir: "src/routes" };
+    for (let index = 0; index < rest.length; index++) {
+        const arg = rest[index];
+        if (arg === "--routes-dir") {
+            const routesDir = rest[++index];
+            if (!routesDir) {
+                return err("--routes-dir requires a path.");
+            }
+            options.routesDir = routesDir;
+        }
+        else if (arg === "--force") {
+            options.force = true;
+        }
+        else {
+            return err(`Unknown argument: ${arg}`);
+        }
+    }
+    return ok(options);
+};
+const parseTypegenArgs = (input, rest) => {
+    if (!input) {
+        return err("Usage: tachyon-dom typegen <input> [--out file] [--type TemplateScope] [--module]");
+    }
+    const options = { command: "typegen", input, module: false };
+    for (let index = 0; index < rest.length; index++) {
+        const arg = rest[index];
+        if (arg === "--out") {
+            const output = rest[++index];
+            if (!output) {
+                return err("--out requires a file path.");
+            }
+            options.output = output;
+        }
+        else if (arg === "--type") {
+            const typeName = rest[++index];
+            if (!typeName) {
+                return err("--type requires a type name.");
+            }
+            options.typeName = typeName;
+        }
+        else if (arg === "--module") {
+            options.module = true;
+        }
+        else {
+            return err(`Unknown argument: ${arg}`);
+        }
+    }
+    return ok(options);
+};
+const parseInitArgs = (rest) => {
+    const options = { command: "init", outDir: ".", template: "basic" };
+    for (let index = 0; index < rest.length; index++) {
+        const arg = rest[index];
+        if (arg === "--out") {
+            const outDir = rest[++index];
+            if (!outDir) {
+                return err("--out requires a directory.");
+            }
+            options.outDir = outDir;
+        }
+        else if (arg === "--template") {
+            const template = rest[++index];
+            if (template !== "basic" && template !== "ssr") {
+                return err("--template must be basic or ssr.");
+            }
+            options.template = template;
+        }
+        else if (arg === "--force") {
+            options.force = true;
+        }
+        else {
+            return err(`Unknown argument: ${arg}`);
+        }
+    }
+    return ok(options);
+};
+const parseLanguageServerArgs = (rest) => rest.length === 1 && rest[0] === "--stdio"
+    ? ok({ command: "language-server", transport: "stdio" })
+    : err("Usage: tachyon-dom language-server --stdio");
+export const parseArgs = (argv) => {
+    const [command, input, ...rest] = argv;
+    if (input === "--help" || input === "-h" || input === "help") {
+        return err(commandUsage[command ?? ""] ?? usage);
+    }
+    if (command === "compile") {
+        return parseCompileArgs(input ?? "", rest);
+    }
+    if (command === "routes") {
+        return parseRoutesArgs(input ?? "", rest);
+    }
+    if (command === "dev" || command === "preview" || command === "build") {
+        return parseServerArgs(command, [input, ...rest].filter((arg) => Boolean(arg)));
+    }
+    if (command === "add") {
+        return parseAddArgs(input ?? "", rest[0] ?? "", rest.slice(1));
+    }
+    if (command === "typegen") {
+        return parseTypegenArgs(input ?? "", rest);
+    }
+    if (command === "init") {
+        return parseInitArgs([input, ...rest].filter((arg) => Boolean(arg)));
+    }
+    if (command === "language-server") {
+        return parseLanguageServerArgs([input, ...rest].filter((arg) => Boolean(arg)));
+    }
+    return err(usage);
+};
+export const compileFile = async (options) => {
+    const source = await readFile(options.input, "utf8");
+    const result = diagnoseTachyonSfc(source);
+    if (!result.ok) {
+        return err(formatDiagnostic(result.error, options.input));
+    }
+    const script = transformSfcScript(result.value.descriptor.script);
+    if (!script.ok) {
+        return err(formatDiagnostic(diagnosticFromCompilerError(source, script.error), options.input));
+    }
+    const code = result.value.scriptOnly
+        ? generateScriptOnlyModule(options.target)
+        : options.target === "server"
+            ? generateServerModule(result.value.template)
+            : options.target === "stream"
+                ? generateServerStreamModule(result.value.template)
+                : generateClientModule(result.value.template, {
+                    reactive: options.reactive,
+                    ...(script.value.defaultScopeName ? { defaultScopeName: script.value.defaultScopeName } : {}),
+                });
+    const moduleCode = `${script.value.code}${code}`;
+    const output = options.sourcemap
+        ? appendInlineSourceMap(moduleCode, createSourceMap(source, options.input, options.output))
+        : moduleCode;
+    if (options.output) {
+        await writeFile(options.output, output);
+    }
+    return ok(output);
+};
+export const buildRouteManifestFile = async (options) => {
+    const manifest = await scanFileRoutes(options.routesDir);
+    const output = `${JSON.stringify(manifest, null, 2)}\n`;
+    if (options.output) {
+        await writeFile(options.output, output);
+    }
+    return ok(output);
+};
+const titleCase = (value) => value
+    .split(/[-_/\s]+/)
+    .filter(Boolean)
+    .map((part) => part.replace(/^\[\.\.\.(.+)]$/, "$1").replace(/^\[(.+)]$/, "$1"))
+    .map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+    .join(" ");
+const generatedRoutesMarker = "// Generated by tachyon-dom. Do not edit by hand.";
+const routeRegistrySource = (files, routesDir, registryFile) => {
+    const pages = pagesFromRouteFiles(files, { rootDir: routesDir }).sort((left, right) => left.path.localeCompare(right.path));
+    const imports = pages.map((page, index) => {
+        const specifier = relative(dirname(registryFile), page.file).replaceAll("\\", "/");
+        return `import routeSource${index} from ${JSON.stringify(`${specifier.startsWith(".") ? specifier : `./${specifier}`}?raw`)};`;
+    });
+    const entries = pages.map((page, index) => `  { assetPrefix: ${JSON.stringify(page.assetPrefix)}, fileName: ${JSON.stringify(page.fileName)}, path: ${JSON.stringify(page.path)}, template: routeSource${index} },`);
+    return `${generatedRoutesMarker}\n${imports.join("\n")}\n\nexport const pages = [\n${entries.join("\n")}\n] as const;\n`;
+};
+const pageSource = (title) => `<script lang="ts">
+export const scope = () => ({
+  title: ${JSON.stringify(title)},
+});
+</script>
+<section>
+  <h1>{title}</h1>
+</section>
+`;
+export const addPageFiles = async (options) => {
+    const normalized = options.name.replace(/^\/+|\/+$/g, "");
+    const segments = normalized.split("/");
+    if (!normalized ||
+        normalized.includes("\\") ||
+        segments.some((segment) => !segment || segment === "." || segment === "..")) {
+        return err("Page name must be a route-local path without '..'.");
+    }
+    const targetDir = join(options.routesDir, normalized);
+    const title = titleCase(normalized);
+    const routeUrl = `/${normalized
+        .split("/")
+        .map((segment) => segment.startsWith("[...") && segment.endsWith("]")
+        ? `*${segment.slice(4, -1)}`
+        : segment.startsWith("[") && segment.endsWith("]")
+            ? `:${segment.slice(1, -1)}`
+            : segment)
+        .join("/")}/`;
+    const pageFile = join(targetDir, "page.td");
+    const declarationFile = `${pageFile}.d.ts`;
+    const registryFile = join(dirname(options.routesDir), "routes.generated.ts");
+    let overwriting = false;
+    let overwritingDeclarations = false;
+    let overwritingRegistry = false;
+    try {
+        await access(pageFile);
+        overwriting = true;
+    }
+    catch {
+        // The target does not exist yet.
+    }
+    try {
+        await access(declarationFile);
+        overwritingDeclarations = true;
+    }
+    catch {
+        // The declaration does not exist yet.
+    }
+    if (!options.force && (overwriting || overwritingDeclarations)) {
+        const conflicts = [
+            overwriting ? pageFile : undefined,
+            overwritingDeclarations ? declarationFile : undefined,
+        ].filter((file) => file !== undefined);
+        return err(`Refusing to overwrite existing page files:\n${conflicts.join("\n")}`);
+    }
+    try {
+        const registry = await readFile(registryFile, "utf8");
+        overwritingRegistry = true;
+        if (!registry.startsWith(generatedRoutesMarker) && !options.force) {
+            return err(`Refusing to replace non-generated route registry: ${registryFile}`);
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const source = pageSource(title);
+    const declarations = generateTachyonModuleTypes(source);
+    if (!declarations.ok)
+        return declarations;
+    let existingRoutes = [];
+    try {
+        existingRoutes = await scanFileRoutes(options.routesDir);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    const routeFiles = existingRoutes
+        .filter((route) => route.kind === "template" && route.file !== pageFile)
+        .map((route) => route.file);
+    routeFiles.push(pageFile);
+    await mkdir(targetDir, { recursive: true });
+    await writeFile(pageFile, source);
+    await writeFile(declarationFile, declarations.value);
+    await writeFile(registryFile, routeRegistrySource(routeFiles, options.routesDir, registryFile));
+    return ok([
+        overwriting ? `Overwrote ${pageFile}.` : `Created ${pageFile}.`,
+        `Route URL: ${routeUrl}`,
+        "Edit the generated page.td to define the route markup and scope.",
+        overwritingDeclarations ? `Overwrote ${declarationFile}.` : `Generated declarations: ${declarationFile}`,
+        overwritingRegistry ? `Updated route registry: ${registryFile}` : `Generated route registry: ${registryFile}`,
+    ].join("\n"));
+};
+export const generateTemplateTypesFile = async (options) => {
+    const source = await readFile(options.input, "utf8");
+    const result = options.module === true
+        ? generateTachyonModuleTypes(source, options.typeName ? { typeName: options.typeName } : {})
+        : generateTemplateTypes(source, options.typeName ? { typeName: options.typeName } : {});
+    if (!result.ok) {
+        return result;
+    }
+    if (options.output) {
+        await mkdir(dirname(options.output), { recursive: true });
+        await writeFile(options.output, result.value);
+    }
+    return result;
+};
+const starterPageSource = () => `<script lang="ts">
+export const scope = () => ({
+  message: "Edit src/routes/index/page.td to start building.",
+  title: "Welcome",
+});
+</script>
+<section>
+  <h1>{title}</h1>
+  <p>{message}</p>
+</section>
+`;
+const starterAppSource = () => `import { defineApp } from "tachyon-dom/app";
+import { pages } from "./routes.generated";
+
+export const app = defineApp({
+  lang: "en",
+  title: "Tachyon App",
+  templateWhitespace: "condense",
+  pages,
+});
+`;
+const starterClientSource = () => `// Client entry for Tachyon DOM runtime code.
+// Add progressive enhancements, client routing, or island hydration imports here.
+`;
+const starterServerSource = () => `import { renderAppResponse } from "tachyon-dom/app";
+import { app } from "./app";
+
+export const render = (path = "/") => renderAppResponse(app, path, { minify: true });
+`;
+const starterSmokeTestSource = () => `import { describe, expect, it } from "vitest";
+import { app } from "./app";
+
+describe("starter app", () => {
+  it("renders the starter page", () => {
+    expect(app.renderRoute("/")).toContain("<h1>Welcome</h1>");
+  });
+});
+`;
+const starterViteConfigSource = () => `import { defineConfig } from "vite";
+import { loadRouteApp, tachyonApp, tachyonDom } from "tachyon-dom/vite";
+
+const templateWhitespace = "condense" as const;
+const app = await loadRouteApp({
+  lang: "en",
+  routesDir: "src/routes",
+  title: "Tachyon App",
+  templateWhitespace,
+});
+
+export default defineConfig({
+  build: {
+    rollupOptions: {
+      input: "src/client/main.ts",
+    },
+  },
+  plugins: [tachyonDom({ reactive: true, templateWhitespace }), tachyonApp(app, { appScript: "/src/client/main.ts" })],
+});
+`;
+const starterTsConfigSource = () => `${JSON.stringify({
+    compilerOptions: {
+        exactOptionalPropertyTypes: true,
+        lib: ["ES2022", "DOM", "DOM.Iterable"],
+        module: "ESNext",
+        moduleResolution: "Bundler",
+        noUncheckedIndexedAccess: true,
+        skipLibCheck: false,
+        strict: true,
+        target: "ES2022",
+        types: ["vite/client", "node", "tachyon-dom/td-modules"],
+    },
+    include: ["src", "vite.config.ts"],
+}, null, 2)}\n`;
+const starterGitignoreSource = () => `node_modules/
+dist/
+.vite/
+coverage/
+`;
+const starterCiSource = () => `name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - run: pnpm typecheck
+      - run: pnpm test
+      - run: pnpm build
+`;
+const starterReadmeSource = (template) => `# Tachyon DOM Starter
+
+Edit \`src/routes/index/page.td\` to start building. Route-local \`.td\` files are the source of truth for page markup.
+
+Use \`src/client/main.ts\` for client-side runtime code that should be bundled by Vite. Do not put application code in \`public/client/main.js\`; reserve \`public/\` for static assets such as images, icons, manifests, and service workers.
+
+Run:
+
+\`\`\`sh
+pnpm install
+pnpm dev
+pnpm typecheck
+pnpm test
+pnpm build
+\`\`\`
+
+Add a page with:
+
+\`\`\`sh
+tachyon-dom add page settings/profile
+\`\`\`
+
+## Route registration
+
+\`src/routes.generated.ts\` is the generated route registry used by the app, Vite, tests, and SSR. \`tachyon-dom add page\` updates it automatically. Do not edit it by hand. Dynamic directories use \`[id]\` and catch-all directories use \`[...slug]\` across the app and server route manifest.
+
+The Vite plugin refreshes adjacent \`.td.d.ts\` declarations during development and builds. The starter and \`add page\` create the initial declaration, so \`pnpm typecheck\` works before the first Vite run. Do not run per-file type generation manually.
+
+Adapters are lower-level deployment APIs for Node, Workers, and Lambda composition. A standard Tachyon DOM app should keep \`.td\` templates and the Vite plugins on the main development path.
+
+Template: \`${template}\`.
+${template === "ssr" ? "\n## SSR entry\n\nThe `ssr` template includes `src/server.ts` with a small `render(path)` helper for server-side composition.\n" : ""}
+`;
+const starterPackageJsonSource = () => `${JSON.stringify({
+    scripts: {
+        build: "vite build",
+        dev: "vite",
+        preview: "vite preview",
+        test: "vitest run",
+        typecheck: "tsc --noEmit",
+    },
+    dependencies: {
+        "tachyon-dom": "^0.1.0",
+    },
+    devDependencies: {
+        "@types/node": "^24.0.3",
+        typescript: "^5.8.3",
+        vite: "^8.0.0",
+        vitest: "^4.1.9",
+    },
+    packageManager: "pnpm@10.32.1",
+    type: "module",
+}, null, 2)}\n`;
+export const createStarterFiles = async (options) => {
+    const managedFiles = [
+        "src/routes/index/page.td",
+        "src/routes/index/page.td.d.ts",
+        "src/routes.generated.ts",
+        "src/app.ts",
+        "src/client/main.ts",
+        "src/app.test.ts",
+        ...(options.template === "ssr" ? ["src/server.ts"] : []),
+        "vite.config.ts",
+        "tsconfig.json",
+        ".gitignore",
+        ".github/workflows/ci.yml",
+        "README.md",
+        "package.json",
+    ].map((file) => join(options.outDir, file));
+    const conflicts = [];
+    for (const file of managedFiles) {
+        try {
+            await access(file);
+            conflicts.push(file);
+        }
+        catch {
+            // Missing targets are safe to create after the full preflight.
+        }
+    }
+    if (conflicts.length > 0 && !options.force) {
+        return err(`Refusing to overwrite existing starter files:\n${conflicts.join("\n")}`);
+    }
+    await mkdir(join(options.outDir, "src", "routes", "index"), { recursive: true });
+    await mkdir(join(options.outDir, "src", "client"), { recursive: true });
+    await mkdir(join(options.outDir, ".github", "workflows"), { recursive: true });
+    const starterPageFile = join(options.outDir, "src", "routes", "index", "page.td");
+    const starterRegistryFile = join(options.outDir, "src", "routes.generated.ts");
+    const starterSource = starterPageSource();
+    const starterDeclarations = generateTachyonModuleTypes(starterSource);
+    if (!starterDeclarations.ok)
+        return starterDeclarations;
+    await writeFile(starterPageFile, starterSource);
+    await writeFile(`${starterPageFile}.d.ts`, starterDeclarations.value);
+    await writeFile(starterRegistryFile, routeRegistrySource([starterPageFile], join(options.outDir, "src", "routes"), starterRegistryFile));
+    await writeFile(join(options.outDir, "src", "app.ts"), starterAppSource());
+    await writeFile(join(options.outDir, "src", "client", "main.ts"), starterClientSource());
+    await writeFile(join(options.outDir, "src", "app.test.ts"), starterSmokeTestSource());
+    if (options.template === "ssr") {
+        await writeFile(join(options.outDir, "src", "server.ts"), starterServerSource());
+    }
+    await writeFile(join(options.outDir, "vite.config.ts"), starterViteConfigSource());
+    await writeFile(join(options.outDir, "tsconfig.json"), starterTsConfigSource());
+    await writeFile(join(options.outDir, ".gitignore"), starterGitignoreSource());
+    await writeFile(join(options.outDir, ".github", "workflows", "ci.yml"), starterCiSource());
+    await writeFile(join(options.outDir, "README.md"), starterReadmeSource(options.template));
+    await writeFile(join(options.outDir, "package.json"), starterPackageJsonSource());
+    return ok([
+        conflicts.length > 0
+            ? `Overwrote Tachyon DOM starter files in ${options.outDir}.`
+            : `Created Tachyon DOM starter in ${options.outDir}. Edit src/routes/index/page.td to start building.`,
+        ...conflicts.map((file) => `Overwrote ${file}.`),
+    ].join("\n"));
+};
+export const serverCommandMessage = (options) => options.command === "build"
+    ? "Build the tachyon-dom app with Vite."
+    : options.command === "dev"
+        ? `Start Vite dev server with tachyon-dom plugin on ${options.host}:${options.port}.`
+        : `Start Vite preview server for the built tachyon-dom app on ${options.host}:${options.port}.`;
+const startViteServer = async (options) => {
+    const vite = await import("vite");
+    if (options.command === "build") {
+        await vite.build();
+        return ok(serverCommandMessage(options));
+    }
+    const server = options.command === "dev"
+        ? await vite.createServer({
+            server: { host: options.host, port: options.port },
+        })
+        : await vite.preview({
+            preview: { host: options.host, port: options.port },
+        });
+    if ("listen" in server && typeof server.listen === "function") {
+        await server.listen();
+    }
+    const urls = "resolvedUrls" in server ? server.resolvedUrls?.local : undefined;
+    return ok(urls?.join("\n") ?? serverCommandMessage(options));
+};
+export const runCli = async (argv = process.argv.slice(2), entrypoint = process.argv[1]) => {
+    argv = normalizeCliArgv(argv, entrypoint);
+    if (argv[0] === "--help" || argv[0] === "-h" || argv[0] === "help") {
+        console.log(usage);
+        return 0;
+    }
+    if (argv[0] === "--version" || argv[0] === "-v") {
+        console.log(await packageVersion());
+        return 0;
+    }
+    if ((argv[1] === "--help" || argv[1] === "-h" || argv[1] === "help") && commandUsage[argv[0] ?? ""]) {
+        console.log(commandUsage[argv[0] ?? ""]);
+        return 0;
+    }
+    const parsed = parseArgs(argv);
+    if (!parsed.ok) {
+        console.error(parsed.error);
+        return 1;
+    }
+    let result;
+    switch (parsed.value.command) {
+        case "language-server": {
+            const { startLanguageServer } = await import("./language-server.js");
+            startLanguageServer();
+            return 0;
+        }
+        case "dev":
+        case "build":
+        case "preview":
+            result = await startViteServer(parsed.value);
+            break;
+        case "init":
+            result = await createStarterFiles(parsed.value);
+            break;
+        case "add-page":
+            result = await addPageFiles(parsed.value);
+            break;
+        case "typegen":
+            result = await generateTemplateTypesFile(parsed.value);
+            break;
+        case "compile":
+            result = await compileFile(parsed.value);
+            break;
+        case "routes":
+            result = await buildRouteManifestFile({
+                routesDir: parsed.value.routesDir,
+                ...(parsed.value.output ? { output: parsed.value.output } : {}),
+            });
+            break;
+    }
+    if (!result.ok) {
+        console.error(result.error);
+        return 1;
+    }
+    if (!("output" in parsed.value) || !parsed.value.output) {
+        console.log(result.value);
+    }
+    return 0;
+};
+export const isCliEntrypoint = async (scriptPath = process.argv[1], moduleUrl = import.meta.url) => {
+    if (!scriptPath) {
+        return false;
+    }
+    try {
+        return pathToFileURL(await realpath(scriptPath)).href === moduleUrl;
+    }
+    catch {
+        return scriptPath.endsWith("cli.js") && moduleUrl.endsWith("/cli.js");
+    }
+};
+if (await isCliEntrypoint()) {
+    process.exitCode = await runCli();
+}