elit 3.6.6 → 3.6.7

package/dist/dev-build.mjs

@@ -0,0 +1,797 @@
+import {createRequire as __createRequire} from 'module';const require = __createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// 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 createDirentFromDenoEntry(entry) {
+  return {
+    name: entry.name,
+    isFile: () => entry.isFile,
+    isDirectory: () => entry.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => entry.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false
+  };
+}
+function processDenoEntries(iterator, withFileTypes) {
+  const entries = [];
+  for (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+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 });
+  }
+}
+function readdirSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode || isBun) {
+    return fs.readdirSync(path, opts);
+  } else if (isDeno) {
+    return processDenoEntries(Deno.readDirSync(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+
+// 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/dev-build/plan.ts
+function resolveStandaloneDevBuildPlan(options) {
+  const cwd = resolve(options.cwd || process.cwd());
+  const devConfig = options.devConfig || void 0;
+  const allBuilds = options.allBuilds && options.allBuilds.length > 0 ? options.allBuilds : [options.buildConfig || {}];
+  const primaryBuild = options.buildConfig || allBuilds[0] || {};
+  const outputRoot = resolve(cwd, options.outDir || devConfig?.outDir || "dev-dist");
+  const outputFile = options.outFile || devConfig?.outFile || "index.js";
+  const outputPath = resolve(join(outputRoot, outputFile));
+  const bundleDir = dirname(outputPath);
+  if (devConfig?.clients && devConfig.clients.length > 0) {
+    const clients = devConfig.clients.map((client, index) => {
+      const buildForClient = allBuilds[index] || primaryBuild;
+      return {
+        basePath: client.basePath || "",
+        fallbackRootRelativePath: normalizeRelativePath(relative(bundleDir, resolve(cwd, buildForClient.outDir || "dist"))),
+        index: client.index,
+        rootRelativePath: normalizeRelativePath(relative(bundleDir, resolve(cwd, client.root || ".")))
+      };
+    });
+    return {
+      clients,
+      outputPath,
+      outputRoot,
+      packageJsonPath: join(outputRoot, "package.json"),
+      usesClientArray: true
+    };
+  }
+  const rootRelativePath = normalizeRelativePath(relative(bundleDir, resolve(cwd, devConfig?.root || ".")));
+  const fallbackRootRelativePath = normalizeRelativePath(relative(bundleDir, resolve(cwd, primaryBuild.outDir || "dist")));
+  return {
+    fallbackRootRelativePath,
+    index: devConfig?.index,
+    outputPath,
+    outputRoot,
+    packageJsonPath: join(outputRoot, "package.json"),
+    clients: void 0,
+    rootRelativePath,
+    usesClientArray: false
+  };
+}
+function resolveStandaloneDevFallbackRootRelativePath(plan, options) {
+  if (plan.fallbackRootRelativePath) {
+    return plan.fallbackRootRelativePath;
+  }
+  const cwd = resolve(options.cwd || process.cwd());
+  const primaryBuild = options.buildConfig || options.allBuilds?.[0] || {};
+  return normalizeRelativePath(relative(dirname(plan.outputPath), resolve(cwd, primaryBuild.outDir || "dist")));
+}
+function createStandaloneDevFallbackRootRelativePath(options) {
+  const plan = resolveStandaloneDevBuildPlan(options);
+  return resolveStandaloneDevFallbackRootRelativePath(plan, options);
+}
+
+// src/dev-build/entry-source.ts
+function createStandaloneDevEntrySource(configPath, plan, devConfig, buildOptions) {
+  const fallbackRootRelativePath = resolveStandaloneDevFallbackRootRelativePath(plan, {
+    cwd: buildOptions?.cwd,
+    buildConfig: buildOptions?.buildConfig,
+    allBuilds: buildOptions?.allBuilds
+  });
+  const configImportBlock = configPath ? `import userConfigModule from ${JSON.stringify(normalizeImportPath(configPath))};
+const resolvedConfig = userConfigModule ?? {};` : "const resolvedConfig = {} as Record<string, any>;";
+  const inlineConfigSource = createInlineConfigSource({
+    port: devConfig?.port,
+    host: devConfig?.host,
+    open: devConfig?.open,
+    logging: devConfig?.logging,
+    domain: devConfig?.domain,
+    env: devConfig?.env,
+    basePath: devConfig?.basePath,
+    index: devConfig?.index,
+    watch: devConfig?.watch,
+    ignore: devConfig?.ignore
+  });
+  const clientArraySource = plan.clients ? `const runtimeClients = [
+${plan.clients.map((client, index) => `  {
+    ...(mergedConfig.clients?.[${index}] ?? {}),
+    basePath: mergedConfig.clients?.[${index}]?.basePath ?? ${JSON.stringify(client.basePath)},
+    fallbackRoot: resolve(__dirname, ${JSON.stringify(client.fallbackRootRelativePath)}),
+    index: mergedConfig.clients?.[${index}]?.index ?? ${client.index ? JSON.stringify(client.index) : "undefined"},
+    root: resolve(__dirname, ${JSON.stringify(client.rootRelativePath)}),
+    mode: 'dev',
+  }`).join(",\n")}
+];` : "";
+  const rootSource = plan.usesClientArray ? "    clients: runtimeClients,\n" : `    root: resolve(__dirname, ${JSON.stringify(plan.rootRelativePath || ".")}),
+    fallbackRoot: resolve(__dirname, ${JSON.stringify(fallbackRootRelativePath)}),
+    basePath: mergedConfig.basePath ?? '',
+    index: mergedConfig.index ?? ${plan.index ? JSON.stringify(plan.index) : "undefined"},
+`;
+  return `import { createDevServer } from 'elit/server';
+import { resolve } from 'node:path';
+
+${configImportBlock}
+
+const inlineDevConfig = ${inlineConfigSource};
+const runtimeConfig = (resolvedConfig as any).dev ?? {};
+const mergedConfig = { ...runtimeConfig, ...inlineDevConfig };
+${clientArraySource}
+const options = {
+    port: mergedConfig.port || 3000,
+    host: mergedConfig.host || 'localhost',
+    open: mergedConfig.open ?? false,
+    logging: mergedConfig.logging ?? true,
+    domain: mergedConfig.domain,
+    api: mergedConfig.api,
+    ws: mergedConfig.ws,
+    https: mergedConfig.https,
+    ssr: mergedConfig.ssr,
+    proxy: mergedConfig.proxy,
+    worker: mergedConfig.worker ?? [],
+    watch: mergedConfig.watch ?? ['**/*.ts', '**/*.js', '**/*.html', '**/*.css'],
+    ignore: mergedConfig.ignore ?? ['node_modules/**', 'dist/**', '.git/**', '**/*.d.ts'],
+    env: mergedConfig.env,
+${rootSource}    mode: 'dev',
+};
+
+const devServer = createDevServer(options);
+
+const shutdown = async () => {
+    await devServer.close();
+    process.exit(0);
+};
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+`;
+}
+
+// src/dev-build/runtime.ts
+var defaultStandaloneDevRuntimeIgnorePatterns = ["node_modules/**", "dist/**", "dev-dist/**", ".git/**", "coverage/**", "**/*.d.ts"];
+function normalizeStandaloneDevRuntimeIgnorePatterns(devConfig) {
+  const merged = new Set(defaultStandaloneDevRuntimeIgnorePatterns);
+  if (devConfig?.outDir) {
+    merged.add(`${normalizeRelativePath(devConfig.outDir).replace(/^\.\//, "")}/**`);
+  }
+  for (const pattern of devConfig?.ignore || []) {
+    merged.add(pattern);
+  }
+  return [...merged];
+}
+function shouldIgnoreStandaloneDevRuntimePath(relativePath2, isDirectory, ignorePatterns) {
+  const normalizedPath = relativePath2.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!normalizedPath) {
+    return false;
+  }
+  for (const pattern of ignorePatterns) {
+    const normalizedPattern = pattern.replace(/\\/g, "/").replace(/^\.\//, "");
+    if (normalizedPattern === "**/*.d.ts") {
+      if (!isDirectory && normalizedPath.endsWith(".d.ts")) {
+        return true;
+      }
+      continue;
+    }
+    const directoryToken = normalizedPattern.replace(/^\*\*\//, "").replace(/\/\*\*$/, "").replace(/\*.*$/, "").replace(/\/+$/, "");
+    if (!directoryToken) {
+      continue;
+    }
+    if (normalizedPath === directoryToken || normalizedPath.startsWith(`${directoryToken}/`) || normalizedPath.includes(`/${directoryToken}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function rootContainsEsbuildDependentSources(rootDir, ignorePatterns) {
+  if (!existsSync(rootDir)) {
+    return false;
+  }
+  const pendingDirectories = [rootDir];
+  while (pendingDirectories.length > 0) {
+    const currentDirectory = pendingDirectories.pop();
+    const entries = readdirSync(currentDirectory, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = join(currentDirectory, entry.name);
+      const relativePath2 = normalizeRelativePath(relative(rootDir, absolutePath));
+      const isDirectory = entry.isDirectory();
+      if (shouldIgnoreStandaloneDevRuntimePath(relativePath2, isDirectory, ignorePatterns)) {
+        continue;
+      }
+      if (isDirectory) {
+        pendingDirectories.push(absolutePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const extension = extname(entry.name).toLowerCase();
+      if (extension === ".tsx" || extension === ".jsx") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function standaloneDevNeedsEsbuildRuntime(cwd, devConfig) {
+  const resolvedCwd = resolve(cwd || process.cwd());
+  const clientRoots = devConfig?.clients && devConfig.clients.length > 0 ? devConfig.clients.map((client) => resolve(resolvedCwd, client.root || ".")) : [resolve(resolvedCwd, devConfig?.root || ".")];
+  const ignorePatterns = normalizeStandaloneDevRuntimeIgnorePatterns(devConfig);
+  return clientRoots.some((clientRoot) => rootContainsEsbuildDependentSources(clientRoot, ignorePatterns));
+}
+
+// src/dev-build/build.ts
+async function buildStandaloneDevServer(options) {
+  const cwd = resolve(options.cwd || process.cwd());
+  const plan = resolveStandaloneDevBuildPlan({
+    ...options,
+    cwd
+  });
+  const outputDir = dirname(plan.outputPath);
+  mkdirSync(outputDir, { recursive: true });
+  const { build, version } = await import("esbuild");
+  const workspacePackagePlugin = createWorkspacePackagePlugin(cwd, {
+    preferBuilt: true,
+    preferredBuiltFormat: "cjs"
+  });
+  const entrySource = createStandaloneDevEntrySource(options.configPath, plan, options.devConfig, {
+    cwd,
+    buildConfig: options.buildConfig,
+    allBuilds: options.allBuilds
+  });
+  const needsEsbuildRuntime = standaloneDevNeedsEsbuildRuntime(cwd, options.devConfig);
+  await build({
+    stdin: {
+      contents: entrySource,
+      loader: "ts",
+      resolveDir: cwd,
+      sourcefile: "elit-standalone-dev-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), {
+    dependencies: needsEsbuildRuntime ? {
+      esbuild: typeof version === "string" && version.length > 0 ? `^${version}` : "*"
+    } : {},
+    replaceDependencies: true
+  });
+  if (options.logging !== false) {
+    console.log(`  \u2713 Standalone dev server \u2192 ${plan.outputPath}`);
+  }
+  return plan.outputPath;
+}
+export {
+  buildStandaloneDevServer,
+  createStandaloneDevEntrySource,
+  createStandaloneDevFallbackRootRelativePath,
+  resolveStandaloneDevBuildPlan,
+  standaloneDevNeedsEsbuildRuntime
+};