@econ-v1/app-sdk 7.0.77 → 7.0.79

package/dist/burger-build/index.js

@@ -0,0 +1,785 @@
+// @bun
+// ../burger-build/src/build.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+
+// ../burger-build/src/bun-version.ts
+var MIN_BUN_VERSION = "1.4.2";
+function assertSupportedBun(version = Bun.version) {
+  const release = version.split("-")[0];
+  if (!Bun.semver.satisfies(release, `>=${MIN_BUN_VERSION}`)) {
+    throw new Error(`burger-build needs Bun >= ${MIN_BUN_VERSION} (found ${version}); run \`bun upgrade\``);
+  }
+}
+
+// ../burger-build/src/gate.ts
+import { readFileSync } from "fs";
+import { extname, isAbsolute, relative, resolve } from "path";
+var FS_SPECIFIERS = new Set([
+  "fs",
+  "node:fs",
+  "fs/promises",
+  "node:fs/promises",
+  "burger:fs",
+  "burger:fs/promises"
+]);
+var BUN_GLOBAL = /(?<![\w$.'"`])Bun\s*\.\s*[A-Za-z_$]|\bglobalThis\s*\.\s*Bun\b/;
+var IMPORT_META_PATH = /\bimport\.meta\.(?:url|dir|dirname|filename|path)\b/;
+var NATIVE_LOADER_PACKAGE = /[\\/]node_modules[\\/](?:bindings|node-gyp-build)[\\/]/;
+function metafileKeyToPath(key, cwd) {
+  if (isAbsolute(key))
+    return key;
+  const colon = key.indexOf(":");
+  const slash = key.indexOf("/");
+  if (colon > 0 && (slash === -1 || colon < slash))
+    return key;
+  return resolve(cwd, key);
+}
+function importerGraph(metafile, cwd) {
+  const parents = new Map;
+  for (const [key, input] of Object.entries(metafile.inputs)) {
+    const importer = metafileKeyToPath(key, cwd);
+    for (const record of input.imports) {
+      if (record.external)
+        continue;
+      const child = metafileKeyToPath(record.path, cwd);
+      if (child !== importer && !parents.has(child)) {
+        parents.set(child, importer);
+      }
+    }
+  }
+  return parents;
+}
+function importerChain(file, parents) {
+  const chain = [file];
+  const seen = new Set(chain);
+  let current = parents.get(file);
+  while (current !== undefined && !seen.has(current)) {
+    chain.unshift(current);
+    seen.add(current);
+    current = parents.get(current);
+  }
+  return chain;
+}
+function loaderFor(file) {
+  switch (extname(file)) {
+    case ".ts":
+    case ".mts":
+    case ".cts":
+      return "ts";
+    case ".tsx":
+      return "tsx";
+    case ".jsx":
+      return "jsx";
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return "js";
+    default:
+      return;
+  }
+}
+function codeOf(file, source) {
+  const loader = loaderFor(file);
+  if (!loader)
+    return;
+  try {
+    return new Bun.Transpiler({ loader }).transformSync(source);
+  } catch {
+    return source;
+  }
+}
+function scanModule(file, code, importedSpecifiers) {
+  const messages = [];
+  if (BUN_GLOBAL.test(code)) {
+    messages.push("uses the Bun global (Bun.*), which does not exist in Burger");
+  }
+  if (IMPORT_META_PATH.test(code) && importedSpecifiers.some((specifier) => FS_SPECIFIERS.has(specifier))) {
+    messages.push("reads files relative to import.meta; bundling moves this module, so the files are not found at runtime \u2014 import the data statically instead");
+  }
+  if (NATIVE_LOADER_PACKAGE.test(file)) {
+    messages.push("loads a native addon (bindings/node-gyp-build), which Burger cannot run");
+  }
+  return messages;
+}
+function collectProblems(metafile, violations, cwd) {
+  const parents = importerGraph(metafile, cwd);
+  const problems = [];
+  for (const violation of violations) {
+    problems.push({
+      message: `import "${violation.specifier}": ${violation.reason}`,
+      chain: importerChain(violation.importer, parents)
+    });
+  }
+  for (const [key, input] of Object.entries(metafile.inputs)) {
+    const file = metafileKeyToPath(key, cwd);
+    if (!isAbsolute(file))
+      continue;
+    let source;
+    try {
+      source = readFileSync(file, "utf8");
+    } catch {
+      continue;
+    }
+    const code = codeOf(file, source);
+    if (code === undefined)
+      continue;
+    const specifiers = input.imports.flatMap((record) => record.original === undefined ? [record.path] : [record.path, record.original]);
+    for (const message of scanModule(file, code, specifiers)) {
+      problems.push({ message, chain: importerChain(file, parents) });
+    }
+  }
+  return problems;
+}
+function formatProblems(problems, cwd) {
+  const lines = [`burger-build: ${problems.length} problem(s) \u2014 this code cannot run on Burger:`];
+  for (const problem of problems) {
+    lines.push(`  \u2717 ${problem.message}`);
+    problem.chain.forEach((file, index) => {
+      const shown = isAbsolute(file) ? relative(cwd, file) : file;
+      lines.push(index === 0 ? `      ${shown}` : `      \u2192 ${shown}`);
+    });
+  }
+  return lines.join(`
+`);
+}
+
+// ../burger-build/src/aliases.ts
+var BURGER_MODULES = [
+  "burger:host",
+  "burger:fs",
+  "burger:fs/promises",
+  "burger:path",
+  "burger:os",
+  "burger:worker_threads",
+  "burger:crypto",
+  "burger:buffer",
+  "burger:sqlite",
+  "burger:test"
+];
+var ALIASES = new Map([
+  ["node:fs", "burger:fs"],
+  ["fs", "burger:fs"],
+  ["node:fs/promises", "burger:fs/promises"],
+  ["fs/promises", "burger:fs/promises"],
+  ["node:path", "burger:path"],
+  ["path", "burger:path"],
+  ["node:os", "burger:os"],
+  ["os", "burger:os"],
+  ["node:worker_threads", "burger:worker_threads"],
+  ["worker_threads", "burger:worker_threads"],
+  ["node:crypto", "burger:crypto"],
+  ["crypto", "burger:crypto"],
+  ["node:buffer", "burger:buffer"],
+  ["buffer", "burger:buffer"],
+  ["bun:sqlite", "burger:sqlite"],
+  ["bun:test", "burger:test"]
+]);
+var NODE_BUILTINS = new Set([
+  "_http_agent",
+  "_http_client",
+  "_http_common",
+  "_http_incoming",
+  "_http_outgoing",
+  "_http_server",
+  "_stream_duplex",
+  "_stream_passthrough",
+  "_stream_readable",
+  "_stream_transform",
+  "_stream_wrap",
+  "_stream_writable",
+  "_tls_common",
+  "_tls_wrap",
+  "assert",
+  "assert/strict",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "dns/promises",
+  "domain",
+  "events",
+  "fs",
+  "fs/promises",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "inspector/promises",
+  "module",
+  "net",
+  "os",
+  "path",
+  "path/posix",
+  "path/win32",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "readline/promises",
+  "repl",
+  "stream",
+  "stream/consumers",
+  "stream/promises",
+  "stream/web",
+  "string_decoder",
+  "sys",
+  "timers",
+  "timers/promises",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "util/types",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib"
+]);
+var BURGER_EXPORTS = {
+  "burger:host": ["appId", "dataDir", "logDir", "entryPoint", "config", "connect", "memoryUsage", "exit"],
+  "burger:fs": [
+    "existsSync",
+    "readFileSync",
+    "writeFileSync",
+    "appendFileSync",
+    "mkdirSync",
+    "readdirSync",
+    "statSync",
+    "rmSync",
+    "renameSync",
+    "chmodSync",
+    "unlinkSync",
+    "mkdtempSync",
+    "promises"
+  ],
+  "burger:fs/promises": [
+    "exists",
+    "readFile",
+    "writeFile",
+    "appendFile",
+    "mkdir",
+    "readdir",
+    "stat",
+    "rm",
+    "rename",
+    "chmod",
+    "unlink",
+    "mkdtemp"
+  ],
+  "burger:path": [
+    "join",
+    "resolve",
+    "dirname",
+    "basename",
+    "extname",
+    "relative",
+    "normalize",
+    "isAbsolute",
+    "sep",
+    "delimiter",
+    "parse",
+    "format"
+  ],
+  "burger:os": ["platform", "arch", "cpus", "totalmem", "freemem", "hostname", "tmpdir", "homedir", "EOL"],
+  "burger:worker_threads": ["isMainThread", "workerData", "parentPort", "threadId"],
+  "burger:crypto": ["randomUUID", "randomBytes", "createHash", "createHmac", "timingSafeEqual"],
+  "burger:buffer": ["Buffer"],
+  "burger:sqlite": ["Database"],
+  "burger:test": [
+    "describe",
+    "test",
+    "it",
+    "beforeEach",
+    "afterEach",
+    "beforeAll",
+    "afterAll",
+    "expect",
+    "mock",
+    "setDefaultTimeout"
+  ]
+};
+var BURGER_MODULE_SET = new Set(BURGER_MODULES);
+function classifySpecifier(specifier) {
+  if (BURGER_MODULE_SET.has(specifier)) {
+    return { kind: "burger", target: specifier };
+  }
+  const alias = ALIASES.get(specifier);
+  if (alias) {
+    return { kind: "burger", target: alias };
+  }
+  if (specifier.startsWith("burger:")) {
+    return { kind: "forbidden", reason: `"${specifier}" is not a Burger Phase 1 module` };
+  }
+  if (specifier.startsWith("node:")) {
+    return { kind: "forbidden", reason: `"${specifier}" is not provided by Burger Phase 1` };
+  }
+  if (specifier === "bun" || specifier.startsWith("bun:")) {
+    return { kind: "forbidden", reason: `"${specifier}" is a Bun runtime module` };
+  }
+  if (NODE_BUILTINS.has(specifier)) {
+    return { kind: "forbidden", reason: `"${specifier}" is a Node built-in not provided by Burger Phase 1` };
+  }
+  if (specifier.endsWith(".node")) {
+    return { kind: "forbidden", reason: `"${specifier}" is a native addon` };
+  }
+  return { kind: "other" };
+}
+
+// ../burger-build/src/plugin.ts
+var BRIDGE_NAMESPACE = "burger-require";
+var BRIDGE_PREFIX = "cjs-bridge/";
+function bridgeSource(target) {
+  const lines = [`import * as m from ${JSON.stringify(target)};`];
+  for (const name of BURGER_EXPORTS[target]) {
+    lines.push(`export const ${name} = m.${name};`);
+  }
+  return lines.join(`
+`) + `
+`;
+}
+function burgerResolvePlugin(state) {
+  return {
+    name: "burger-resolve",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (args.kind === "entry-point-build" || args.kind === "entry-point-run") {
+          return;
+        }
+        const specifierClass = classifySpecifier(args.path);
+        if (specifierClass.kind === "other") {
+          return;
+        }
+        if (specifierClass.kind === "forbidden") {
+          state.violations.push({ specifier: args.path, importer: args.importer, reason: specifierClass.reason });
+          return { path: args.path, external: true };
+        }
+        if (args.kind === "require-call") {
+          return { path: BRIDGE_PREFIX + specifierClass.target, namespace: BRIDGE_NAMESPACE };
+        }
+        return { path: specifierClass.target, external: true };
+      });
+      build.onLoad({ filter: /.*/, namespace: BRIDGE_NAMESPACE }, (args) => ({
+        contents: bridgeSource(args.path.slice(BRIDGE_PREFIX.length)),
+        loader: "js"
+      }));
+    }
+  };
+}
+
+// ../burger-build/src/build.ts
+async function buildApp(options) {
+  assertSupportedBun();
+  const cwd = process.cwd();
+  const state = { violations: [] };
+  const result = await Bun.build({
+    entrypoints: [options.entry],
+    target: "browser",
+    format: "esm",
+    conditions: ["burger"],
+    minify: options.minify,
+    splitting: false,
+    metafile: true,
+    throw: false,
+    naming: "[name].js",
+    plugins: [burgerResolvePlugin(state)]
+  });
+  if (!result.success) {
+    return { ok: false, report: result.logs.map((log) => String(log)).join(`
+`), problems: [] };
+  }
+  const problems = collectProblems(result.metafile, state.violations, cwd);
+  if (problems.length > 0) {
+    return { ok: false, report: formatProblems(problems, cwd), problems };
+  }
+  mkdirSync(options.outdir, { recursive: true });
+  const outputs = [];
+  for (const artifact of result.outputs) {
+    const target = join(options.outdir, basename(artifact.path));
+    writeFileSync(target, await artifact.text());
+    outputs.push(target);
+  }
+  return { ok: true, outputs };
+}
+// ../burger-build/src/test-prepare.ts
+import { existsSync, mkdirSync as mkdirSync2, readdirSync, readFileSync as readFileSync2, rmSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, extname as extname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2, sep } from "path";
+var CODE_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".js", ".mjs", ".jsx"]);
+var RESOLVE_SUFFIXES = [".ts", ".tsx", ".mts", ".js", ".mjs", ".jsx"];
+var TEST_FILE = /\.test\.ts$/;
+var SKIPPED_DIRECTORIES = new Set(["node_modules", "dist"]);
+var UI_DIRECTORY = "ui";
+var MOCK_MODULE_CALL = /\bmock\.module\(\s*(["'])([^"'\n]+)\1/g;
+var IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+var RESERVED = new Set([
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "enum",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "instanceof",
+  "interface",
+  "let",
+  "new",
+  "null",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "__esModule"
+]);
+function isCodeFile(path) {
+  return CODE_EXTENSIONS.has(extname2(path)) && !path.endsWith(".d.ts");
+}
+function walkCode(dir, appRoot, into) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (SKIPPED_DIRECTORIES.has(entry.name) || entry.name.startsWith("."))
+      continue;
+    if (entry.name === UI_DIRECTORY && dir === appRoot)
+      continue;
+    const path = join2(dir, entry.name);
+    if (entry.isDirectory())
+      walkCode(path, appRoot, into);
+    else if (entry.isFile() && isCodeFile(path))
+      into.push(path);
+  }
+}
+function commonAncestor(dirs) {
+  const split = dirs.map((dir) => dir.split(sep));
+  const first = split[0];
+  let length = first.length;
+  for (const parts of split.slice(1)) {
+    let i = 0;
+    while (i < length && i < parts.length && parts[i] === first[i])
+      i += 1;
+    length = i;
+  }
+  return first.slice(0, length).join(sep) || sep;
+}
+function isInside(child, parent) {
+  const rel = relative2(parent, child);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+}
+function preparedPath(relativePath) {
+  const ext = extname2(relativePath);
+  return (CODE_EXTENSIONS.has(ext) ? relativePath.slice(0, -ext.length) : relativePath) + ".js";
+}
+function relativeSpecifier(fromDir, to) {
+  const rel = relative2(fromDir, to).split(sep).join("/");
+  return rel.startsWith(".") ? rel : `./${rel}`;
+}
+function resolveRelativeFile(importerDir, specifier) {
+  const base = resolve2(importerDir, specifier);
+  const candidates = [
+    base,
+    ...RESOLVE_SUFFIXES.map((suffix) => base + suffix),
+    ...RESOLVE_SUFFIXES.map((suffix) => join2(base, `index${suffix}`))
+  ];
+  return candidates.find((candidate) => existsSync(candidate) && statSync(candidate).isFile());
+}
+function dependencyFileName(specifier) {
+  return specifier.replace(/^@/, "").replace(/[\\/]/g, "__") + ".js";
+}
+function rewriteSpecifier(ws, importer, specifier) {
+  const specifierClass = classifySpecifier(specifier);
+  if (specifierClass.kind === "burger")
+    return specifierClass.target;
+  if (specifierClass.kind === "forbidden") {
+    ws.problems.push({ message: `import "${specifier}": ${specifierClass.reason}`, chain: [importer] });
+    return;
+  }
+  if (specifier.startsWith(".") || isAbsolute2(specifier)) {
+    const target = resolveRelativeFile(dirname(importer), specifier);
+    if (target === undefined) {
+      ws.problems.push({ message: `cannot resolve "${specifier}"`, chain: [importer] });
+      return;
+    }
+    if (extname2(target) === ".json") {
+      if (!isInside(target, ws.root)) {
+        ws.problems.push({ message: `"${specifier}" is outside ${ws.root}`, chain: [importer] });
+        return;
+      }
+      ws.jsonFiles.add(target);
+      return `${relativeSpecifier(dirname(importer), target)}.js`;
+    }
+    if (!ws.sources.has(target)) {
+      ws.problems.push({
+        message: `"${specifier}" resolves to ${target}, which is not under --src or --tests`,
+        chain: [importer]
+      });
+      return;
+    }
+    return preparedPath(relativeSpecifier(dirname(importer), target));
+  }
+  if (specifier.startsWith("#")) {
+    ws.problems.push({
+      message: `package.json "imports" specifier "${specifier}" is not supported in prepared tests`,
+      chain: [importer]
+    });
+    return;
+  }
+  ws.dependencies.add(specifier);
+  return specifier;
+}
+function moduleIdentity(importer, specifier) {
+  const specifierClass = classifySpecifier(specifier);
+  if (specifierClass.kind === "burger")
+    return specifierClass.target;
+  if (specifier.startsWith(".") || isAbsolute2(specifier)) {
+    return resolveRelativeFile(dirname(importer), specifier) ?? resolve2(dirname(importer), specifier);
+  }
+  return specifier;
+}
+function staticallyImportedMocks(file, code, imports) {
+  const staticImports = new Map;
+  for (const record of imports) {
+    if (record.kind === "import-statement")
+      staticImports.set(moduleIdentity(file, record.path), record.path);
+  }
+  const messages = [];
+  const reported = new Set;
+  for (const match of code.matchAll(MOCK_MODULE_CALL)) {
+    const mocked = match[2];
+    const identity = moduleIdentity(file, mocked);
+    const imported = staticImports.get(identity);
+    if (imported === undefined || reported.has(identity))
+      continue;
+    reported.add(identity);
+    messages.push(`statically imports "${imported}" and also mocks it with mock.module("${mocked}"); ` + "Burger links static imports before mock.module runs, so the test would use the real module. " + `Call mock.module first, then load the module with \`await import("${imported}")\``);
+  }
+  return messages;
+}
+function sourcesPlugin(ws) {
+  return {
+    name: "burger-test-prepare",
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (args.kind === "entry-point-build" || args.kind === "entry-point-run")
+          return;
+        if (args.kind === "require-call") {
+          ws.problems.push({
+            message: `require("${args.path}") cannot run in a Burger module; use import`,
+            chain: [args.importer]
+          });
+          return { path: args.path, external: true };
+        }
+        return { path: rewriteSpecifier(ws, args.importer, args.path) ?? args.path, external: true };
+      });
+    }
+  };
+}
+function loaderFor2(path) {
+  const ext = extname2(path);
+  if (ext === ".tsx")
+    return "tsx";
+  if (ext === ".jsx")
+    return "jsx";
+  if (ext === ".js" || ext === ".mjs")
+    return "js";
+  return "ts";
+}
+async function bundleDependency(specifier, shimDir, cwd) {
+  const shim = join2(shimDir, dependencyFileName(specifier));
+  const quoted = JSON.stringify(specifier);
+  writeFileSync2(shim, `export * from ${quoted};
+import * as __burger_ns from ${quoted};
+export default __burger_ns.default;
+`);
+  const build = async () => {
+    const gate = { violations: [] };
+    const result = await Bun.build({
+      entrypoints: [shim],
+      target: "browser",
+      format: "esm",
+      conditions: ["burger"],
+      splitting: false,
+      metafile: true,
+      throw: false,
+      plugins: [burgerResolvePlugin(gate)]
+    });
+    return { gate, result };
+  };
+  let { gate, result } = await build();
+  if (!result.success) {
+    return { problems: [{ message: `cannot bundle dependency "${specifier}": ${result.logs.map(String).join("; ")}`, chain: [shim] }] };
+  }
+  const metafile = result.metafile;
+  const shimKey = Object.keys(metafile.inputs).find((key) => metafileKeyToPath(key, cwd) === shim);
+  const entryRecord = shimKey ? metafile.inputs[shimKey].imports.find((record) => !record.external) : undefined;
+  const entryInput = entryRecord ? metafile.inputs[entryRecord.path] : undefined;
+  if (entryInput?.format === "cjs") {
+    const probe = Bun.spawnSync([process.execPath, "-e", `process.stdout.write(JSON.stringify(Object.keys(require(${quoted}) ?? {})))`], { cwd: shimDir, stdout: "pipe", stderr: "pipe" });
+    if (probe.exitCode !== 0) {
+      return { problems: [{ message: `cannot read the exports of CommonJS dependency "${specifier}": ${probe.stderr.toString()}`, chain: [shim] }] };
+    }
+    const names = JSON.parse(probe.stdout.toString()).filter((name) => IDENTIFIER.test(name) && !RESERVED.has(name));
+    const named = names.length > 0 ? `export const { ${names.join(", ")} } = __burger_cjs;
+` : "";
+    writeFileSync2(shim, `import __burger_cjs from ${quoted};
+export default __burger_cjs;
+${named}`);
+    ({ gate, result } = await build());
+    if (!result.success) {
+      return { problems: [{ message: `cannot bundle dependency "${specifier}": ${result.logs.map(String).join("; ")}`, chain: [shim] }] };
+    }
+  }
+  const problems = collectProblems(result.metafile, gate.violations, cwd);
+  if (problems.length > 0)
+    return { problems };
+  return { code: await result.outputs[0].text() };
+}
+async function prepareTests(options) {
+  assertSupportedBun();
+  const cwd = process.cwd();
+  const src = resolve2(options.src);
+  const tests = options.tests === undefined ? undefined : resolve2(options.tests);
+  const out = resolve2(options.out);
+  for (const dir of [src, tests]) {
+    if (dir !== undefined && !(existsSync(dir) && statSync(dir).isDirectory())) {
+      return { ok: false, report: `burger-build: ${dir} is not a directory` };
+    }
+  }
+  const inputs = tests === undefined ? [src] : [src, tests];
+  if (inputs.some((dir) => isInside(dir, out))) {
+    return { ok: false, report: `burger-build: --out ${out} must not contain --src or --tests` };
+  }
+  const root = commonAncestor(inputs);
+  const files = [];
+  for (const dir of new Set(inputs))
+    walkCode(dir, cwd, files);
+  files.sort();
+  const byOutput = new Map;
+  for (const file of files) {
+    const output = preparedPath(relative2(root, file));
+    const clash = byOutput.get(output);
+    if (clash !== undefined) {
+      return { ok: false, report: `burger-build: ${clash} and ${file} would both be prepared as ${output}` };
+    }
+    byOutput.set(output, file);
+  }
+  rmSync(out, { recursive: true, force: true });
+  mkdirSync2(out, { recursive: true });
+  const ws = {
+    root,
+    sources: new Set(files),
+    jsonFiles: new Set,
+    dependencies: new Set,
+    problems: []
+  };
+  if (files.length > 0) {
+    const result = await Bun.build({
+      entrypoints: files,
+      root,
+      outdir: out,
+      target: "browser",
+      format: "esm",
+      conditions: ["burger"],
+      splitting: false,
+      minify: false,
+      throw: false,
+      naming: "[dir]/[name].js",
+      plugins: [sourcesPlugin(ws)]
+    });
+    if (!result.success) {
+      return { ok: false, report: result.logs.map(String).join(`
+`) };
+    }
+  }
+  for (const file of files) {
+    const output = join2(out, preparedPath(relative2(root, file)));
+    const prepared = readFileSync2(output, "utf8").replace(MOCK_MODULE_CALL, (call, quote, specifier) => {
+      const rewritten = rewriteSpecifier(ws, file, specifier);
+      return rewritten === undefined ? call : call.replace(`${quote}${specifier}${quote}`, JSON.stringify(rewritten));
+    });
+    writeFileSync2(output, prepared);
+    const source = readFileSync2(file, "utf8");
+    const code = codeOf(file, source) ?? source;
+    const imports = new Bun.Transpiler({ loader: loaderFor2(file) }).scan(source).imports;
+    const specifiers = imports.map((record) => record.path);
+    for (const message of [...scanModule(file, code, specifiers), ...staticallyImportedMocks(file, code, imports)]) {
+      ws.problems.push({ message, chain: [file] });
+    }
+  }
+  for (const json of ws.jsonFiles) {
+    const target = join2(out, `${relative2(root, json)}.js`);
+    mkdirSync2(dirname(target), { recursive: true });
+    const value = JSON.parse(readFileSync2(json, "utf8"));
+    writeFileSync2(target, `export default ${JSON.stringify(value)};
+`);
+  }
+  const importMap = { imports: {} };
+  if (ws.dependencies.size > 0) {
+    const shimDir = join2(root, "node_modules", ".cache", "burger-build", "shims");
+    mkdirSync2(shimDir, { recursive: true });
+    mkdirSync2(join2(out, "node_modules"), { recursive: true });
+    for (const specifier of [...ws.dependencies].sort()) {
+      const bundled = await bundleDependency(specifier, shimDir, cwd);
+      if ("problems" in bundled) {
+        ws.problems.push(...bundled.problems);
+        continue;
+      }
+      const target = join2(out, "node_modules", dependencyFileName(specifier));
+      writeFileSync2(target, bundled.code);
+      importMap.imports[specifier] = target;
+    }
+  }
+  if (ws.problems.length > 0) {
+    return { ok: false, report: formatProblems(ws.problems, cwd) };
+  }
+  const importMapPath = join2(out, "importmap.json");
+  writeFileSync2(importMapPath, `${JSON.stringify(importMap, null, 2)}
+`);
+  const plan = {
+    importMap: importMapPath,
+    tests: files.filter((file) => TEST_FILE.test(file)).map((file) => ({ source: file, output: join2(out, preparedPath(relative2(root, file))) }))
+  };
+  writeFileSync2(join2(out, "test-plan.json"), `${JSON.stringify(plan, null, 2)}
+`);
+  return { ok: true, plan, importMap };
+}
+export {
+  MIN_BUN_VERSION,
+  buildApp,
+  prepareTests
+};