vantris 0.2.0 → 0.3.0

package/dist/chunk-LRSN7SF4.js

@@ -0,0 +1,1117 @@
+import { pathToFileURL } from 'url';
+import { readFile, stat, rm, mkdir, cp, writeFile, realpath } from 'fs/promises';
+import { sep, join, basename, relative, isAbsolute, resolve, dirname, extname } from 'path';
+import { createServer } from 'http';
+import { H3, toNodeHandler, getRequestURL } from 'h3';
+import { WebSocketServer, WebSocket } from 'ws';
+import { transform } from 'esbuild';
+import MagicString from 'magic-string';
+import { rolldown } from 'rolldown';
+import { bundleAsync } from 'lightningcss';
+import { createHash } from 'crypto';
+import { watch } from 'chokidar';
+
+// src/shared/constants.ts
+var APP_NAME = "vantris";
+var VERSION = "0.3.0";
+var HTML_ENTRY_FILENAME = "index.html";
+var DEFAULTS = {
+  root: ".",
+  rootDir: "./src",
+  publicDir: "./public",
+  outDir: "./dist"
+};
+var DEV_DEFAULTS = {
+  port: 3e3,
+  host: "localhost"
+};
+var BUILD_DEFAULTS = {
+  minify: true,
+  sourcemap: false,
+  assetsDir: "assets"
+};
+var ASSET_EXTENSIONS = [
+  // images
+  ".svg",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".avif",
+  ".ico",
+  ".bmp",
+  // fonts
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  // media
+  ".mp4",
+  ".webm",
+  ".ogg",
+  ".mp3",
+  ".wav",
+  ".flac",
+  ".aac"
+];
+var RELOAD_MESSAGE = "reload";
+var CONFIG_FILENAMES = [
+  "vantris.config.ts",
+  "vantris.config.js",
+  "vantris.config.mjs"
+];
+
+// src/shared/errors.ts
+var VantrisError = class extends Error {
+  name = "VantrisError";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+var ConfigError = class extends VantrisError {
+  name = "ConfigError";
+};
+var HtmlEntryError = class extends VantrisError {
+  name = "HtmlEntryError";
+};
+var BuildError = class extends VantrisError {
+  name = "BuildError";
+};
+var NotImplementedError = class extends VantrisError {
+  name = "NotImplementedError";
+};
+function isVantrisError(error) {
+  return error instanceof VantrisError;
+}
+async function isFile(path) {
+  try {
+    return (await stat(path)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readTextFile(path) {
+  return readFile(path, "utf8");
+}
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+function resolveFrom(base, target) {
+  return isAbsolute(target) ? target : resolve(base, target);
+}
+
+// src/config/load.ts
+async function loadConfig(options) {
+  const { cwd, logger } = options;
+  const file = options.configFile ? resolveFrom(cwd, options.configFile) : await findConfigFile(cwd);
+  if (!file) {
+    logger.debug("No config file found; using defaults.");
+    return { config: {}, file: null };
+  }
+  logger.debug(`Loading config from ${file}`);
+  const config = await importConfig(file);
+  return { config, file };
+}
+async function findConfigFile(cwd) {
+  for (const name of CONFIG_FILENAMES) {
+    const candidate = resolveFrom(cwd, name);
+    if (await isFile(candidate)) return candidate;
+  }
+  return null;
+}
+async function importConfig(file) {
+  let mod;
+  try {
+    const url = `${pathToFileURL(file).href}?t=${Date.now()}`;
+    mod = await import(url);
+  } catch (cause) {
+    throw new ConfigError(`Failed to load config file: ${file}`, { cause });
+  }
+  const exported = mod.default;
+  if (exported === void 0) {
+    throw new ConfigError(
+      `Config file "${file}" has no default export. Export your config with \`export default defineConfig({ ... })\`.`
+    );
+  }
+  return normalise(exported, file);
+}
+async function normalise(input, file) {
+  const value = typeof input === "function" ? await input() : input;
+  if (value === null || typeof value !== "object") {
+    throw new ConfigError(
+      `Config file "${file}" must export an object (or a function returning one).`
+    );
+  }
+  return value;
+}
+
+// src/config/resolve.ts
+function resolveConfig(raw, cwd, configFile = null) {
+  const root = resolveFrom(cwd, raw.root ?? DEFAULTS.root);
+  const paths = {
+    root,
+    rootDir: resolveFrom(root, raw.rootDir ?? DEFAULTS.rootDir),
+    publicDir: resolveFrom(root, raw.publicDir ?? DEFAULTS.publicDir),
+    outDir: resolveFrom(root, raw.outDir ?? DEFAULTS.outDir)
+  };
+  const base = normalizeBase(raw.base ?? "/");
+  const dev2 = {
+    port: raw.dev?.port ?? DEV_DEFAULTS.port,
+    host: raw.dev?.host ?? DEV_DEFAULTS.host
+  };
+  const assetsDir = raw.build?.assetsDir ?? BUILD_DEFAULTS.assetsDir;
+  const build2 = {
+    minify: raw.build?.minify ?? BUILD_DEFAULTS.minify,
+    sourcemap: raw.build?.sourcemap ?? BUILD_DEFAULTS.sourcemap,
+    assetsDir,
+    // File-name patterns default off `assetsDir`; explicit values win.
+    entryFileNames: raw.build?.entryFileNames ?? `${assetsDir}/[name]-[hash].js`,
+    chunkFileNames: raw.build?.chunkFileNames ?? `${assetsDir}/[name]-[hash].js`,
+    assetFileNames: raw.build?.assetFileNames ?? `${assetsDir}/[name]-[hash][extname]`
+  };
+  return { raw, paths, base, dev: dev2, build: build2, configFile };
+}
+function normalizeBase(base) {
+  let value = base.trim() || "/";
+  if (!/^https?:\/\//.test(value) && !value.startsWith("/")) {
+    value = `/${value}`;
+  }
+  if (!value.endsWith("/")) value = `${value}/`;
+  return value;
+}
+
+// src/html/parse.ts
+var SCRIPT_TAG = /<script\b[^>]*>/gi;
+var TYPE_MODULE = /\btype\s*=\s*["']module["']/i;
+var SRC_ATTR = /\bsrc\s*=\s*["']([^"']+)["']/i;
+function parseHtml(file, html) {
+  const scripts = [];
+  for (const [tag] of html.matchAll(SCRIPT_TAG)) {
+    if (!TYPE_MODULE.test(tag)) continue;
+    const src = SRC_ATTR.exec(tag)?.[1];
+    if (src) scripts.push({ src });
+  }
+  return { file, html, scripts };
+}
+
+// src/html/detect.ts
+async function detectHtmlEntry(root) {
+  const file = resolveFrom(root, HTML_ENTRY_FILENAME);
+  if (!await isFile(file)) return null;
+  const html = await readTextFile(file);
+  return parseHtml(file, html);
+}
+
+// src/html/client.ts
+var DEV_CLIENT_SCRIPT = `<script type="module">
+  // Injected by Vantris dev server \u2014 live reload (full page).
+  const connect = () => {
+    const ws = new WebSocket("ws://" + location.host);
+    ws.addEventListener("message", () => location.reload());
+    // Reconnect if the dev server restarts.
+    ws.addEventListener("close", () => setTimeout(connect, 1000));
+  };
+  connect();
+</script>`;
+function injectDevClient(html) {
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${DEV_CLIENT_SCRIPT}
+</head>`);
+  }
+  if (html.includes("</body>")) {
+    return html.replace("</body>", `${DEV_CLIENT_SCRIPT}
+</body>`);
+  }
+  return `${html}
+${DEV_CLIENT_SCRIPT}`;
+}
+function createReloadSocket(options) {
+  const { server, logger } = options;
+  const wss = new WebSocketServer({ server });
+  const clients = /* @__PURE__ */ new Set();
+  wss.on("connection", (socket) => {
+    clients.add(socket);
+    socket.on("close", () => clients.delete(socket));
+    socket.on("error", () => clients.delete(socket));
+  });
+  wss.on("error", (error) => {
+    logger.error(`websocket error: ${error.message}`);
+  });
+  return {
+    broadcastReload() {
+      for (const socket of clients) {
+        if (socket.readyState === WebSocket.OPEN) {
+          socket.send(RELOAD_MESSAGE);
+        }
+      }
+    },
+    get clientCount() {
+      return clients.size;
+    },
+    close() {
+      return new Promise((resolveClose) => {
+        for (const socket of clients) socket.terminate();
+        clients.clear();
+        wss.close(() => resolveClose());
+      });
+    }
+  };
+}
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".txt": "text/plain; charset=utf-8",
+  ".map": "application/json; charset=utf-8"
+};
+var JAVASCRIPT = "text/javascript; charset=utf-8";
+function contentTypeFor(file, transpiled = false) {
+  if (transpiled) return JAVASCRIPT;
+  return MIME_TYPES[extname(file).toLowerCase()] ?? "application/octet-stream";
+}
+var TRANSPILE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".jsx"]);
+function shouldTranspile(file) {
+  return TRANSPILE_EXTENSIONS.has(extname(file).toLowerCase());
+}
+function loaderFor(file) {
+  switch (extname(file).toLowerCase()) {
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    default:
+      return "ts";
+  }
+}
+async function transpile(code, file) {
+  const result = await transform(code, {
+    loader: loaderFor(file),
+    format: "esm",
+    target: "es2022",
+    sourcemap: "inline",
+    sourcefile: file
+  });
+  return result.code;
+}
+
+// src/server/static.ts
+var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".mjs", ".jsx"];
+function createStaticLoader(options) {
+  const root = resolve(options.root);
+  const rootDir = resolve(options.rootDir);
+  const publicDir = resolve(options.publicDir);
+  return async function loadAsset(pathname) {
+    const relative4 = decodeURIComponent(pathname).replace(/^\/+/, "");
+    if (!relative4) return null;
+    const source = await resolveConfined(root, rootDir, relative4);
+    if (source) return readAsset(source);
+    const asset = await resolveConfined(publicDir, publicDir, relative4);
+    if (asset) return readAsset(asset);
+    return null;
+  };
+}
+async function resolveConfined(base, confine, relative4) {
+  const target = resolve(join(base, relative4));
+  if (target !== confine && !target.startsWith(confine + sep)) {
+    return null;
+  }
+  if (await isFile(target)) return target;
+  if (!extname(target)) {
+    for (const ext of RESOLVE_EXTENSIONS) {
+      const candidate = `${target}${ext}`;
+      if (await isFile(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+async function readAsset(file) {
+  const ext = extname(file).toLowerCase();
+  const isHtml = ext === ".html";
+  if (shouldTranspile(file)) {
+    const source = await readFile(file, "utf8");
+    return {
+      body: await transpile(source, file),
+      contentType: contentTypeFor(file, true),
+      isHtml: false
+    };
+  }
+  if (isHtml) {
+    return {
+      body: await readFile(file, "utf8"),
+      contentType: contentTypeFor(file),
+      isHtml: true
+    };
+  }
+  return {
+    body: await readFile(file),
+    contentType: contentTypeFor(file),
+    isHtml: false
+  };
+}
+
+// src/server/index.ts
+var HTML_HEADERS = {
+  "content-type": "text/html; charset=utf-8",
+  "cache-control": "no-cache"
+};
+async function startDevServer(options) {
+  const { ctx, entry } = options;
+  const { paths, dev: dev2 } = ctx.config;
+  const loadAsset = createStaticLoader({
+    root: paths.root,
+    rootDir: paths.rootDir,
+    publicDir: paths.publicDir
+  });
+  const entryFile = entry?.file ?? null;
+  const app = new H3();
+  const handler = async (event) => {
+    const { pathname } = getRequestURL(event);
+    const asset = await loadAsset(pathname);
+    if (asset) {
+      if (asset.isHtml) {
+        return new Response(injectDevClient(asset.body), {
+          headers: HTML_HEADERS
+        });
+      }
+      return new Response(asset.body, {
+        headers: { "content-type": asset.contentType, "cache-control": "no-cache" }
+      });
+    }
+    if (entryFile) {
+      const html = await readFile(entryFile, "utf8");
+      return new Response(injectDevClient(html), { headers: HTML_HEADERS });
+    }
+    return new Response(`404 Not Found: ${pathname}`, {
+      status: 404,
+      headers: { "content-type": "text/plain; charset=utf-8" }
+    });
+  };
+  app.all("/", handler);
+  app.all("/**", handler);
+  const server = createServer(toNodeHandler(app));
+  const reload = createReloadSocket({ server, logger: ctx.logger });
+  const port = await listen(server, dev2.port, dev2.host);
+  const url = `http://${dev2.host}:${port}/`;
+  return {
+    url,
+    host: dev2.host,
+    port,
+    broadcastReload: () => reload.broadcastReload(),
+    async close() {
+      await reload.close();
+      await new Promise((resolveClose, reject) => {
+        server.close((err) => err ? reject(err) : resolveClose());
+      });
+    }
+  };
+}
+function listen(server, port, host) {
+  return new Promise((resolveListen, reject) => {
+    const onError = (err) => {
+      server.removeListener("error", onError);
+      reject(
+        err.code === "EADDRINUSE" ? new Error(`Port ${port} is already in use.`) : err
+      );
+    };
+    server.once("error", onError);
+    server.listen(port, host, () => {
+      server.removeListener("error", onError);
+      const address = server.address();
+      resolveListen(
+        typeof address === "object" && address ? address.port : port
+      );
+    });
+  });
+}
+function contentHash(content) {
+  return createHash("sha256").update(content).digest("base64url").slice(0, 8);
+}
+async function emitHashedAsset(outDir, assetsDir, sourceName, content) {
+  const ext = extname(sourceName);
+  const name = basename(sourceName, ext) || "asset";
+  const fileName = `${assetsDir}/${name}-${contentHash(content)}${ext}`;
+  const target = join(outDir, fileName);
+  await mkdir(dirname(target), { recursive: true });
+  await writeFile(target, content);
+  return fileName;
+}
+async function copyPublicDir(publicDir, outDir) {
+  if (!await isDirectory(publicDir)) return false;
+  try {
+    await cp(publicDir, outDir, { recursive: true });
+    return true;
+  } catch (cause) {
+    throw new BuildError(
+      `Failed to copy public assets from ${publicDir}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+  }
+}
+
+// src/build/css.ts
+var STYLE_RE = /\.(css|scss|sass|less)$/i;
+var MODULE_RE = /\.module\.[^.]+$/i;
+function stripQuery(path) {
+  return path.split("?", 1)[0] ?? path;
+}
+function isStyle(path) {
+  return STYLE_RE.test(stripQuery(path));
+}
+function isCssModule(path) {
+  return MODULE_RE.test(stripQuery(path));
+}
+async function loadPostcss(root) {
+  const { default: load } = await import('postcss-load-config');
+  let config;
+  try {
+    config = await load({}, root);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "";
+    if (/No PostCSS Config found|Cannot find (module|package)/i.test(message)) {
+      return null;
+    }
+    throw new BuildError(`Failed to load PostCSS config: ${message}`, {
+      cause: error
+    });
+  }
+  const { default: postcss } = await import('postcss');
+  const processor = postcss(config.plugins);
+  return async (css, from) => {
+    const result = await processor.process(css, { ...config.options, from });
+    return result.css;
+  };
+}
+async function importOptional(name, forExt) {
+  try {
+    return await import(name);
+  } catch {
+    throw new BuildError(
+      `"${name}" is required to compile ${forExt} files. Install it (e.g. \`pnpm add -D ${name}\`).`
+    );
+  }
+}
+async function preprocess(file, ext) {
+  if (ext === ".scss" || ext === ".sass") {
+    const sass = await importOptional("sass", ".scss/.sass");
+    return sass.compile(file, { style: "expanded" }).css;
+  }
+  if (ext === ".less") {
+    const less = (await importOptional("less", ".less")).default;
+    const out = await less.render(await readFile(file, "utf8"), { filename: file });
+    return out.css;
+  }
+  return readFile(file, "utf8");
+}
+async function processStyle(file, options) {
+  const clean = stripQuery(file);
+  let result;
+  try {
+    result = await bundleAsync({
+      filename: clean,
+      minify: options.minify,
+      analyzeDependencies: true,
+      cssModules: isCssModule(clean),
+      resolver: {
+        read: async (filePath) => {
+          let css2 = await preprocess(filePath, extname(filePath).toLowerCase());
+          if (options.postcss) css2 = await options.postcss(css2, filePath);
+          return css2;
+        },
+        resolve: (specifier, from) => resolve(dirname(from), specifier)
+      }
+    });
+  } catch (error) {
+    throw new BuildError(
+      `Failed to process ${basename(clean)}: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+  let css = result.code.toString();
+  for (const dep of result.dependencies ?? []) {
+    if (dep.type === "url") {
+      const fromDir = dirname(dep.loc.filePath);
+      const target = await resolveStyleUrl(dep.url, fromDir, options.paths);
+      if (target) {
+        const fileName = await emitHashedAsset(
+          options.outDir,
+          options.assetsDir,
+          basename(target),
+          await readFile(target)
+        );
+        css = css.replaceAll(dep.placeholder, `${options.base}${fileName}`);
+      } else {
+        css = css.replaceAll(dep.placeholder, dep.url);
+      }
+    } else if (dep.type === "import") {
+      css = css.replaceAll(dep.placeholder, dep.url);
+    }
+  }
+  const exports = result.exports ? Object.fromEntries(
+    Object.entries(result.exports).map(([key, value]) => [key, value.name])
+  ) : void 0;
+  return exports ? { css, exports } : { css };
+}
+async function resolveStyleUrl(url, fromDir, paths) {
+  if (/^(?:[a-z]+:)?\/\//i.test(url) || /^(?:data:|#)/i.test(url) || url.startsWith("/")) {
+    return null;
+  }
+  const candidate = resolve(fromDir, url.split(/[?#]/, 1)[0] ?? url);
+  const real = await realpath(candidate).catch(() => null);
+  if (!real) return null;
+  const root = await realpath(paths.rootDir).catch(() => paths.rootDir);
+  return real === root || real.startsWith(root + sep) ? real : null;
+}
+function cssLoaderSnippet(href) {
+  const h = JSON.stringify(href);
+  return `(function(){try{var d=document;if(!d.querySelector('link[href='+JSON.stringify(${h})+']')){var l=d.createElement("link");l.rel="stylesheet";l.href=${h};d.head.appendChild(l);}}catch(e){}})();`;
+}
+function cssPlugin(options, cssByEntry) {
+  const cssByModule = /* @__PURE__ */ new Map();
+  return {
+    name: "vantris:css",
+    async load(id) {
+      const file = stripQuery(id);
+      if (!isStyle(file)) return null;
+      const { css, exports } = await processStyle(file, options);
+      cssByModule.set(id, css);
+      const code = exports ? `export default ${JSON.stringify(exports)};` : "export default {};";
+      return { code, moduleType: "js", moduleSideEffects: "no-treeshake" };
+    },
+    async generateBundle(_outputOptions, bundle2) {
+      for (const fileName of Object.keys(bundle2)) {
+        const chunk = bundle2[fileName];
+        if (!chunk || chunk.type !== "chunk") continue;
+        const css = chunk.moduleIds.filter((moduleId) => cssByModule.has(moduleId)).map((moduleId) => cssByModule.get(moduleId)).join("\n");
+        if (!css) continue;
+        const cssFile = await emitHashedAsset(
+          options.outDir,
+          options.assetsDir,
+          `${chunk.name}.css`,
+          css
+        );
+        if (chunk.isEntry) {
+          cssByEntry.set(chunk.name, cssFile);
+        } else {
+          chunk.code = cssLoaderSnippet(`${options.base}${cssFile}`) + chunk.code;
+        }
+      }
+    }
+  };
+}
+
+// src/build/bundle.ts
+var ASSET_EXTENSION_SET = new Set(ASSET_EXTENSIONS);
+async function bundle(input) {
+  const { entries, config } = input;
+  const { paths, build: build2 } = config;
+  const cssByEntry = /* @__PURE__ */ new Map();
+  const styleOptions = {
+    paths,
+    outDir: paths.outDir,
+    assetsDir: build2.assetsDir,
+    base: config.base,
+    minify: build2.minify,
+    postcss: input.postcss ?? null
+  };
+  const inputOptions = {
+    input: entries,
+    cwd: paths.root,
+    platform: "browser",
+    // Images/fonts/media imported from JS become hashed assets with absolute
+    // URLs from `base`; the CSS plugin handles styles (modules, url(), lazy).
+    plugins: [assetUrlPlugin(config.base), cssPlugin(styleOptions, cssByEntry)]
+    // Tree shaking is enabled by default.
+  };
+  const outputOptions = {
+    dir: paths.outDir,
+    format: "es",
+    minify: build2.minify,
+    sourcemap: build2.sourcemap,
+    entryFileNames: toChunkNames(build2.entryFileNames),
+    chunkFileNames: toChunkNames(build2.chunkFileNames),
+    assetFileNames: toAssetNames(build2.assetFileNames)
+  };
+  let result;
+  try {
+    const bundler = await rolldown(inputOptions);
+    try {
+      result = await bundler.write(outputOptions);
+    } finally {
+      await bundler.close();
+    }
+  } catch (cause) {
+    throw new BuildError(
+      `Bundling failed: ${cause instanceof Error ? cause.message : String(cause)}`,
+      { cause }
+    );
+  }
+  const hasEntry = result.output.some(
+    (item) => item.type === "chunk" && item.isEntry
+  );
+  if (!hasEntry) {
+    throw new BuildError("Bundler produced no entry chunk.");
+  }
+  return { output: result.output, cssByEntry };
+}
+function entryFileName(output, name) {
+  const chunk = output.find(
+    (item) => item.type === "chunk" && item.isEntry && item.name === name
+  );
+  if (!chunk) {
+    throw new BuildError(`No output chunk produced for entry "${name}".`);
+  }
+  return chunk.fileName;
+}
+function toChunkNames(value) {
+  if (typeof value === "string") return value;
+  return (chunk) => value({
+    name: chunk.name,
+    isEntry: chunk.isEntry,
+    isDynamicEntry: chunk.isDynamicEntry,
+    facadeModuleId: chunk.facadeModuleId ?? null,
+    moduleIds: chunk.moduleIds,
+    exports: chunk.exports
+  });
+}
+function toAssetNames(value) {
+  if (typeof value === "string") return value;
+  return (asset) => value({
+    names: asset.names,
+    originalFileNames: asset.originalFileNames
+  });
+}
+function assetUrlPlugin(base) {
+  const tokens = /* @__PURE__ */ new Map();
+  return {
+    name: "vantris:asset-urls",
+    async load(id) {
+      const file = id.split("?", 1)[0] ?? id;
+      if (!ASSET_EXTENSION_SET.has(extname(file).toLowerCase())) return null;
+      const referenceId = this.emitFile({
+        type: "asset",
+        name: basename(file),
+        originalFileName: file,
+        source: await readFile(file)
+      });
+      const token = `__VANTRIS_ASSET_${referenceId}__`;
+      tokens.set(token, referenceId);
+      return `export default ${JSON.stringify(token)};`;
+    },
+    renderChunk(code) {
+      const magic = new MagicString(code);
+      let changed = false;
+      for (const [token, referenceId] of tokens) {
+        const url = `${base}${this.getFileName(referenceId)}`;
+        for (let index = code.indexOf(token); index !== -1; index = code.indexOf(token, index + token.length)) {
+          magic.update(index, index + token.length, url);
+          changed = true;
+        }
+      }
+      return changed ? { code: magic.toString(), map: magic.generateMap({ hires: true }) } : null;
+    }
+  };
+}
+function resolveHtmlEntries(entry, paths) {
+  if (entry.scripts.length === 0) {
+    throw new BuildError(
+      `No <script type="module" src="..."> found in ${entry.file}.`
+    );
+  }
+  const used = /* @__PURE__ */ new Set();
+  return entry.scripts.map((script) => {
+    const entryFile = resolve(paths.root, script.src.replace(/^\/+/, ""));
+    const base = basename(script.src).replace(/\.[^.]+$/, "") || "entry";
+    let name = base;
+    for (let i = 1; used.has(name); i++) name = `${base}${i}`;
+    used.add(name);
+    return { name, entryFile, entrySrc: script.src };
+  });
+}
+function renderProductionHtml(html, replacements) {
+  let out = html;
+  for (const { from, to } of replacements) out = out.replaceAll(from, to);
+  return out;
+}
+var HTML_URL_REF = /<(?:link|img|script|source|use)\b[^>]*?\b(?:href|src|xlink:href)\s*=\s*(?:"([^"]*)"|'([^']*)')/gi;
+function collectAssetRefs(html) {
+  const urls = /* @__PURE__ */ new Set();
+  for (const match of html.matchAll(HTML_URL_REF)) {
+    const url = match[1] ?? match[2];
+    if (url) urls.add(url);
+  }
+  return [...urls];
+}
+function resolveSourceRef(url, paths) {
+  if (/^(?:[a-z]+:)?\/\//i.test(url) || /^(?:data:|#|mailto:)/i.test(url)) {
+    return null;
+  }
+  const file = resolve(paths.root, url.replace(/^\/+/, ""));
+  const withinRoot = file === paths.rootDir || file.startsWith(paths.rootDir + sep);
+  return withinRoot ? file : null;
+}
+function injectStylesheets(html, hrefs) {
+  if (hrefs.length === 0) return html;
+  const links = hrefs.map((href) => `<link rel="stylesheet" href="${href}">`).join("\n");
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${links}
+</head>`);
+  }
+  const bodyOpen = /<body[^>]*>/.exec(html);
+  if (bodyOpen) {
+    return html.replace(bodyOpen[0], `${bodyOpen[0]}
+${links}`);
+  }
+  return `${links}
+${html}`;
+}
+async function cleanOutDir(outDir) {
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir(outDir, { recursive: true });
+}
+async function writeHtml(outDir, html) {
+  const file = join(outDir, HTML_ENTRY_FILENAME);
+  await writeFile(file, html, "utf8");
+  return file;
+}
+
+// src/build/index.ts
+async function runBuild(options) {
+  const { ctx, entry } = options;
+  const { paths, build: build2 } = ctx.config;
+  const log = ctx.logger;
+  const started = Date.now();
+  const rel2 = (p) => relative(paths.root, p) || ".";
+  log.info("building for production\u2026");
+  if (!entry) {
+    throw new HtmlEntryError(
+      `No index.html found at ${paths.root}; nothing to build.`
+    );
+  }
+  const htmlEntries = resolveHtmlEntries(entry, paths);
+  for (const { entryFile, entrySrc } of htmlEntries) {
+    if (!await isFile(entryFile)) {
+      throw new BuildError(
+        `Entry module "${entrySrc}" resolves to a missing file: ${entryFile}`
+      );
+    }
+  }
+  assertSafeOutDir(paths.outDir, paths.root, paths.rootDir, paths.publicDir);
+  log.info(`cleaning ${rel2(paths.outDir)}${sep}`);
+  await cleanOutDir(paths.outDir);
+  const inputs = Object.fromEntries(
+    htmlEntries.map((e) => [e.name, e.entryFile])
+  );
+  const postcss = await loadPostcss(paths.root);
+  log.info(
+    `bundling ${htmlEntries.length} entr${htmlEntries.length === 1 ? "y" : "ies"} with Rolldown\u2026`
+  );
+  const { output, cssByEntry } = await bundle({
+    entries: inputs,
+    config: ctx.config,
+    postcss
+  });
+  log.info(
+    `bundled ${output.length} file(s)` + (build2.minify ? " (minified)" : "") + (build2.sourcemap ? " + sourcemaps" : "")
+  );
+  if (await copyPublicDir(paths.publicDir, paths.outDir)) {
+    log.info(`copied ${rel2(paths.publicDir)}${sep} \u2192 ${rel2(paths.outDir)}${sep}`);
+    if (await isFile(join(paths.publicDir, HTML_ENTRY_FILENAME))) {
+      log.warn(
+        `public/${HTML_ENTRY_FILENAME} is ignored \u2014 the generated entry HTML takes precedence.`
+      );
+    }
+  }
+  const base = ctx.config.base;
+  const url = (fileName) => `${base}${fileName}`;
+  const replacements = [];
+  const entrySrcs = new Set(htmlEntries.map((e) => e.entrySrc));
+  const entries = htmlEntries.map((e) => {
+    const fileName = entryFileName(output, e.name);
+    replacements.push({ from: e.entrySrc, to: url(fileName) });
+    return { src: e.entrySrc, fileName };
+  });
+  const stylesheets = [];
+  for (const e of htmlEntries) {
+    const cssFile = cssByEntry.get(e.name);
+    if (cssFile) stylesheets.push(url(cssFile));
+  }
+  const styleOptions = {
+    paths,
+    outDir: paths.outDir,
+    assetsDir: build2.assetsDir,
+    base,
+    minify: build2.minify,
+    postcss
+  };
+  let assetCount = 0;
+  for (const ref of collectAssetRefs(entry.html)) {
+    if (entrySrcs.has(ref)) continue;
+    const file = resolveSourceRef(ref, paths);
+    if (!file || !await isFile(file)) continue;
+    let fileName;
+    if (isStyle(file)) {
+      const { css } = await processStyle(file, styleOptions);
+      const name = basename(file).replace(/\.(scss|sass|less|styl|stylus)$/i, ".css");
+      fileName = await emitHashedAsset(paths.outDir, build2.assetsDir, name, css);
+    } else {
+      fileName = await emitHashedAsset(
+        paths.outDir,
+        build2.assetsDir,
+        basename(file),
+        await readFile(file)
+      );
+    }
+    replacements.push({ from: ref, to: url(fileName) });
+    assetCount += 1;
+  }
+  let html = renderProductionHtml(entry.html, replacements);
+  html = injectStylesheets(html, stylesheets);
+  await writeHtml(paths.outDir, html);
+  if (stylesheets.length > 0) log.info(`css: ${stylesheets.length} stylesheet(s)`);
+  if (assetCount > 0) log.info(`html assets: ${assetCount} rewritten from rootDir`);
+  const durationMs = Date.now() - started;
+  const fileCount = output.length + 1 + stylesheets.length + assetCount;
+  log.info(`build complete in ${durationMs}ms \u2014 ${fileCount} files in ${rel2(paths.outDir)}${sep}`);
+  return { outDir: paths.outDir, entries, durationMs, fileCount };
+}
+function assertSafeOutDir(outDir, root, rootDir, publicDir) {
+  const clashes = outDir === root || outDir === rootDir || outDir === publicDir;
+  const isAncestorOfRoot = root === outDir || root.startsWith(outDir + sep);
+  if (clashes || isAncestorOfRoot) {
+    throw new BuildError(
+      `Refusing to clean outDir "${outDir}": it overlaps the project root or source directories.`
+    );
+  }
+}
+
+// src/shared/logger.ts
+var prefix = `[${APP_NAME}]`;
+function createLogger(options = {}) {
+  const { verbose = false, sink = console } = options;
+  return {
+    info(message) {
+      sink.log(`${prefix} ${message}`);
+    },
+    warn(message) {
+      sink.warn(`${prefix} ${message}`);
+    },
+    error(message) {
+      sink.error(`${prefix} ${message}`);
+    },
+    debug(message) {
+      if (verbose) sink.log(`${prefix} ${message}`);
+    }
+  };
+}
+
+// src/shared/context.ts
+async function createContext(options) {
+  const { cwd, logger } = options;
+  const loaded = await loadConfig({
+    cwd,
+    logger,
+    ...options.configFile !== void 0 ? { configFile: options.configFile } : {}
+  });
+  const config = resolveConfig(loaded.config, cwd, loaded.file);
+  return { cwd, config, logger };
+}
+function createWatcher(options) {
+  const { dir, logger, onChange } = options;
+  const watcher = watch(dir, {
+    ignoreInitial: true,
+    persistent: true,
+    ignored: (path) => path.includes("node_modules") || /(^|[/\\])\.[^/\\]/.test(path)
+  });
+  const emit = (kind) => (file) => {
+    logger.debug(`watch ${kind}: ${file}`);
+    onChange({ kind, file });
+  };
+  watcher.on("add", emit("add")).on("change", emit("change")).on("unlink", emit("unlink")).on(
+    "error",
+    (error) => logger.error(`watcher error: ${error.message}`)
+  );
+  return {
+    close: () => watcher.close()
+  };
+}
+function rel(ctx, target) {
+  return relative(ctx.config.paths.root, target) || ".";
+}
+async function inspectProject(ctx) {
+  const { paths, configFile } = ctx.config;
+  ctx.logger.info(
+    `config: ${configFile ? rel(ctx, configFile) : "defaults (no config file)"}`
+  );
+  ctx.logger.info(`rootDir:   ${rel(ctx, paths.rootDir)}`);
+  ctx.logger.info(`publicDir: ${rel(ctx, paths.publicDir)}`);
+  ctx.logger.info(`outDir:    ${rel(ctx, paths.outDir)}`);
+  const entry = await detectHtmlEntry(paths.root);
+  if (entry) {
+    ctx.logger.info(`html entry: ${rel(ctx, entry.file)}`);
+  } else {
+    ctx.logger.warn(
+      "no index.html found at the project root; nothing to serve yet."
+    );
+  }
+  return entry;
+}
+async function prepareDirectories(ctx, dirs) {
+  for (const dir of dirs) {
+    await ensureDir(dir);
+    ctx.logger.debug(`prepared directory: ${dir}`);
+  }
+}
+
+// src/commands/dev.ts
+var RELOAD_DEBOUNCE_MS = 50;
+var dev = {
+  name: "dev",
+  description: "Start the development server",
+  async run(ctx) {
+    const { root, rootDir, publicDir } = ctx.config.paths;
+    await prepareDirectories(ctx, [rootDir, publicDir]);
+    const entry = await inspectProject(ctx);
+    const server = await startDevServer({ ctx, entry });
+    ctx.logger.info(`ready \u2014 dev server running at ${server.url}`);
+    let timer;
+    const watcher = createWatcher({
+      dir: rootDir,
+      logger: ctx.logger,
+      onChange: ({ kind, file }) => {
+        ctx.logger.info(`${kind}: ${relative(root, file)} \u2014 reloading`);
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => server.broadcastReload(), RELOAD_DEBOUNCE_MS);
+      }
+    });
+    await waitForShutdown();
+    ctx.logger.info("shutting down\u2026");
+    if (timer) clearTimeout(timer);
+    await watcher.close();
+    await server.close();
+  }
+};
+function waitForShutdown() {
+  return new Promise((resolve5) => {
+    const onSignal = () => {
+      process.removeListener("SIGINT", onSignal);
+      process.removeListener("SIGTERM", onSignal);
+      resolve5();
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+  });
+}
+
+// src/commands/build.ts
+var build = {
+  name: "build",
+  description: "Build the project for production",
+  async run(ctx) {
+    const entry = await inspectProject(ctx);
+    await runBuild({ ctx, entry });
+  }
+};
+
+// src/preview/index.ts
+async function runPreview(options) {
+  const { ctx } = options;
+  ctx.logger.info(
+    "preview is not implemented in v0.1.0 (planned: static server over outDir)."
+  );
+}
+
+// src/commands/preview.ts
+var preview = {
+  name: "preview",
+  description: "Locally preview a production build",
+  async run(ctx) {
+    await prepareDirectories(ctx, [ctx.config.paths.outDir]);
+    await inspectProject(ctx);
+    await runPreview({ ctx });
+  }
+};
+
+// src/commands/index.ts
+var commands = {
+  [dev.name]: dev,
+  [build.name]: build,
+  [preview.name]: preview
+};
+
+// src/cli/help.ts
+function helpText() {
+  const lines = [
+    `${APP_NAME} v${VERSION} \u2014 a modern bundler for JavaScript/TypeScript`,
+    "",
+    "Usage:",
+    `  ${APP_NAME} <command> [options]`,
+    "",
+    "Commands:"
+  ];
+  const width = Math.max(...Object.keys(commands).map((n) => n.length));
+  for (const command of Object.values(commands)) {
+    lines.push(`  ${command.name.padEnd(width)}  ${command.description}`);
+  }
+  lines.push(
+    "",
+    "Options:",
+    "  -h, --help     Show this help",
+    "  -v, --version  Show the version number"
+  );
+  return lines.join("\n");
+}
+function versionText() {
+  return `${APP_NAME} v${VERSION}`;
+}
+
+// src/cli/run.ts
+async function run(argv, options = {}) {
+  const verbose = argv.includes("--verbose") || argv.includes("--debug");
+  const logger = options.logger ?? createLogger({ verbose });
+  const cwd = options.cwd ?? process.cwd();
+  const [first, ...rest] = argv.filter((arg) => !isGlobalFlag(arg));
+  if (!first || first === "--help" || first === "-h" || first === "help") {
+    logger.info(helpText());
+    return 0 /* Ok */;
+  }
+  if (first === "--version" || first === "-v") {
+    logger.info(versionText());
+    return 0 /* Ok */;
+  }
+  const command = commands[first];
+  if (!command) {
+    logger.error(`Unknown command: "${first}"`);
+    logger.info(helpText());
+    return 1 /* Error */;
+  }
+  const ctx = await createContext({ cwd, logger });
+  await command.run(ctx, rest);
+  return 0 /* Ok */;
+}
+function isGlobalFlag(arg) {
+  return arg === "--verbose" || arg === "--debug";
+}
+
+export { BuildError, ConfigError, DEV_CLIENT_SCRIPT, HtmlEntryError, NotImplementedError, VERSION, VantrisError, commands, createContext, createLogger, createWatcher, detectHtmlEntry, injectDevClient, isVantrisError, loadConfig, parseHtml, resolveConfig, run, runBuild, startDevServer };
+//# sourceMappingURL=chunk-LRSN7SF4.js.map
+//# sourceMappingURL=chunk-LRSN7SF4.js.map