elit 3.6.5 → 3.6.7

package/dist/preview-build.cjs

@@ -0,0 +1,712 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/preview-build/index.ts
+var preview_build_exports = {};
+__export(preview_build_exports, {
+  buildStandalonePreviewServer: () => buildStandalonePreviewServer,
+  createInlineConfigSource: () => createInlineConfigSource,
+  createStandalonePreviewEntrySource: () => createStandalonePreviewEntrySource,
+  createWorkspacePackagePlugin: () => createWorkspacePackagePlugin,
+  normalizeImportPath: () => normalizeImportPath,
+  normalizeRelativePath: () => normalizeRelativePath,
+  resolveStandalonePreviewBuildPlan: () => resolveStandalonePreviewBuildPlan,
+  writeStandalonePackageJson: () => writeStandalonePackageJson
+});
+module.exports = __toCommonJS(preview_build_exports);
+
+// src/shares/runtime.ts
+var runtime = (() => {
+  if (typeof Deno !== "undefined") return "deno";
+  if (typeof Bun !== "undefined") return "bun";
+  return "node";
+})();
+var isNode = runtime === "node";
+var isBun = runtime === "bun";
+var isDeno = runtime === "deno";
+
+// src/server/fs/node-modules.ts
+var fs;
+var fsPromises;
+if (isNode || isBun) {
+  fs = require("fs");
+  fsPromises = require("fs/promises");
+}
+
+// src/server/fs/utils.ts
+function parseOptions(options, defaultValue) {
+  return typeof options === "string" ? { encoding: options } : options || defaultValue;
+}
+function decodeContent(content, encoding) {
+  if (encoding) {
+    return new TextDecoder(encoding).decode(content);
+  }
+  return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
+}
+function dataToUint8Array(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Buffer) {
+    return new Uint8Array(data);
+  }
+  return data;
+}
+function createStatsFromDenoFileInfo(info) {
+  return {
+    isFile: () => info.isFile,
+    isDirectory: () => info.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => info.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: info.dev || 0,
+    ino: info.ino || 0,
+    mode: info.mode || 0,
+    nlink: info.nlink || 1,
+    uid: info.uid || 0,
+    gid: info.gid || 0,
+    rdev: 0,
+    size: info.size,
+    blksize: info.blksize || 4096,
+    blocks: info.blocks || Math.ceil(info.size / 512),
+    atimeMs: info.atime?.getTime() || Date.now(),
+    mtimeMs: info.mtime?.getTime() || Date.now(),
+    ctimeMs: info.birthtime?.getTime() || Date.now(),
+    birthtimeMs: info.birthtime?.getTime() || Date.now(),
+    atime: info.atime || /* @__PURE__ */ new Date(),
+    mtime: info.mtime || /* @__PURE__ */ new Date(),
+    ctime: info.birthtime || /* @__PURE__ */ new Date(),
+    birthtime: info.birthtime || /* @__PURE__ */ new Date()
+  };
+}
+
+// src/server/fs/file-ops.ts
+function readFileSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode || isBun) {
+    return fs.readFileSync(path, opts);
+  } else if (isDeno) {
+    const content = Deno.readFileSync(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+function writeFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode || isBun) {
+    fs.writeFileSync(path, data, opts);
+  } else if (isDeno) {
+    Deno.writeFileSync(path, dataToUint8Array(data));
+  }
+}
+function existsSync(path) {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function statSync(path) {
+  if (isNode || isBun) {
+    return fs.statSync(path);
+  } else if (isDeno) {
+    const info = Deno.statSync(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+
+// src/server/fs/directory-ops.ts
+function mkdirSync(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode || isBun) {
+    fs.mkdirSync(path, opts);
+  } else if (isDeno) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  }
+}
+
+// src/server/path/platform.ts
+function getSeparator(isWin) {
+  return isWin ? "\\" : "/";
+}
+function getCwd() {
+  if (isNode || isBun) {
+    return process.cwd();
+  }
+  if (isDeno) {
+    return Deno.cwd();
+  }
+  return "/";
+}
+var isWindows = (() => {
+  if (isNode) {
+    return process.platform === "win32";
+  }
+  if (isDeno) {
+    return Deno.build.os === "windows";
+  }
+  return typeof process !== "undefined" && process.platform === "win32";
+})();
+
+// src/server/path/operations.ts
+function findLastSeparator(path) {
+  return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+}
+function isAbsolutePosix(path) {
+  return path.length > 0 && path[0] === "/";
+}
+function isAbsoluteWin(path) {
+  const len = path.length;
+  if (len === 0) return false;
+  const code = path.charCodeAt(0);
+  if (code === 47 || code === 92) {
+    return true;
+  }
+  if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+    if (len > 2 && path.charCodeAt(1) === 58) {
+      const code2 = path.charCodeAt(2);
+      if (code2 === 47 || code2 === 92) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function normalizePath(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const isAbsolute = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
+  const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
+  const normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const parts = normalized.split(separator);
+  const result = [];
+  for (let index = 0; index < parts.length; index++) {
+    const part = parts[index];
+    if (part === "" || part === ".") {
+      if (index === 0 && isAbsolute) result.push("");
+      continue;
+    }
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        if (!(result.length === 1 && result[0] === "")) {
+          result.pop();
+        }
+      } else if (!isAbsolute) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let finalPath = result.join(separator);
+  if (finalPath.length === 0) {
+    return isAbsolute ? separator : ".";
+  }
+  if (trailingSeparator && finalPath[finalPath.length - 1] !== separator) {
+    finalPath += separator;
+  }
+  return finalPath;
+}
+function joinPaths(paths, isWin) {
+  if (paths.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  let joined = "";
+  for (let index = 0; index < paths.length; index++) {
+    const path = paths[index];
+    if (path && path.length > 0) {
+      if (joined.length === 0) {
+        joined = path;
+      } else {
+        joined += separator + path;
+      }
+    }
+  }
+  if (joined.length === 0) return ".";
+  return normalizePath(joined, isWin);
+}
+function resolvePaths(paths, isWin) {
+  const separator = getSeparator(isWin);
+  let resolved = "";
+  let absolute = false;
+  for (let index = paths.length - 1; index >= 0 && !absolute; index--) {
+    const path = paths[index];
+    if (path && path.length > 0) {
+      resolved = path + (resolved.length > 0 ? separator + resolved : "");
+      absolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+    }
+  }
+  if (!absolute) {
+    const cwd = getCwd();
+    resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+  }
+  return normalizePath(resolved, isWin);
+}
+function relativePath(from, to, isWin) {
+  const resolvedFrom = resolvePaths([from], isWin);
+  const resolvedTo = resolvePaths([to], isWin);
+  if (resolvedFrom === resolvedTo) return "";
+  const separator = getSeparator(isWin);
+  const fromParts = resolvedFrom.split(separator).filter((part) => part.length > 0);
+  const toParts = resolvedTo.split(separator).filter((part) => part.length > 0);
+  const minLength = Math.min(fromParts.length, toParts.length);
+  let commonLength = 0;
+  for (let index = 0; index < minLength; index++) {
+    if (fromParts[index] === toParts[index]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const result = [];
+  const upCount = fromParts.length - commonLength;
+  for (let index = 0; index < upCount; index++) {
+    result.push("..");
+  }
+  for (let index = commonLength; index < toParts.length; index++) {
+    result.push(toParts[index]);
+  }
+  return result.join(separator) || ".";
+}
+function getDirname(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const normalized = normalizePath(path, isWin);
+  const lastSeparatorIndex = normalized.lastIndexOf(separator);
+  if (lastSeparatorIndex === -1) return ".";
+  if (lastSeparatorIndex === 0) return separator;
+  return normalized.slice(0, lastSeparatorIndex);
+}
+function getBasename(path, ext, isWin) {
+  if (path.length === 0) return "";
+  const lastSeparatorIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+  let base = lastSeparatorIndex === -1 ? path : path.slice(lastSeparatorIndex + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function getExtname(path) {
+  const lastDotIndex = path.lastIndexOf(".");
+  const lastSeparatorIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSeparatorIndex || lastDotIndex === path.length - 1) {
+    return "";
+  }
+  return path.slice(lastDotIndex);
+}
+function parsePath(path, isWin) {
+  let root = "";
+  if (isWin) {
+    if (path.length >= 2 && path[1] === ":") {
+      root = path.slice(0, 2);
+      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+        root += "\\";
+      }
+    } else if (path[0] === "\\" || path[0] === "/") {
+      root = "\\";
+    }
+  } else if (path[0] === "/") {
+    root = "/";
+  }
+  const dir = getDirname(path, isWin);
+  const base = getBasename(path, void 0, isWin);
+  const ext = getExtname(path);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+function formatPath(pathObject, isWin) {
+  const separator = getSeparator(isWin);
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + separator + base;
+}
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path) => normalizePath(path, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path) => getDirname(path, isWin),
+    basename: (path, ext) => getBasename(path, ext, isWin),
+    extname: (path) => getExtname(path),
+    parse: (path) => parsePath(path, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+
+// src/server/path/index.ts
+var posix = createPathOps(false);
+var win32 = createPathOps(true);
+function join(...paths) {
+  return joinPaths(paths, isWindows);
+}
+function resolve(...paths) {
+  return resolvePaths(paths, isWindows);
+}
+function relative(from, to) {
+  return relativePath(from, to, isWindows);
+}
+function dirname(path) {
+  return getDirname(path, isWindows);
+}
+function basename(path, ext) {
+  return getBasename(path, ext, isWindows);
+}
+function extname(path) {
+  return getExtname(path);
+}
+
+// src/shares/workspace-package/package-json.ts
+function readPackageJson(filePath) {
+  try {
+    const packageJsonBuffer = readFileSync(filePath, "utf-8");
+    const packageJsonText = typeof packageJsonBuffer === "string" ? packageJsonBuffer : packageJsonBuffer.toString("utf-8");
+    return JSON.parse(packageJsonText);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/shares/workspace-package/roots.ts
+function findPackageDirectory(startDir, resolveMatch) {
+  let currentDir = resolve(startDir);
+  while (true) {
+    const match = resolveMatch(currentDir);
+    if (match) {
+      return match;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function findWorkspacePackageRoot(startDir, packageName) {
+  return findPackageDirectory(startDir, (currentDir) => {
+    const packageJsonPath = join(currentDir, "package.json");
+    const packageJson = existsSync(packageJsonPath) ? readPackageJson(packageJsonPath) : void 0;
+    return packageJson?.name === packageName ? currentDir : void 0;
+  });
+}
+function findInstalledPackageRoot(startDir, packageName) {
+  return findPackageDirectory(startDir, (currentDir) => {
+    const candidate = join(currentDir, "node_modules", ...packageName.split("/"));
+    return existsSync(candidate) ? candidate : void 0;
+  });
+}
+
+// src/shares/workspace-package/candidates.ts
+function getWorkspacePackageImportCandidates(packageRoot, specifier, options = {}) {
+  const subpath = specifier === "elit" ? "index" : specifier.slice("elit/".length);
+  const builtCandidates = options.preferredBuiltFormat === "cjs" ? [
+    resolve(packageRoot, "dist", `${subpath}.cjs`),
+    resolve(packageRoot, "dist", `${subpath}.js`),
+    resolve(packageRoot, "dist", `${subpath}.mjs`)
+  ] : [
+    resolve(packageRoot, "dist", `${subpath}.mjs`),
+    resolve(packageRoot, "dist", `${subpath}.js`),
+    resolve(packageRoot, "dist", `${subpath}.cjs`)
+  ];
+  const sourceCandidates = [
+    resolve(packageRoot, "src", `${subpath}.ts`),
+    resolve(packageRoot, "src", `${subpath}.tsx`)
+  ];
+  return options.preferBuilt ? [...builtCandidates, ...sourceCandidates] : [...sourceCandidates, ...builtCandidates];
+}
+
+// src/shares/workspace-package/resolve.ts
+function isWorkspacePackageSpecifier(specifier) {
+  return specifier === "elit" || specifier.startsWith("elit/");
+}
+function resolveWorkspacePackageImport(specifier, startDir, options = {}) {
+  if (!isWorkspacePackageSpecifier(specifier)) {
+    return void 0;
+  }
+  const packageRoots = /* @__PURE__ */ new Set();
+  const workspacePackageRoot = findWorkspacePackageRoot(startDir, "elit");
+  const installedPackageRoot = findInstalledPackageRoot(startDir, "elit");
+  if (workspacePackageRoot) {
+    packageRoots.add(workspacePackageRoot);
+  }
+  if (installedPackageRoot) {
+    packageRoots.add(installedPackageRoot);
+  }
+  for (const packageRoot of packageRoots) {
+    for (const candidate of getWorkspacePackageImportCandidates(packageRoot, specifier, options)) {
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/preview-build/helpers.ts
+function normalizePackageDependencies(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const dependencies = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (typeof entryValue === "string") {
+      dependencies[key] = entryValue;
+    }
+  }
+  return dependencies;
+}
+function readJsonFile(filePath) {
+  try {
+    const rawContent = readFileSync(filePath, "utf-8");
+    const content = typeof rawContent === "string" ? rawContent : rawContent.toString("utf-8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+function createWorkspacePackagePlugin(resolveDir, options = {}) {
+  return {
+    name: "workspace-package-self-reference",
+    setup(build) {
+      build.onResolve({ filter: /^elit(?:\/.*)?$/ }, (args) => {
+        const resolved = resolveWorkspacePackageImport(args.path, args.resolveDir || resolveDir, options);
+        return resolved ? { path: resolved } : void 0;
+      });
+    }
+  };
+}
+function normalizeRelativePath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized === "" ? "." : normalized;
+}
+function normalizeImportPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function createInlineConfigSource(config) {
+  const entries = Object.entries(config).filter(([, value]) => value !== void 0);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  return `{ ${entries.map(([key, value]) => `${JSON.stringify(key)}: ${JSON.stringify(value)}`).join(", ")} }`;
+}
+function writeStandalonePackageJson(packageJsonPath, outputFile, options = {}) {
+  const currentPackageJson = existsSync(packageJsonPath) ? readJsonFile(packageJsonPath) : void 0;
+  const basePackageJson = options.replaceDependencies && currentPackageJson ? Object.fromEntries(Object.entries(currentPackageJson).filter(([key]) => key !== "dependencies")) : currentPackageJson ?? {};
+  const dependencies = options.replaceDependencies ? { ...options.dependencies ?? {} } : {
+    ...normalizePackageDependencies(currentPackageJson?.dependencies),
+    ...options.dependencies ?? {}
+  };
+  const nextPackageJson = {
+    ...basePackageJson,
+    ...Object.keys(dependencies).length > 0 ? { dependencies } : {},
+    private: true,
+    type: "commonjs",
+    main: outputFile
+  };
+  writeFileSync(packageJsonPath, `${JSON.stringify(nextPackageJson, null, 2)}
+`);
+}
+
+// src/preview-build/entry-source.ts
+function createStandalonePreviewEntrySource(configPath, plan, previewConfig) {
+  const configImportBlock = configPath ? `import userConfigModule from ${JSON.stringify(normalizeImportPath(configPath))};
+const resolvedConfig = userConfigModule ?? {};` : "const resolvedConfig = {} as Record<string, any>;";
+  const inlineConfigSource = createInlineConfigSource({
+    port: previewConfig?.port,
+    host: previewConfig?.host,
+    open: previewConfig?.open,
+    logging: previewConfig?.logging,
+    domain: previewConfig?.domain,
+    env: previewConfig?.env,
+    basePath: previewConfig?.basePath,
+    index: previewConfig?.index
+  });
+  const clientArraySource = plan.clients ? `const runtimeClients = [
+${plan.clients.map((client, index) => `  {
+    ...(mergedPreviewConfig.clients?.[${index}] ?? {}),
+    basePath: mergedPreviewConfig.clients?.[${index}]?.basePath ?? ${JSON.stringify(client.basePath)},
+    index: mergedPreviewConfig.clients?.[${index}]?.index ?? ${client.index ? JSON.stringify(client.index) : "undefined"},
+    root: resolve(__dirname, ${JSON.stringify(client.rootRelativePath)}),
+  }`).join(",\n")}
+];` : "";
+  const rootSource = plan.usesClientArray ? "    clients: runtimeClients,\n" : `    root: resolve(__dirname, ${JSON.stringify(plan.rootRelativePath || ".")}),
+    basePath: mergedPreviewConfig.basePath ?? '',
+    index: mergedPreviewConfig.index ?? ${plan.index ? JSON.stringify(plan.index) : "undefined"},
+`;
+  return `import { createDevServer } from 'elit/server';
+import { resolve } from 'node:path';
+
+${configImportBlock}
+
+const inlinePreviewConfig = ${inlineConfigSource};
+const previewConfig = (resolvedConfig as any).preview ?? {};
+const mergedPreviewConfig = { ...previewConfig, ...inlinePreviewConfig };
+${clientArraySource}
+const options = {
+    port: mergedPreviewConfig.port || 4173,
+    host: mergedPreviewConfig.host || 'localhost',
+    open: mergedPreviewConfig.open ?? false,
+    logging: mergedPreviewConfig.logging ?? true,
+    domain: mergedPreviewConfig.domain,
+    api: mergedPreviewConfig.api,
+    ws: mergedPreviewConfig.ws,
+    https: mergedPreviewConfig.https,
+    ssr: mergedPreviewConfig.ssr,
+    proxy: mergedPreviewConfig.proxy,
+    worker: mergedPreviewConfig.worker,
+    env: mergedPreviewConfig.env,
+${rootSource}    mode: 'preview',
+};
+
+const devServer = createDevServer(options);
+
+if (options.logging === false) {
+    const previewUrl = \`http://\${options.host}:\${options.port}\`;
+    console.log(\`[elit] Preview server running at \${previewUrl}\`);
+}
+
+const shutdown = async () => {
+    await devServer.close();
+    process.exit(0);
+};
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+`;
+}
+
+// src/preview-build/plan.ts
+function resolveBuildOutputFile(buildConfig) {
+  if (buildConfig.outFile) {
+    return buildConfig.outFile;
+  }
+  const baseName = basename(buildConfig.entry, extname(buildConfig.entry));
+  const ext = buildConfig.format === "cjs" ? ".cjs" : ".js";
+  return baseName + ext;
+}
+function resolveStandalonePreviewBuildPlan(options) {
+  const cwd = resolve(options.cwd || process.cwd());
+  const previewConfig = options.previewConfig || void 0;
+  const allBuilds = options.allBuilds.length > 0 ? options.allBuilds : [options.buildConfig];
+  const primaryBuild = options.buildConfig;
+  const outputRoot = resolve(cwd, previewConfig?.root || primaryBuild.outDir || allBuilds[0]?.outDir || "dist");
+  const outputFile = options.outFile || previewConfig?.outFile || primaryBuild.standalonePreviewOutFile || "index.js";
+  const outputPath = resolve(join(outputRoot, outputFile));
+  const clientOutputPath = resolve(join(resolve(cwd, primaryBuild.outDir || "dist"), resolveBuildOutputFile(primaryBuild)));
+  if (outputPath === clientOutputPath) {
+    throw new Error(`Standalone preview output ${outputFile} conflicts with the client bundle. Set preview.outFile or --preview-out-file to a different filename.`);
+  }
+  const bundleDir = dirname(outputPath);
+  if (previewConfig?.clients && previewConfig.clients.length > 0) {
+    const clients = previewConfig.clients.map((client, index) => {
+      const buildForClient = allBuilds[index] || primaryBuild;
+      const clientRoot = resolve(cwd, buildForClient.outDir || primaryBuild.outDir || client.root || "dist");
+      return {
+        basePath: client.basePath || "",
+        index: client.index,
+        rootRelativePath: normalizeRelativePath(relative(bundleDir, clientRoot))
+      };
+    });
+    return {
+      clients,
+      outputPath,
+      outputRoot,
+      packageJsonPath: join(outputRoot, "package.json"),
+      usesClientArray: true
+    };
+  }
+  const rootRelativePath = normalizeRelativePath(relative(bundleDir, outputRoot));
+  return {
+    index: previewConfig?.index,
+    outputPath,
+    outputRoot,
+    packageJsonPath: join(outputRoot, "package.json"),
+    rootRelativePath,
+    usesClientArray: false
+  };
+}
+
+// src/preview-build/build.ts
+async function buildStandalonePreviewServer(options) {
+  const cwd = resolve(options.cwd || process.cwd());
+  const plan = resolveStandalonePreviewBuildPlan({
+    ...options,
+    cwd
+  });
+  const outputDir = dirname(plan.outputPath);
+  mkdirSync(outputDir, { recursive: true });
+  const { build } = await import("esbuild");
+  const workspacePackagePlugin = createWorkspacePackagePlugin(cwd, {
+    preferBuilt: true,
+    preferredBuiltFormat: "cjs"
+  });
+  const entrySource = createStandalonePreviewEntrySource(options.configPath, plan, options.previewConfig);
+  await build({
+    stdin: {
+      contents: entrySource,
+      loader: "ts",
+      resolveDir: cwd,
+      sourcefile: "elit-standalone-preview-entry.ts"
+    },
+    bundle: true,
+    outfile: plan.outputPath,
+    format: "cjs",
+    mainFields: ["module", "main"],
+    platform: "node",
+    plugins: [workspacePackagePlugin],
+    external: ["esbuild", "javascript-obfuscator", "open"],
+    sourcemap: false,
+    target: "es2020",
+    logLevel: options.logging === false ? "silent" : "info"
+  });
+  writeStandalonePackageJson(plan.packageJsonPath, basename(plan.outputPath));
+  if (options.logging !== false) {
+    console.log(`  \u2713 Standalone preview server \u2192 ${plan.outputPath}`);
+  }
+  return plan.outputPath;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildStandalonePreviewServer,
+  createInlineConfigSource,
+  createStandalonePreviewEntrySource,
+  createWorkspacePackagePlugin,
+  normalizeImportPath,
+  normalizeRelativePath,
+  resolveStandalonePreviewBuildPlan,
+  writeStandalonePackageJson
+});