@buding0904/vitepad 0.3.1 → 0.3.2

package/dist/cli-runtime.js

@@ -0,0 +1,807 @@
+#!/usr/bin/env node
+import fs3 from 'fs/promises';
+import os from 'os';
+import path3 from 'path';
+import process2 from 'process';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { createServer, mergeConfig, normalizePath, createLogger } from 'vite';
+import pc2 from 'picocolors';
+import { spawn } from 'child_process';
+import { createRequire } from 'module';
+
+var packageRoot = path3.resolve(fileURLToPath(new URL("..", import.meta.url)));
+var requireFromPackage = createRequire(path3.join(packageRoot, "package.json"));
+var linkedPeerPackages = ["vite"];
+var log = {
+  framework(requested, resolved) {
+    console.log(`
+${pc2.cyan("vitepad")} ${pc2.bold("framework")} ${pc2.gray(requested)} ${pc2.gray("->")} ${pc2.green(resolved)}`);
+  },
+  install(packages) {
+    console.log(`  ${pc2.gray("install")} ${packages.map((pkg) => pc2.cyan(pkg)).join(pc2.gray(", "))}`);
+  },
+  done(message) {
+    console.log(`  ${pc2.green(message)}`);
+  }
+};
+async function resolveFramework(spec, options) {
+  if (spec.name === "auto") {
+    throw new Error("Internal error: unresolved framework auto.");
+  }
+  if (spec.name === "vanilla") {
+    return {
+      name: "vanilla",
+      version: "local",
+      requested: "vanilla",
+      cacheStatus: "local",
+      aliases: [],
+      packageLinks: packageLinks(["unocss"]),
+      editorPackageLinks: []
+    };
+  }
+  const resolved = await resolveFrameworkPackages(spec.name, spec.version);
+  const cacheDir = frameworkCacheDir(spec.name, resolved.version);
+  const nodeModules = path3.join(cacheDir, "node_modules");
+  const installed = await isInstalled(cacheDir, resolved.packages);
+  log.framework(`${spec.name}@${spec.version}`, `${spec.name}@${resolved.version}`);
+  const cacheStatus = options.forceInstall ? "miss" : installed ? "hit" : "miss";
+  if (!installed) {
+    log.install(resolved.packages);
+    await installFrameworkCache(cacheDir, resolved.packages);
+  }
+  await linkPeerPackages(cacheDir);
+  return {
+    name: spec.name,
+    version: resolved.version,
+    requested: `${spec.name}@${spec.version}`,
+    cacheStatus,
+    cacheDir,
+    aliases: [],
+    packageLinks: [
+      ...packageLinks(["unocss"]),
+      ...packageLinks(nodeModules, frameworkRuntimePackages(spec.name))
+    ],
+    editorPackageLinks: packageLinks(nodeModules, frameworkEditorPackages(spec.name))
+  };
+}
+async function resolveFrameworkPackages(framework, version) {
+  const specs = frameworkPackageSpecs(framework, version);
+  const resolved = await Promise.all(specs.map(async (spec) => {
+    const parsed = splitPackageSpec(spec);
+    const resolvedVersion = await resolvePackageVersion(parsed.name, parsed.version);
+    return {
+      name: parsed.name,
+      version: resolvedVersion,
+      spec: `${parsed.name}@${resolvedVersion}`
+    };
+  }));
+  const primary = splitPackageSpec(specs[0]).name;
+  const primaryVersion = resolved.find((pkg) => pkg.name === primary)?.version;
+  if (!primaryVersion) {
+    throw new Error(`Failed to resolve ${framework}@${version}.`);
+  }
+  return {
+    version: primaryVersion,
+    packages: resolved.map((pkg) => pkg.spec)
+  };
+}
+function frameworkDedupe(framework) {
+  return frameworkRuntimePackages(framework);
+}
+function frameworkOptimizeDeps(framework) {
+  switch (framework) {
+    case "react":
+      return ["react", "react-dom", "react/jsx-runtime", "react/jsx-dev-runtime"];
+    case "preact":
+      return ["preact", "preact/jsx-runtime", "preact/hooks"];
+    case "solid":
+      return ["solid-js", "solid-js/web"];
+    case "vue":
+      return ["vue"];
+    case "svelte":
+    case "vanilla":
+      return [];
+  }
+}
+async function loadFrameworkPlugins(framework) {
+  if (framework.name === "vanilla") {
+    return [];
+  }
+  if (!framework.cacheDir) {
+    throw new Error(`Missing framework cache for ${framework.name}.`);
+  }
+  const plugins = [];
+  for (const pluginPackage of frameworkPluginPackages(framework.name)) {
+    const mod = await importCachePackage(framework.cacheDir, pluginPackage);
+    appendPlugin(plugins, createFrameworkPlugin(pluginPackage, mod));
+  }
+  return plugins;
+}
+function createFrameworkPlugin(pluginPackage, mod) {
+  const factory = frameworkPluginFactory(pluginPackage, mod);
+  return factory();
+}
+function frameworkPluginFactory(pluginPackage, mod) {
+  if (pluginPackage === "@sveltejs/vite-plugin-svelte" && typeof mod.svelte === "function") {
+    return mod.svelte;
+  }
+  if (pluginPackage === "@preact/preset-vite" && typeof mod.preact === "function") {
+    return mod.preact;
+  }
+  if (typeof mod.default === "function") {
+    return mod.default;
+  }
+  if (mod.default && typeof mod.default.default === "function") {
+    return mod.default.default;
+  }
+  throw new Error(`Failed to load Vite plugin ${pluginPackage}: no callable plugin export found.`);
+}
+function appendPlugin(plugins, plugin) {
+  if (Array.isArray(plugin)) {
+    plugins.push(...plugin);
+  } else {
+    plugins.push(plugin);
+  }
+}
+function frameworkPackageSpecs(framework, version) {
+  switch (framework) {
+    case "react":
+      return [
+        `react@${version}`,
+        `react-dom@${version}`,
+        `@types/react@${reactTypesVersion(version)}`,
+        `@types/react-dom@${reactTypesVersion(version)}`,
+        "@vitejs/plugin-react@latest"
+      ];
+    case "preact":
+      return [`preact@${version}`, "@preact/preset-vite@latest"];
+    case "solid":
+      return [`solid-js@${version}`, "vite-plugin-solid@latest"];
+    case "vue":
+      return [`vue@${version}`, "@vitejs/plugin-vue@latest", "@vitejs/plugin-vue-jsx@latest"];
+    case "svelte":
+      return [`svelte@${version}`, "@sveltejs/vite-plugin-svelte@latest"];
+    case "vanilla":
+      return [];
+  }
+}
+function reactTypesVersion(version) {
+  const major = version.match(/^\D*(\d+)/)?.[1];
+  return major || "latest";
+}
+function resolvePackageVersion(name, range) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("npm", ["view", `${name}@${range}`, "version", "--json"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        reject(new Error(`npm view failed for ${name}@${range}
+${stderr.trim()}`));
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout.trim());
+        const version = Array.isArray(parsed) ? parsed[parsed.length - 1] : parsed;
+        if (typeof version !== "string" || !version) {
+          throw new Error(`Unexpected npm view output: ${stdout}`);
+        }
+        resolve(version);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+}
+function frameworkRuntimePackages(framework) {
+  switch (framework) {
+    case "react":
+      return ["react", "react-dom"];
+    case "preact":
+      return ["preact"];
+    case "solid":
+      return ["solid-js"];
+    case "vue":
+      return ["vue"];
+    case "svelte":
+      return ["svelte"];
+    case "vanilla":
+      return [];
+  }
+}
+function frameworkEditorPackages(framework) {
+  switch (framework) {
+    case "react":
+      return ["react", "react-dom", "@types/react", "@types/react-dom"];
+    case "preact":
+    case "solid":
+    case "vue":
+    case "svelte":
+    case "vanilla":
+      return frameworkRuntimePackages(framework);
+  }
+}
+function frameworkPluginPackages(framework) {
+  switch (framework) {
+    case "react":
+      return ["@vitejs/plugin-react"];
+    case "preact":
+      return ["@preact/preset-vite"];
+    case "solid":
+      return ["vite-plugin-solid"];
+    case "vue":
+      return ["@vitejs/plugin-vue", "@vitejs/plugin-vue-jsx"];
+    case "svelte":
+      return ["@sveltejs/vite-plugin-svelte"];
+    case "vanilla":
+      return [];
+  }
+}
+function packageLinks(nodeModulesOrPackageNames, maybePackageNames) {
+  if (Array.isArray(nodeModulesOrPackageNames)) {
+    return nodeModulesOrPackageNames.map((packageName) => ({
+      name: packageName,
+      source: resolveInstalledPackageDir(packageName)
+    }));
+  }
+  const nodeModules = nodeModulesOrPackageNames;
+  const packageNames = maybePackageNames ?? [];
+  return packageNames.map((packageName) => ({
+    name: packageName,
+    source: path3.join(nodeModules, packageName)
+  }));
+}
+function resolveInstalledPackageDir(packageName) {
+  const packageJson = requireFromPackage.resolve(`${packageName}/package.json`);
+  return path3.dirname(packageJson);
+}
+function frameworkCacheDir(framework, version) {
+  const base = process.env.VITEPAD_CACHE_DIR || (process.env.XDG_CACHE_HOME ? path3.join(process.env.XDG_CACHE_HOME, "vitepad") : path3.join(os.homedir(), ".cache", "vitepad"));
+  return path3.join(base, "frameworks", `${framework}-${sanitizeCacheKey(version)}`);
+}
+function sanitizeCacheKey(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+async function isInstalled(cacheDir, packages) {
+  if (!await pathExists(path3.join(cacheDir, "node_modules"))) return false;
+  for (const pkg of packages) {
+    const { name } = splitPackageSpec(pkg);
+    if (!await pathExists(path3.join(cacheDir, "node_modules", name))) {
+      return false;
+    }
+  }
+  return true;
+}
+async function installFrameworkCache(cacheDir, packages) {
+  await fs3.mkdir(cacheDir, { recursive: true });
+  await fs3.writeFile(path3.join(cacheDir, "package.json"), JSON.stringify({
+    private: true,
+    type: "module",
+    dependencies: Object.fromEntries(packages.map((pkg) => packageToDependency(pkg)))
+  }, null, 2));
+  await runInstall(cacheDir);
+}
+function runInstall(cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("npm", ["install", "--legacy-peer-deps", "--no-audit", "--no-fund", "--loglevel=notice"], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const progress = createProgress("vitepad: installing framework packages");
+    let output = "";
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+      progress.tick();
+    });
+    child.stderr.on("data", (chunk) => {
+      output += chunk;
+      progress.tick();
+    });
+    child.on("error", (error) => {
+      progress.stop();
+      reject(error);
+    });
+    child.on("exit", (code) => {
+      progress.stop();
+      if (code === 0) {
+        log.done("install complete");
+        resolve();
+      } else {
+        reject(new Error(`npm install failed with exit code ${code}
+${output.trim()}`));
+      }
+    });
+  });
+}
+async function linkPeerPackages(cacheDir) {
+  await fs3.mkdir(path3.join(cacheDir, "node_modules"), { recursive: true });
+  for (const packageName of linkedPeerPackages) {
+    try {
+      await linkPackage({
+        source: resolveInstalledPackageDir(packageName),
+        target: path3.join(cacheDir, "node_modules", packageName)
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to link ${packageName} into vitepad cache at ${cacheDir}.
+${message}`);
+    }
+  }
+}
+async function linkPackage(input) {
+  const source = await fs3.realpath(input.source);
+  const existing = await fs3.lstat(input.target).catch(() => null);
+  if (existing) {
+    if (existing.isSymbolicLink()) {
+      const current = await fs3.realpath(input.target).catch(() => null);
+      if (current === source) return;
+    }
+    await fs3.rm(input.target, { recursive: true, force: true });
+  }
+  await fs3.symlink(source, input.target, "dir");
+}
+function createProgress(label) {
+  const width = 18;
+  let frame = 0;
+  const render = () => {
+    const position = frame % width;
+    const bar = Array.from({ length: width }, (_, index) => index === position ? "=" : "-").join("");
+    process.stderr.write(`\r${label} [${bar}]`);
+    frame += 1;
+  };
+  const timer = setInterval(render, 120);
+  render();
+  return {
+    tick: render,
+    stop() {
+      clearInterval(timer);
+      process.stderr.write(`\r${" ".repeat(label.length + width + 4)}\r`);
+    }
+  };
+}
+function packageToDependency(pkg) {
+  const parsed = splitPackageSpec(pkg);
+  return [parsed.name, parsed.version];
+}
+function splitPackageSpec(spec) {
+  if (spec.startsWith("@")) {
+    const secondAt = spec.indexOf("@", 1);
+    if (secondAt === -1) return { name: spec, version: "latest" };
+    return { name: spec.slice(0, secondAt), version: spec.slice(secondAt + 1) };
+  }
+  const at = spec.indexOf("@");
+  if (at === -1) return { name: spec, version: "latest" };
+  return { name: spec.slice(0, at), version: spec.slice(at + 1) };
+}
+async function importCachePackage(cacheDir, packageName) {
+  const requireFromCache = createRequire(path3.join(cacheDir, "package.json"));
+  const resolved = requireFromCache.resolve(packageName);
+  return import(pathToFileURL(resolved).href);
+}
+async function pathExists(file) {
+  return fs3.access(file).then(() => true, () => false);
+}
+async function packageVersion() {
+  const packageJson = await readPackageJson();
+  if (typeof packageJson.version === "string") return packageJson.version;
+  throw new Error("Failed to read vitepad version from package.json.");
+}
+async function readPackageJson() {
+  let current = path3.dirname(fileURLToPath(import.meta.url));
+  while (true) {
+    const packageJsonPath = path3.join(current, "package.json");
+    const source = await fs3.readFile(packageJsonPath, "utf8").catch(() => null);
+    if (source) {
+      const packageJson = JSON.parse(source);
+      if (packageJson.name === "@buding0904/vitepad") return packageJson;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      throw new Error("Failed to locate vitepad package.json.");
+    }
+    current = parent;
+  }
+}
+
+// src/runtime/index.ts
+var rootDir = path3.resolve(fileURLToPath(new URL("..", import.meta.url)));
+var supportedComponentExts = /* @__PURE__ */ new Set([".jsx", ".tsx", ".vue", ".svelte"]);
+var supportedMainExts = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"]);
+var frameworkValues = /* @__PURE__ */ new Set(["auto", "react", "preact", "solid", "vue", "svelte", "vanilla"]);
+async function run(argv) {
+  const options = parseArgs(argv);
+  if (options.help) {
+    console.log(helpText());
+    return;
+  }
+  if (options.version) {
+    console.log(await packageVersion());
+    return;
+  }
+  if (!options.entry) {
+    throw new Error(helpText("Missing entry file."));
+  }
+  const entry = path3.resolve(process2.cwd(), options.entry);
+  const stat = await fs3.stat(entry).catch(() => null);
+  if (!stat?.isFile()) {
+    throw new Error(`Entry file does not exist: ${entry}`);
+  }
+  const extension = path3.extname(entry).toLowerCase();
+  const mode = inferMode(extension);
+  const source = await fs3.readFile(entry, "utf8");
+  const framework = inferFramework({
+    extension,
+    source,
+    requested: options.framework,
+    version: options.frameworkVersion
+  });
+  validateCombination({ mode, framework: framework.name, extension });
+  const resolvedFramework = await resolveFramework(framework, { forceInstall: false });
+  await setupEditorPackages(path3.dirname(entry), resolvedFramework.editorPackageLinks);
+  const workspace = await createWorkspace({
+    entry,
+    mode,
+    framework: resolvedFramework.name,
+    packageLinks: resolvedFramework.packageLinks
+  });
+  const config = await loadUserConfig(options.config);
+  const server = await createServer(mergeConfig({
+    root: workspace,
+    configFile: false,
+    server: {
+      host: options.host,
+      port: options.port,
+      strictPort: options.strictPort,
+      open: false,
+      watch: {
+        ignored: (file) => normalizePath(file).startsWith(`${normalizePath(workspace)}/`)
+      },
+      fs: {
+        allow: [
+          rootDir,
+          process2.cwd(),
+          path3.dirname(entry),
+          workspace,
+          ...resolvedFramework.cacheDir ? [resolvedFramework.cacheDir] : []
+        ]
+      }
+    },
+    plugins: await loadPlugins(resolvedFramework),
+    resolve: {
+      alias: [
+        ...resolvedFramework.aliases,
+        {
+          find: "@",
+          replacement: path3.dirname(entry)
+        }
+      ],
+      dedupe: frameworkDedupe(resolvedFramework.name)
+    },
+    optimizeDeps: {
+      entries: [path3.join(workspace, "src/main.js")],
+      include: frameworkOptimizeDeps(resolvedFramework.name)
+    },
+    customLogger: createVitepadLogger()
+  }, config));
+  await server.listen();
+  printReady({
+    entry,
+    framework: resolvedFramework,
+    urls: server.resolvedUrls
+  });
+  const close = async () => {
+    await server.close();
+    process2.exit(0);
+  };
+  process2.once("SIGINT", close);
+  process2.once("SIGTERM", close);
+}
+function parseArgs(argv) {
+  const options = {
+    framework: "auto",
+    frameworkVersion: "latest",
+    port: 8e3,
+    strictPort: false,
+    host: "0.0.0.0",
+    help: false,
+    version: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "-h" || arg === "--help") {
+      options.help = true;
+    } else if (arg === "-v" || arg === "--version") {
+      options.version = true;
+    } else if (arg === "--framework" || arg === "-f") {
+      Object.assign(options, parseFramework(readValue(argv, ++index, arg)));
+    } else if (arg.startsWith("--framework=")) {
+      Object.assign(options, parseFramework(arg.slice("--framework=".length)));
+    } else if (arg === "--strictPort") {
+      options.strictPort = true;
+    } else if (arg === "--port" || arg === "-p") {
+      options.port = Number(readValue(argv, ++index, arg));
+    } else if (arg.startsWith("--port=")) {
+      options.port = Number(arg.slice("--port=".length));
+    } else if (arg === "--host") {
+      options.host = readValue(argv, ++index, arg);
+    } else if (arg.startsWith("--host=")) {
+      options.host = arg.slice("--host=".length);
+    } else if (arg === "--config" || arg === "-c") {
+      options.config = readValue(argv, ++index, arg);
+    } else if (arg.startsWith("--config=")) {
+      options.config = arg.slice("--config=".length);
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else if (!options.entry) {
+      options.entry = arg;
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+  if (!Number.isInteger(options.port) || options.port < 0 || options.port > 65535) {
+    throw new Error(`Invalid port: ${options.port}`);
+  }
+  return options;
+}
+function parseFramework(value) {
+  const match = value.match(/^([^@]+)(?:@(.+))?$/);
+  const name = match?.[1];
+  const version = match?.[2] || "latest";
+  if (name && frameworkValues.has(name)) {
+    return { framework: name, frameworkVersion: version };
+  }
+  throw new Error(`Unsupported framework "${value}". Use one of: ${[...frameworkValues].join(", ")}, optionally with @version.`);
+}
+function readValue(argv, index, option) {
+  const value = argv[index];
+  if (!value || value.startsWith("-")) {
+    throw new Error(`Missing value for ${option}`);
+  }
+  return value;
+}
+function inferMode(extension) {
+  if (supportedMainExts.has(extension)) return "main";
+  if (supportedComponentExts.has(extension)) return "component";
+  throw new Error(`Unsupported entry extension "${extension}". Supported: js, ts, jsx, tsx, vue, svelte.`);
+}
+function inferFramework(input) {
+  const { extension, source, requested, version } = input;
+  if (requested !== "auto") return { name: requested, version };
+  if (extension === ".vue") return { name: "vue", version };
+  if (extension === ".svelte") return { name: "svelte", version };
+  if (/\bfrom\s+['"]solid-js\b|\bfrom\s+['"]solid-js\/web\b|\bsolid-js\b/.test(source)) return { name: "solid", version };
+  if (/\bfrom\s+['"]preact\b|\bfrom\s+['"]preact\/compat\b|\bfrom\s+['"]preact\/hooks\b/.test(source)) return { name: "preact", version };
+  if (/\bfrom\s+['"]vue\b/.test(source)) return { name: "vue", version };
+  if (/\bfrom\s+['"]svelte\b|\bfrom\s+['"]svelte\//.test(source)) return { name: "svelte", version };
+  if (extension === ".jsx" || extension === ".tsx") return { name: "react", version };
+  return { name: "vanilla", version: "local" };
+}
+function validateCombination(input) {
+  const { mode, framework, extension } = input;
+  if (mode === "component" && framework === "vanilla") {
+    throw new Error(`Component entry ${extension} needs a framework. Try --framework react, vue, svelte, preact, or solid.`);
+  }
+  if (extension === ".vue" && framework !== "vue") {
+    throw new Error(".vue entries must use --framework vue.");
+  }
+  if (extension === ".svelte" && framework !== "svelte") {
+    throw new Error(".svelte entries must use --framework svelte.");
+  }
+}
+async function createWorkspace(input) {
+  const workspace = await fs3.mkdtemp(path3.join(await fs3.realpath(os.tmpdir()), "vitepad-"));
+  const srcDir = path3.join(workspace, "src");
+  const nodeModulesDir = path3.join(workspace, "node_modules");
+  await fs3.mkdir(srcDir, { recursive: true });
+  await fs3.mkdir(nodeModulesDir, { recursive: true });
+  await Promise.all([
+    fs3.writeFile(path3.join(workspace, "index.html"), htmlTemplate()),
+    fs3.writeFile(path3.join(srcDir, "main.js"), mainTemplate(input)),
+    ...input.packageLinks.map((link) => linkWorkspacePackage(nodeModulesDir, link))
+  ]);
+  return workspace;
+}
+async function linkWorkspacePackage(nodeModulesDir, link) {
+  const source = await fs3.realpath(link.source);
+  const target = path3.join(nodeModulesDir, link.name);
+  await fs3.mkdir(path3.dirname(target), { recursive: true });
+  await fs3.symlink(source, target, "dir");
+}
+async function setupEditorPackages(projectDir, links) {
+  if (links.length === 0) return;
+  const linked = [];
+  for (const link of links) {
+    const result = await linkEditorPackage(projectDir, link);
+    if (result === "linked") {
+      linked.push(link.name);
+    }
+  }
+  if (linked.length > 0) {
+    console.log(`${pc2.cyan("vitepad")} ${pc2.green("editor")} linked ${linked.map((name) => pc2.cyan(name)).join(pc2.gray(", "))}`);
+  }
+}
+async function linkEditorPackage(projectDir, link) {
+  const source = await fs3.realpath(link.source);
+  const existingResolvablePackage = await findResolvablePackage(projectDir, link.name);
+  if (existingResolvablePackage) return "skipped";
+  const nodeModulesDir = path3.join(projectDir, "node_modules");
+  const target = path3.join(nodeModulesDir, link.name);
+  await fs3.mkdir(path3.dirname(target), { recursive: true });
+  const existing = await fs3.lstat(target).catch(() => null);
+  if (existing) {
+    if (existing.isSymbolicLink()) {
+      const current = await fs3.realpath(target).catch(() => null);
+      if (current === source) return "skipped";
+    }
+    return "skipped";
+  }
+  await fs3.symlink(source, target, "dir");
+  return "linked";
+}
+async function findResolvablePackage(fromDir, packageName) {
+  let current = path3.resolve(fromDir);
+  while (true) {
+    const candidate = path3.join(current, "node_modules", packageName);
+    const existing = await fs3.lstat(candidate).catch(() => null);
+    if (existing) return candidate;
+    const parent = path3.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function htmlTemplate() {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>vitepad</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.js"></script>
+  </body>
+</html>
+`;
+}
+function mainTemplate(input) {
+  const { entry, mode, framework } = input;
+  const importPath = `/@fs/${normalizePath(entry)}`;
+  if (mode === "main") {
+    return `import 'virtual:uno.css'
+import ${JSON.stringify(importPath)}
+`;
+  }
+  switch (framework) {
+    case "react":
+      return `import 'virtual:uno.css'
+import React from 'react'
+import { createRoot } from 'react-dom/client'
+import App from ${JSON.stringify(importPath)}
+
+createRoot(document.getElementById('root')).render(React.createElement(App))
+`;
+    case "preact":
+      return `import 'virtual:uno.css'
+import { h, render } from 'preact'
+import App from ${JSON.stringify(importPath)}
+
+render(h(App, null), document.getElementById('root'))
+`;
+    case "solid":
+      return `import 'virtual:uno.css'
+import { render } from 'solid-js/web'
+import App from ${JSON.stringify(importPath)}
+
+render(() => App({}), document.getElementById('root'))
+`;
+    case "vue":
+      return `import 'virtual:uno.css'
+import { createApp } from 'vue'
+import App from ${JSON.stringify(importPath)}
+
+createApp(App).mount('#root')
+`;
+    case "svelte":
+      return `import 'virtual:uno.css'
+import { mount } from 'svelte'
+import App from ${JSON.stringify(importPath)}
+
+const target = document.getElementById('root')
+const app = mount(App, { target })
+export default app
+`;
+    case "vanilla":
+      throw new Error("Vanilla entries cannot be used as component entries.");
+  }
+}
+async function loadUserConfig(configFile) {
+  if (!configFile) return {};
+  const resolved = path3.resolve(process2.cwd(), configFile);
+  const configModule = await import(pathToFileURL(resolved).href);
+  return configModule.default ?? configModule;
+}
+async function loadPlugins(framework) {
+  const [{ default: unocss }, { presetUno }, frameworkPlugins] = await Promise.all([
+    import('unocss/vite'),
+    import('unocss'),
+    loadFrameworkPlugins(framework)
+  ]);
+  const plugins = [];
+  appendPlugin(plugins, unocss({ presets: [presetUno()] }));
+  plugins.push(...frameworkPlugins);
+  return plugins;
+}
+function printReady(input) {
+  const { entry, framework, urls } = input;
+  const frameworkLabel = `${framework.name}@${framework.version}`;
+  console.log(`${pc2.cyan("vitepad")} ${pc2.green("ready")} ${pc2.green(frameworkLabel)}`);
+  console.log(`  ${pc2.gray("entry")}     ${pc2.gray(entry)}`);
+  if (framework.cacheDir) {
+    console.log(`  ${pc2.gray("cache")}     ${pc2.gray(framework.cacheDir)}`);
+  }
+  printUrls(urls);
+}
+function printUrls(urls) {
+  if (!urls) return;
+  for (const url of urls.local) {
+    console.log(`  ${pc2.green("\u279C")}  ${pc2.bold("Local:")}   ${pc2.bold(url)}`);
+  }
+  for (const url of urls.network) {
+    console.log(`  ${pc2.green("\u279C")}  ${pc2.bold("Network:")} ${pc2.bold(url)}`);
+  }
+}
+function createVitepadLogger() {
+  const logger = createLogger("info");
+  const info = logger.info.bind(logger);
+  return {
+    ...logger,
+    info(message, options) {
+      if (isNoisyViteInfo(message)) return;
+      info(message, options);
+    }
+  };
+}
+function isNoisyViteInfo(message) {
+  return /\[vite\]\s+\(client\)\s+(hmr update|page reload)\b/.test(stripAnsi(message));
+}
+function stripAnsi(value) {
+  return value.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+function helpText(prefix) {
+  return `${prefix ? `${prefix}
+
+` : ""}Usage:
+  vitepad <entry> [options]
+
+Entries:
+  .js, .ts                  Treated as main entry files.
+  .jsx, .tsx, .vue, .svelte Treated as App component files.
+
+Options:
+  -f, --framework <name>    auto, react, preact, solid, vue, svelte, vanilla
+                            Version specs are supported, e.g. react@18, vue@3.4.
+  -p, --port <number>       Dev server port. Default: 8000
+  --strictPort              Exit if the configured port is already in use.
+  --host <host>             Dev server host. Default: 0.0.0.0
+  -c, --config <file>       Merge an extra Vite config file.
+  -h, --help                Show help.
+`;
+}
+
+// src/cli-runtime.ts
+run(process.argv.slice(2)).catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});
+//# sourceMappingURL=cli-runtime.js.map
+//# sourceMappingURL=cli-runtime.js.map