@cimplify/cli 0.15.3 → 0.17.0

package/dist/chunk-PHUBMRAS.mjs

@@ -0,0 +1,623 @@
+#!/usr/bin/env node
+import { writeModuleTree } from './chunk-XF3MGADK.mjs';
+import { outputPathOf } from './chunk-BTNVYAC4.mjs';
+import { isEngineGame } from './chunk-HQPZQIWW.mjs';
+import { resolveExport, NODE_CONDITIONS, heapHooksUrl, runtimeImportMap, ENGINE_CORE, engineCoreFile } from './chunk-N2WZJX5P.mjs';
+import { CHUNK_PAYLOAD_PART } from './chunk-EYEMPIMP.mjs';
+import { createServer } from 'http';
+import { promises } from 'fs';
+import { createRequire } from 'module';
+import path from 'path';
+import { pathToFileURL, fileURLToPath } from 'url';
+import { build } from 'esbuild';
+import { spawn } from 'child_process';
+import { FULL_ENGINE_VARIANT } from '@cimplify/sdk/interactives';
+import { judgeEconomy, auditManifestEconomy } from '@cimplify/sdk/game/kit';
+
+var MAGLEV_GATE = "heap growth (maglev)";
+var GATE_BROWSER_ENV = "CIMPLIFY_GATE_BROWSER";
+var GATE_BROWSER_REQUIRED = "required";
+var WASM_TOP_TIER_FLAG = "--no-wasm-dynamic-tiering";
+var MAGLEV_FLAGS = `--max-opt=2 ${WASM_TOP_TIER_FLAG}`;
+var BUNDLE_FILE = "maglev-gate.js";
+var PAGE_FILE = "maglev-gate.html";
+var ENTRY_FILE = "maglev-entry.mjs";
+var SAMPLING_INTERVAL_BYTES = 32;
+var LOAD_TIMEOUT_MS = 12e4;
+var PLAYWRIGHT_PACKAGES = ["playwright-core", "playwright"];
+var CONTENT_TYPES = {
+  ".html": "text/html",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".json": "application/json",
+  ".wasm": "application/wasm"
+};
+function loadPlaywright(bases) {
+  for (const base of bases) {
+    const require2 = createRequire(path.join(base, "package.json"));
+    for (const name of PLAYWRIGHT_PACKAGES) {
+      try {
+        return require2(name);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+function libraryFile(config, specifier) {
+  const exact = config.imports[specifier];
+  if (exact !== void 0) return fileURLToPath(exact);
+  for (const key of Object.keys(config.imports)) {
+    if (key.endsWith("/") && specifier.startsWith(key)) return fileURLToPath(config.imports[key] + specifier.slice(key.length));
+  }
+  return specifier;
+}
+function entrySource(config) {
+  const libraries = [...new Set(config.modules.flatMap((m) => m.imports.map((i) => i.library).filter((l) => l !== null)))];
+  const lines = [`import * as runtime from ${JSON.stringify(fileURLToPath(config.runtime))};`];
+  libraries.forEach((library, i) => lines.push(`import * as library${i} from ${JSON.stringify(libraryFile(config, library))};`));
+  if (config.hooks !== null) lines.push(`import * as hooks from ${JSON.stringify(fileURLToPath(config.hooks))};`);
+  else lines.push("const hooks = null;");
+  lines.push(`globalThis.__gate = { runtime, hooks, libraries: { ${libraries.map((library, i) => `${JSON.stringify(library)}: library${i}`).join(", ")} } };`);
+  return `${lines.join("\n")}
+`;
+}
+var PAGE_SCRIPT = `
+const g = globalThis.__gate;
+const state = { frame: null, index: 0 };
+globalThis.__setup = async (gate) => {
+  const runtime = g.runtime;
+  const modules = gate.modules.map((m) => ({ path: m.path, code: m.code, imports: m.imports.map((u) => ({ ...u, export: u.library })) }));
+  const runtimes = Object.keys(g.libraries).map((unit) => ({ unit, kind: "code", code: "", imports: [] }));
+  const compiler = {
+    compile: (p, code) =>
+      p.startsWith(runtime.RUNTIME_PATH_PREFIX)
+        ? (_require, exports) => { const unit = p.slice(runtime.RUNTIME_PATH_PREFIX.length); exports.default = { [unit]: g.libraries[unit] }; }
+        : new Function(...runtime.MODULE_PARAMETERS, code),
+  };
+  const slice = new runtime.Slice({ begin() {}, over: () => false });
+  const mod = await runtime.commonJsLinker(compiler).link(modules, gate.entry, slice.tick, runtimes);
+  let platform;
+  if (gate.engine !== null && g.hooks !== null && typeof g.hooks.bytesFramePlatform === "function") {
+    const bytes = new Uint8Array(await (await fetch(gate.engine)).arrayBuffer());
+    platform = g.hooks.bytesFramePlatform(bytes);
+  }
+  const assets = {
+    take: async (asset) => {
+      const url = gate.assets[asset];
+      if (url === undefined) throw new Error("the package carries no asset " + asset);
+      return new Uint8Array(await (await fetch(url)).arrayBuffer());
+    },
+  };
+  state.frame = await mod.default(platform, assets);
+  for (let i = 0; i < gate.warmup; i++) state.frame(state.index++);
+  return true;
+};
+globalThis.__run = (count) => { const frame = state.frame; for (let i = 0; i < count; i++) frame(state.index++); return count; };
+`;
+function serve(root) {
+  const server = createServer((req, res) => {
+    const pathname = decodeURIComponent(new URL(req.url ?? "/", "http://localhost").pathname);
+    const file = path.join(root, path.normalize(pathname).replace(/^(\.\.[/\\])+/, ""));
+    if (!file.startsWith(root)) {
+      res.writeHead(404).end();
+      return;
+    }
+    promises.readFile(file).then(
+      (bytes) => res.writeHead(200, { "content-type": CONTENT_TYPES[path.extname(file)] ?? "application/octet-stream", "cache-control": "no-store" }).end(bytes),
+      () => res.writeHead(404).end()
+    );
+  });
+  return new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve({ server, port: server.address().port })));
+}
+function sampledBytes(node) {
+  let total = node.selfSize;
+  for (const child of node.children) total += sampledBytes(child);
+  return total;
+}
+async function measureMaglev(workDir, configFile, entry, warmup, samples, bases) {
+  const playwright = loadPlaywright(bases);
+  if (playwright === null) return { kind: "unavailable", reason: "playwright is not installed, so the Maglev heap gate cannot run headless Chromium" };
+  const config = JSON.parse(await promises.readFile(configFile, "utf8"));
+  await promises.writeFile(path.join(workDir, ENTRY_FILE), entrySource(config));
+  try {
+    await build({ entryPoints: [path.join(workDir, ENTRY_FILE)], bundle: true, format: "esm", platform: "browser", target: "es2022", outfile: path.join(workDir, BUNDLE_FILE), logLevel: "silent" });
+  } catch (err) {
+    return { kind: "failed", reason: `the Maglev gate page did not bundle: ${err.message}` };
+  }
+  await promises.writeFile(path.join(workDir, PAGE_FILE), `<!doctype html><script type="module" src="${BUNDLE_FILE}"></script><script type="module">${PAGE_SCRIPT}</script>
+`);
+  const modules = await Promise.all(config.modules.map(async (m) => ({ path: m.path, code: await promises.readFile(m.file, "utf8"), imports: m.imports })));
+  const engine = config.engine === null ? null : `/${path.basename(config.engine)}`;
+  const assets = {};
+  for (const [asset, file] of Object.entries(config.assets ?? {})) assets[asset] = `/${path.relative(workDir, file).split(path.sep).map(encodeURIComponent).join("/")}`;
+  const gate2 = { modules, entry, warmup, engine, assets };
+  const { server, port } = await serve(workDir);
+  let browser = null;
+  try {
+    try {
+      browser = await playwright.chromium.launch({ headless: true, args: [`--js-flags=${MAGLEV_FLAGS}`] });
+    } catch (err) {
+      return { kind: "unavailable", reason: `headless Chromium did not start (${err.message.split("\n")[0]}); install it with npx playwright install chromium` };
+    }
+    const page = await browser.newPage();
+    await page.goto(`http://127.0.0.1:${port}/${PAGE_FILE}`);
+    await page.waitForFunction("typeof globalThis.__setup === 'function'", void 0, { timeout: LOAD_TIMEOUT_MS });
+    await page.evaluate(`globalThis.__setup(${JSON.stringify(gate2)})`);
+    const cdp = await page.context().newCDPSession(page);
+    await cdp.send("HeapProfiler.startSampling", { samplingInterval: SAMPLING_INTERVAL_BYTES, includeObjectsCollectedByMajorGC: true, includeObjectsCollectedByMinorGC: true });
+    await page.evaluate(`globalThis.__run(${samples})`);
+    const sampled = await cdp.send("HeapProfiler.stopSampling");
+    return { kind: "measured", bytesPerFrame: sampledBytes(sampled.profile.head) / samples };
+  } catch (err) {
+    return { kind: "failed", reason: `the conformance entry did not run in headless Chromium: ${err.message.split("\n")[0]}` };
+  } finally {
+    await browser?.close();
+    server.close();
+  }
+}
+function browserRequired() {
+  return process.env[GATE_BROWSER_ENV] === GATE_BROWSER_REQUIRED;
+}
+function cliBase() {
+  return path.dirname(fileURLToPath(import.meta.url));
+}
+var FRAME_BUDGETS = {
+  low: { p99Ms: 2, heapBytesPerMinute: 256 * 1024, collectionsPerMinute: 2, gcPauseMs: 1, coldAllocationBytes: 1024 * 1024 },
+  mid: { p99Ms: 3, heapBytesPerMinute: 512 * 1024, collectionsPerMinute: 4, gcPauseMs: 2, coldAllocationBytes: 2 * 1024 * 1024 },
+  high: { p99Ms: 4, heapBytesPerMinute: 1024 * 1024, collectionsPerMinute: 6, gcPauseMs: 4, coldAllocationBytes: 4 * 1024 * 1024 }
+};
+var COLD_START_FRAMES = 600;
+var COLD_START_SECONDS = COLD_START_FRAMES / 60;
+var WARMUP_FRAMES = 3e4;
+var SAMPLE_FRAMES = 3600;
+var GATE_RUNTIME_ENV = "CIMPLIFY_GATE_RUNTIME";
+var DEFAULT_RUNTIME = "node";
+var NODE_RUNTIME = /^node(\.exe)?$/;
+var NODE_GATE_FLAGS = ["--no-concurrent-recompilation", WASM_TOP_TIER_FLAG];
+var RUNNER_FILE = "gate-runner.mjs";
+var MODULE_DIR = "modules";
+var FRAMES_PER_MINUTE = 3600;
+var ENGINE_FRAME_GATES = "engine games are measured in the canvas harness (bun scripts/canvas-host-e2e.ts in packages/sdk): frame time, young garbage, collections and the cold first frame";
+var CONFIG_FILE = "gate-config.json";
+var ENGINE_FILE = "engine-core.wasm";
+var ASSET_DIR = "assets";
+var NATIVE_PROFILE = "native";
+async function writeShippedEngine(workDir, result, toolchain = null) {
+  const file = path.join(workDir, ENGINE_FILE);
+  const reference = result.package?.runtime.find((r) => r.name === ENGINE_CORE && r.kind === "wasm");
+  const chunk = reference === void 0 ? void 0 : result.chunks.find((c) => c.digest === reference.chunk);
+  if (chunk !== void 0) {
+    await promises.writeFile(file, chunk.parts[CHUNK_PAYLOAD_PART]);
+    return file;
+  }
+  if (toolchain === null || result.manifest?.profile.kind !== NATIVE_PROFILE) return null;
+  try {
+    await promises.copyFile(engineCoreFile(toolchain.sdkDir, FULL_ENGINE_VARIANT), file);
+    return file;
+  } catch {
+    return null;
+  }
+}
+var UNPACKED_KINDS = /* @__PURE__ */ new Set(["code", "bytecode", "index"]);
+async function writeAssetTree(workDir, result) {
+  const out = {};
+  const byDigest = new Map(result.chunks.map((c) => [c.digest, c]));
+  for (const group of result.package?.groups ?? []) {
+    for (const f of group.files) {
+      if (UNPACKED_KINDS.has(f.kind) || f.runtime !== void 0 || f.path in out) continue;
+      const chunk = byDigest.get(f.chunk);
+      if (chunk === void 0) continue;
+      const file = path.join(workDir, ASSET_DIR, ...f.path.split("/"));
+      await promises.mkdir(path.dirname(file), { recursive: true });
+      await promises.writeFile(file, chunk.parts[CHUNK_PAYLOAD_PART]);
+      out[f.path] = file;
+    }
+  }
+  return out;
+}
+var RUNTIME_SUBPATH = "./interactives/runtime";
+var V8_METADATA_NAMES = [
+  "system / WeakArrayList",
+  "system / ProtectedFixedArray",
+  "system / SharedFunctionInfoWrapper",
+  "system / ClosureFeedbackCellArray",
+  "system / FeedbackCell",
+  "system / FeedbackMetadata",
+  "system / ScopeInfo",
+  "system / TrustedByteArray",
+  "system / TrustedFixedArray",
+  "system / TrustedWeakFixedArray",
+  "system / InterpreterData",
+  "system / CodeWrapper",
+  "system / BytecodeWrapper",
+  "system / PreparseData"
+];
+var RUNNER = `import { readFileSync } from "node:fs";
+import { PerformanceObserver } from "node:perf_hooks";
+import { pathToFileURL } from "node:url";
+import vm from "node:vm";
+const [entry, warmupArg, samplesArg, configPath] = process.argv.slice(2);
+const config = JSON.parse(readFileSync(configPath, "utf8"));
+const runtime = await import(config.runtime);
+const libraryUrl = (specifier) => {
+  const exact = config.imports[specifier];
+  if (exact !== undefined) return exact;
+  for (const key of Object.keys(config.imports)) {
+    if (key.endsWith("/") && specifier.startsWith(key)) return config.imports[key] + specifier.slice(key.length);
+  }
+  return pathToFileURL(specifier).href;
+};
+const libraries = new Map();
+for (const module of config.modules) {
+  for (const used of module.imports) {
+    if (used.library !== null && !libraries.has(used.library)) libraries.set(used.library, await import(libraryUrl(used.library)));
+  }
+}
+const modules = config.modules.map((module) => ({
+  path: module.path,
+  code: readFileSync(module.file, "utf8"),
+  imports: module.imports.map((used) => ({ ...used, export: used.library })),
+}));
+const runtimes = [...libraries.keys()].map((unit) => ({ unit, kind: "code", code: "", imports: [] }));
+const hostUnit = (unit) => (_require, exports) => {
+  exports.default = { [unit]: libraries.get(unit) };
+};
+const compiler = {
+  compile: (path, code) =>
+    path.startsWith(runtime.RUNTIME_PATH_PREFIX)
+      ? hostUnit(path.slice(runtime.RUNTIME_PATH_PREFIX.length))
+      : vm.compileFunction(code, runtime.MODULE_PARAMETERS.slice(), { filename: path }),
+};
+const slice = new runtime.Slice({ begin() {}, over: () => false });
+let gcCount = 0;
+let gcMaxMs = 0;
+let windowOpened = Number.POSITIVE_INFINITY;
+let windowClosed = Number.NEGATIVE_INFINITY;
+const tally = (entries) => {
+  for (const e of entries) {
+    if (e.startTime < windowOpened || e.startTime > windowClosed) continue;
+    gcCount++;
+    if (e.duration > gcMaxMs) gcMaxMs = e.duration;
+  }
+};
+const observer = new PerformanceObserver((list) => tally(list.getEntries()));
+observer.observe({ entryTypes: ["gc"] });
+const warmup = Number(warmupArg);
+const samples = Number(samplesArg);
+const coldFrames = Number(config.coldFrames);
+const mod = await runtime.commonJsLinker(compiler).link(modules, entry, slice.tick, runtimes);
+const hooks = config.hooks === null ? null : await import(config.hooks).catch(() => null);
+const platform = config.engine === null || hooks === null || typeof hooks.engineFramePlatform !== "function" ? undefined : await hooks.engineFramePlatform(config.engine);
+const assets = {
+  take: async (asset) => {
+    const file = config.assets?.[asset];
+    if (file === undefined) throw new Error("the package carries no asset " + asset);
+    return new Uint8Array(readFileSync(file));
+  },
+};
+const inspector = await import("node:inspector/promises").catch(() => null);
+const v8 = await import("node:v8").catch(() => null);
+const own = new Set(config.modules.map((module) => module.path));
+const boxedNumberBytes = process.config?.variables?.v8_enable_pointer_compression ? 12 : 16;
+const V8_METADATA_TYPES = new Set(["code", "object shape"]);
+const V8_METADATA_NAMES = new Set(${JSON.stringify(V8_METADATA_NAMES)});
+const isV8Metadata = (type, name) => V8_METADATA_TYPES.has(type) || (type === "hidden" && V8_METADATA_NAMES.has(name));
+const coldShares = (snap) => {
+  const meta = snap.snapshot.meta;
+  const nodeFields = meta.node_fields.length;
+  const sizeAt = meta.node_fields.indexOf("self_size");
+  const traceAt = meta.node_fields.indexOf("trace_node_id");
+  const fnFields = meta.trace_function_info_fields.length;
+  const scriptAt = meta.trace_function_info_fields.indexOf("script_name");
+  const typeAt = meta.node_fields.indexOf("type");
+  const nameAt = meta.node_fields.indexOf("name");
+  const nodeTypes = meta.node_types[typeAt];
+  const live = new Map();
+  const metadata = new Map();
+  for (let i = 0; i < snap.nodes.length; i += nodeFields) {
+    const trace = snap.nodes[i + traceAt];
+    if (trace === 0) continue;
+    const size = snap.nodes[i + sizeAt];
+    if (isV8Metadata(nodeTypes[snap.nodes[i + typeAt]], snap.strings[snap.nodes[i + nameAt]])) {
+      const m = metadata.get(trace) ?? { bytes: 0, count: 0 };
+      m.bytes += size;
+      m.count++;
+      metadata.set(trace, m);
+    } else {
+      live.set(trace, (live.get(trace) ?? 0) + size);
+    }
+  }
+  const shares = { game: { allocated: 0, garbage: 0, boxed: 0, metadata: 0 }, platform: { allocated: 0, garbage: 0, boxed: 0, metadata: 0 } };
+  const visit = (tree) => {
+    for (let i = 0; i < tree.length; i += 5) {
+      const script = snap.strings[snap.trace_function_infos[tree[i + 1] * fnFields + scriptAt]] ?? "";
+      const share = own.has(script) ? shares.game : script.startsWith("file:") ? shares.platform : null;
+      if (share !== null) {
+        const m = metadata.get(tree[i]);
+        const metaBytes = Math.min(tree[i + 3], m === undefined ? 0 : m.bytes);
+        const bytes = tree[i + 3] - metaBytes;
+        const count = Math.max(0, tree[i + 2] - (m === undefined ? 0 : m.count));
+        const objects = Math.min(bytes, 2 * Math.max(0, bytes - count * boxedNumberBytes));
+        share.metadata += metaBytes;
+        share.boxed += bytes - objects;
+        share.allocated += objects;
+        share.garbage += Math.max(0, objects - (live.get(tree[i]) ?? 0));
+      }
+      visit(tree[i + 4]);
+    }
+  };
+  visit(snap.trace_tree);
+  shares.metadataLive = 0;
+  for (const m of metadata.values()) shares.metadataLive += m.bytes;
+  return shares;
+};
+let cold = null;
+let tracked = null;
+let frame;
+let index = 0;
+if (inspector === null) {
+  cold = { error: "the cold-start meter needs node:inspector" };
+  frame = await mod.default(platform, assets);
+} else {
+  const session = new inspector.Session();
+  session.connect();
+  const settle = async () => {
+    for (let i = 0; i < 2; i++) await session.post("HeapProfiler.collectGarbage");
+    return v8 === null ? 0 : v8.getHeapStatistics().used_heap_size;
+  };
+  const measure = async (frames) => {
+    const held = await settle();
+    const gcBefore = gcCount;
+    windowOpened = performance.now();
+    windowClosed = Number.POSITIVE_INFINITY;
+    await session.post("HeapProfiler.startTrackingHeapObjects", { trackAllocations: true });
+    for (let i = 0; i < frames; i++, index++) frame(index);
+    windowClosed = performance.now();
+    const chunks = [];
+    const collect = (message) => chunks.push(message.params.chunk);
+    session.on("HeapProfiler.addHeapSnapshotChunk", collect);
+    await session.post("HeapProfiler.stopTrackingHeapObjects", { reportProgress: false, treatGlobalObjectsAsRoots: true });
+    session.off("HeapProfiler.addHeapSnapshotChunk", collect);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    tally(observer.takeRecords());
+    const collections = gcCount - gcBefore;
+    const shares = coldShares(JSON.parse(chunks.splice(0).join("")));
+    const retained = Math.max(0, (await settle()) - held - shares.metadataLive);
+    gcCount = 0;
+    gcMaxMs = 0;
+    windowOpened = Number.POSITIVE_INFINITY;
+    windowClosed = Number.NEGATIVE_INFINITY;
+    return { shares, retained, collections };
+  };
+  const primer = await mod.default(platform, assets);
+  for (let i = 0; i < coldFrames; i++) primer(i);
+  frame = await mod.default(platform, assets);
+  const first = await measure(coldFrames);
+  cold = {
+    frames: coldFrames,
+    allocated_bytes: first.shares.game.allocated + first.shares.platform.allocated,
+    garbage_bytes: first.shares.game.garbage + first.shares.platform.garbage,
+    game_allocated_bytes: first.shares.game.allocated,
+    platform_allocated_bytes: first.shares.platform.allocated,
+    boxed_number_bytes: first.shares.game.boxed + first.shares.platform.boxed,
+    v8_metadata_bytes: first.shares.game.metadata + first.shares.platform.metadata,
+    collections: first.collections,
+  };
+  const steady = await measure(samples);
+  const objects = steady.shares.game.allocated + steady.shares.platform.allocated;
+  tracked = {
+    bytes_per_frame: Math.max(objects, steady.retained) / samples,
+    object_bytes_per_frame: objects / samples,
+    retained_bytes_per_frame: steady.retained / samples,
+    boxed_number_bytes_per_frame: (steady.shares.game.boxed + steady.shares.platform.boxed) / samples,
+    v8_metadata_bytes_per_frame: (steady.shares.game.metadata + steady.shares.platform.metadata) / samples,
+    from_frame: coldFrames,
+    collections: steady.collections,
+  };
+  session.disconnect();
+}
+for (; index < coldFrames + warmup; index++) frame(index);
+await new Promise((resolve) => setTimeout(resolve, 0));
+const times = new Float64Array(samples);
+windowOpened = performance.now();
+windowClosed = Number.POSITIVE_INFINITY;
+for (let s = 0; s < samples; s++, index++) {
+  const start = performance.now();
+  frame(index);
+  times[s] = performance.now() - start;
+}
+windowClosed = performance.now();
+await new Promise((resolve) => setTimeout(resolve, 0));
+tally(observer.takeRecords());
+const gc = { count: gcCount, max_ms: gcMaxMs };
+times.sort();
+const at = (q) => times[Math.min(samples - 1, Math.floor(q * samples))];
+let heap = tracked;
+if (heap === null) try {
+  if (hooks === null) throw new Error("the pinned SDK has no heap hooks");
+  const meter = await hooks.createNodeHeapMeter();
+  if (meter) {
+    const base = index;
+    const session = inspector === null ? null : new inspector.Session();
+    session?.connect();
+    const held = async () => {
+      if (session === null || v8 === null) return 0;
+      for (let i = 0; i < 2; i++) await session.post("HeapProfiler.collectGarbage");
+      return v8.getHeapStatistics().used_heap_size;
+    };
+    const heldBefore = await held();
+    const report = await hooks.measureAllocations(meter, samples, (n) => frame(base + n));
+    const retainedPerFrame = Math.max(0, (await held()) - heldBefore) / samples;
+    session?.disconnect();
+    meter.dispose();
+    heap = { bytes_per_frame: Math.max(report.bytesPerFrame, retainedPerFrame), young_bytes_per_frame: report.bytesPerFrame, retained_bytes_per_frame: retainedPerFrame, collections: report.collections };
+  }
+} catch (err) {
+  heap = { error: String(err && err.message ? err.message : err) };
+}
+observer.disconnect();
+process.stdout.write(JSON.stringify({ p50: at(0.5), p99: at(0.99), p999: at(0.999), max: times[samples - 1], gc, heap, cold }));
+`;
+function gate(name, status, detail) {
+  return { name, status, detail };
+}
+function countBy(diagnostics, prefixes) {
+  return diagnostics.filter((d) => d.severity === "error" && prefixes.some((p) => d.code.startsWith(p)));
+}
+var ANALYSIS_PREFIXES = ["analysis.", "refusal.", "resolve."];
+var SIZE_PREFIXES = ["delivery."];
+var TYPE_PREFIXES = ["typecheck.", "toolchain."];
+var GATED_PREFIXES = [...ANALYSIS_PREFIXES, ...SIZE_PREFIXES, ...TYPE_PREFIXES];
+var ECONOMY_GATES = ["currency classes", "odds disclosure", "one-way money"];
+function economyGates(manifest) {
+  if (manifest === null) return [];
+  const economy = manifest.economy;
+  if (economy.currencies.length === 0 && economy.items.length === 0 && economy.odds.length === 0) return [];
+  const judged = judgeEconomy(auditManifestEconomy(economy, { category: manifest.identity.category, capabilities: manifest.capabilities.map((c) => c.name) }));
+  return ECONOMY_GATES.map((name) => {
+    const found = judged.find((g) => g.name === name);
+    return found === void 0 || found.passed ? gate(name, "passed", found?.detail ?? "") : gate(name, "failed", found.detail);
+  });
+}
+function buildGates(result) {
+  const analysis = countBy(result.diagnostics, ANALYSIS_PREFIXES);
+  const size = countBy(result.diagnostics, SIZE_PREFIXES);
+  const types = countBy(result.diagnostics, TYPE_PREFIXES);
+  const other = result.diagnostics.filter((d) => d.severity === "error" && !GATED_PREFIXES.some((p) => d.code.startsWith(p)));
+  const out = [];
+  out.push(other.length === 0 ? gate("build", "passed", `${result.stats.files} files`) : gate("build", "failed", `${other.length} errors`));
+  out.push(analysis.length === 0 ? gate("analysis", "passed", "no refusals") : gate("analysis", "failed", `${analysis.length} findings`));
+  if (types.length > 0) out.push(gate("types", "failed", `${types.length} type errors`));
+  else if (other.length > 0 || analysis.length > 0) out.push(gate("types", "skipped", "earlier gates failed"));
+  else out.push(gate("types", "passed", "strict type check against the pinned SDK"));
+  if (result.ok) {
+    out.push(gate("size", "passed", `${result.stats.totalBytes} bytes, ${result.stats.beforePlayBytes} before play`));
+  } else {
+    out.push(size.length === 0 ? gate("size", "skipped", "the build did not finish") : gate("size", "failed", `${size.length} findings`));
+  }
+  for (const g of economyGates(result.manifest)) out.push(g);
+  return out;
+}
+async function runRunner(runtime, runner, [entry, config], cwd) {
+  return new Promise((resolve, reject) => {
+    const flags = NODE_RUNTIME.test(path.basename(runtime)) ? NODE_GATE_FLAGS : [];
+    const child = spawn(runtime, [...flags, runner, entry, String(WARMUP_FRAMES), String(SAMPLE_FRAMES), config], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    const out = [];
+    const err = [];
+    child.stdout.on("data", (b) => out.push(b));
+    child.stderr.on("data", (b) => err.push(b));
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(Buffer.concat(err).toString("utf8").trim() || `frame runner exited with ${code}`));
+        return;
+      }
+      try {
+        resolve(JSON.parse(Buffer.concat(out).toString("utf8")));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+function judgeFrames(measured, tier) {
+  const budget = FRAME_BUDGETS[tier];
+  const times = `p50 ${measured.p50.toFixed(3)} ms, p99 ${measured.p99.toFixed(3)} ms, p99.9 ${measured.p999.toFixed(3)} ms`;
+  const out = [
+    measured.p99 <= budget.p99Ms ? gate("frame time", "passed", `${times} (budget p99 ${budget.p99Ms} ms)`) : gate("frame time", "failed", `${times} exceeds the ${tier} tier budget of ${budget.p99Ms} ms at p99`)
+  ];
+  const heap = measured.heap;
+  if (heap === null || "error" in heap) {
+    out.push(gate("heap growth", "skipped", heap === null ? "the heap meter is unavailable on this runtime" : heap.error));
+  } else {
+    const perMinute = heap.bytes_per_frame * FRAMES_PER_MINUTE;
+    const boxed = heap.boxed_number_bytes_per_frame;
+    const measured2 = boxed === void 0 ? `${Math.round(perMinute)} bytes per minute` : `${Math.round(perMinute)} bytes per minute of objects over the minute from frame ${heap.from_frame} (${Math.round(boxed * FRAMES_PER_MINUTE)} more in numbers V8 boxes before it optimizes, which JavaScriptCore and Hermes never allocate; ${Math.round((heap.v8_metadata_bytes_per_frame ?? 0) * FRAMES_PER_MINUTE)} in V8 compiler and runtime metadata)`;
+    out.push(
+      perMinute <= budget.heapBytesPerMinute ? gate("heap growth", "passed", `${measured2} (budget ${budget.heapBytesPerMinute})`) : gate("heap growth", "failed", `${measured2} exceeds ${budget.heapBytesPerMinute}; reuse buffers in the frame loop`)
+    );
+  }
+  const cold = measured.cold ?? null;
+  if (cold === null || "error" in cold) {
+    out.push(gate("cold start", "skipped", cold === null ? "the cold-start meter is unavailable on this runtime" : cold.error));
+  } else {
+    const made = `${cold.allocated_bytes} bytes of objects allocated in the first ${COLD_START_SECONDS} s of frames, ${cold.garbage_bytes} of them garbage (${cold.game_allocated_bytes} in the game's functions, ${cold.platform_allocated_bytes} in the SDK; ${cold.boxed_number_bytes} more in numbers V8 boxes before it optimizes, which JavaScriptCore and Hermes never allocate; ${cold.v8_metadata_bytes ?? 0} in V8 compiler and runtime metadata), ${cold.collections} collections`;
+    out.push(
+      cold.allocated_bytes <= budget.coldAllocationBytes ? gate("cold start", "passed", `${made} (budget ${budget.coldAllocationBytes})`) : gate("cold start", "failed", `${made} exceeds ${budget.coldAllocationBytes}; allocate scratch once at setup, not on first use, and keep arrays in one element kind`)
+    );
+  }
+  const gc = measured.gc;
+  const pauses = `${gc.count} collections, longest ${gc.max_ms.toFixed(3)} ms in a minute of frames`;
+  out.push(
+    gc.count <= budget.collectionsPerMinute && gc.max_ms <= budget.gcPauseMs ? gate("gc pauses", "passed", pauses) : gate("gc pauses", "failed", `${pauses}; the budget is ${budget.collectionsPerMinute} collections of at most ${budget.gcPauseMs} ms`)
+  );
+  return out;
+}
+function judgeMaglev(outcome, tier, required) {
+  if (outcome.kind === "unavailable") return gate(MAGLEV_GATE, required ? "failed" : "skipped", outcome.reason);
+  if (outcome.kind === "failed") return gate(MAGLEV_GATE, "failed", outcome.reason);
+  const budget = FRAME_BUDGETS[tier].heapBytesPerMinute;
+  const perMinute = outcome.bytesPerFrame * FRAMES_PER_MINUTE;
+  const detail = `${Math.round(perMinute)} bytes per minute in headless Chromium with only Maglev (budget ${budget})`;
+  return perMinute <= budget ? gate(MAGLEV_GATE, "passed", detail) : gate(MAGLEV_GATE, "failed", `${detail}; keep computed floats off non-inlined calls and fields in the frame path`);
+}
+var MICROS_PER_MS = 1e3;
+function measurementsOf(measured) {
+  const heap = measured.heap;
+  return {
+    frame_micros_p99: Math.round(measured.p99 * MICROS_PER_MS),
+    gc_pause_micros_p99: Math.round(measured.gc.max_ms * MICROS_PER_MS),
+    heap_growth_bytes_per_minute: heap === null || "error" in heap ? null : Math.round(heap.bytes_per_frame * FRAMES_PER_MINUTE)
+  };
+}
+async function frameGates(workDir, result, toolchain, requireBrowser = browserRequired()) {
+  const manifest = result.manifest;
+  if (manifest === null || manifest.profile.game === null) return { gates: [], measurements: null };
+  if (isEngineGame(manifest.profile.game)) {
+    return { gates: [gate("frame time", "skipped", ENGINE_FRAME_GATES)], measurements: null };
+  }
+  const entry = manifest.entries.conformance;
+  if (entry === null) {
+    return { gates: [gate("frame time", "skipped", "declare entries.conformance to run the frame and heap gates")], measurements: null };
+  }
+  if (result.modules.length === 0) return { gates: [gate("frame time", "skipped", "the build did not finish")], measurements: null };
+  if (toolchain === null) {
+    return { gates: [gate("frame time", "failed", "the pinned SDK is not installed where the gate runner can load it")], measurements: null };
+  }
+  const moduleDir = path.join(workDir, MODULE_DIR);
+  await writeModuleTree(moduleDir, result.modules);
+  const linker = resolveExport(toolchain.sdkDir, RUNTIME_SUBPATH, NODE_CONDITIONS);
+  if (linker === null) {
+    return { gates: [gate("frame time", "failed", "the pinned SDK does not ship the Interactives runtime the gate runner links with")], measurements: null };
+  }
+  const runner = path.join(workDir, RUNNER_FILE);
+  const config = path.join(workDir, CONFIG_FILE);
+  await promises.writeFile(runner, RUNNER);
+  const engine = await writeShippedEngine(workDir, result, toolchain);
+  const assets = await writeAssetTree(workDir, result);
+  await promises.writeFile(
+    config,
+    JSON.stringify({
+      runtime: pathToFileURL(linker).href,
+      imports: runtimeImportMap(toolchain),
+      hooks: heapHooksUrl(toolchain),
+      engine,
+      assets,
+      coldFrames: COLD_START_FRAMES,
+      modules: result.modules.map((m) => ({ path: m.output, file: path.join(moduleDir, ...m.output.split("/")), imports: m.imports }))
+    })
+  );
+  const runtime = process.env[GATE_RUNTIME_ENV] ?? DEFAULT_RUNTIME;
+  try {
+    const measured = await runRunner(runtime, runner, [outputPathOf(entry), config], workDir);
+    const maglev = await measureMaglev(workDir, config, outputPathOf(entry), WARMUP_FRAMES, SAMPLE_FRAMES, [cliBase(), toolchain.base, toolchain.sdkDir]);
+    const gates = [...judgeFrames(measured, manifest.delivery.minDeviceTier), judgeMaglev(maglev, manifest.delivery.minDeviceTier, requireBrowser)];
+    return { gates, measurements: measurementsOf(measured) };
+  } catch (err) {
+    return { gates: [gate("frame time", "failed", `the conformance entry did not run: ${err.message}`)], measurements: null };
+  }
+}
+
+export { browserRequired, buildGates, economyGates, frameGates };