@h-ai/runner 0.0.0-stage → 1.0.0-beta.25

package/dist/index.js

@@ -0,0 +1,1982 @@
+import { z } from 'zod';
+import { Buffer } from 'buffer';
+import { randomUUID, createHash } from 'crypto';
+import { core, ok, err } from '@h-ai/core';
+import { execFile, spawn } from 'child_process';
+import { once } from 'events';
+import { lstat, chmod, rm, readFile, readlink, stat, realpath, mkdtemp, writeFile, mkdir } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join, posix, basename } from 'path';
+import { promisify } from 'util';
+import process from 'process';
+import { reldb } from '@h-ai/reldb';
+
+// src/runner-config.ts
+var id = z.string().min(1).max(100).regex(/^[\w.-]+$/u);
+var timeout = z.number().int().min(1).max(864e5);
+var resources = z.strictObject({
+  cpu: z.number().finite().positive().max(1024),
+  memoryMiB: z.number().int().min(16).max(2097152),
+  pids: z.number().int().min(1).max(1048576),
+  scratchMiB: z.number().int().min(3).max(2097152)
+});
+var environment = z.strictObject({
+  id,
+  image: z.string().max(255).regex(/^(?:[\w.:/-]+@)?sha256:[a-f\d]{64}$/u),
+  backend: z.literal("container").default("container"),
+  architecture: z.enum(["x64", "arm64"]).optional(),
+  capabilities: z.array(id).max(64).default([]),
+  resources,
+  networkPolicy: z.enum(["offline", "internal"]).default("offline"),
+  network: id.optional()
+}).refine((value) => value.networkPolicy === "offline" ? !value.network : !!value.network && ![
+  "host",
+  "bridge",
+  "none",
+  "default",
+  "podman"
+].includes(value.network));
+var RunnerConfigSchema = z.strictObject({
+  nodeId: id,
+  executor: z.boolean().default(true),
+  engine: z.enum(["podman", "docker"]).default("podman"),
+  capacity: resources.default({
+    cpu: 4,
+    memoryMiB: 4096,
+    pids: 512,
+    scratchMiB: 2048
+  }),
+  /** 每个执行节点独立预留给工具作业的资源；宿主总预算须同时覆盖 capacity 和本项。 */
+  toolCapacity: resources.default({
+    cpu: 1,
+    memoryMiB: 1024,
+    pids: 128,
+    scratchMiB: 512
+  }),
+  /** 每个执行节点的工具作业总并发，包括等待清理及未核验的作业，默认 4。 */
+  toolMaxRunning: z.number().int().min(1).max(1e3).default(4),
+  leaseMs: z.number().int().min(1e3).max(12e4).default(1e4),
+  pollMs: z.number().int().min(10).max(1e3).default(50),
+  maxRunning: z.number().int().min(1).max(1e3).default(8),
+  maxRunningPerScope: z.number().int().min(1).max(1e3).default(4),
+  maxControlRunning: z.number().int().min(1).max(1e3).default(8),
+  maxQueued: z.number().int().min(1).max(1e5).default(5e3),
+  maxEvents: z.number().int().min(1).max(1e5).default(1e4),
+  /** 已结算任务、事件和幂等键的保留期限。未核验的 unknown 不受该期限影响。 */
+  retentionMs: z.number().int().min(36e5).max(365 * 864e5).default(7 * 864e5),
+  closeTimeoutMs: z.number().int().min(100).max(12e4).default(2e4),
+  environments: z.array(environment).max(1e3).default([])
+}).refine((value) => value.pollMs * 3 < value.leaseMs && new Set(value.environments.map((entry) => entry.id)).size === value.environments.length);
+var json = z.json();
+var submitSchema = z.strictObject({
+  scope: z.strictObject({
+    tenantId: z.string().min(1).max(200),
+    userId: z.string().min(1).max(200)
+  }),
+  kind: id,
+  input: json,
+  idempotencyKey: z.string().min(1).max(200).optional(),
+  environmentId: id.optional(),
+  resources: resources.partial().optional(),
+  nodeId: id.optional(),
+  parentId: z.string().regex(/^[\da-f]{64}$/u).optional(),
+  /** 仅可信服务提交工具类别；其节点资源与普通 Worker 分开核算。 */
+  capacityClass: z.enum(["default", "tool"]).default("default"),
+  /** 使用已登记服务的单次预热池。 */
+  warmPool: z.literal(true).optional(),
+  /** 同一 kind + key 的跨节点上限，部署变更期间采用最小活动值。 */
+  concurrency: z.strictObject({
+    key: id,
+    limit: z.number().int().min(1).max(1e3)
+  }).optional(),
+  reuseKey: z.string().min(1).max(200).optional(),
+  queueTimeoutMs: timeout.default(3e5),
+  runTimeoutMs: timeout.default(3e5)
+}).refine((value) => !value.parentId || !value.nodeId && !value.environmentId && !value.resources && !value.reuseKey && value.capacityClass === "default" && !value.concurrency).refine((value) => !value.warmPool || value.capacityClass === "tool" && value.environmentId && value.concurrency && !value.resources);
+var warmPoolSchema = z.strictObject({
+  key: id,
+  kind: id,
+  environmentId: id,
+  minReady: z.number().int().min(0).max(1e3),
+  maxRunning: z.number().int().min(1).max(1e3),
+  maxTotal: z.number().int().min(1).max(1e3)
+}).refine((value) => value.minReady <= value.maxTotal && value.maxRunning <= value.maxTotal);
+var runnerKind = id;
+
+// messages/en-US.json
+var en_US_default = {
+  runner_notInitialized: "Runner is not initialized",
+  runner_alreadyInitialized: "Runner is already initialized or starting",
+  runner_invalid: "Invalid execution options",
+  runner_notFound: "Execution or environment not found",
+  runner_conflict: "The execution key has different options or execution state changed",
+  runner_unavailable: "Managed execution is unavailable",
+  runner_capacity: "Execution queue or resource limit reached",
+  runner_leaseLost: "The execution lease expired",
+  runner_cleanupUnconfirmed: "Unable to verify release of all execution resources"
+};
+
+// messages/ja-JP.json
+var ja_JP_default = {
+  runner_notInitialized: "Runner \u306F\u521D\u671F\u5316\u3055\u308C\u3066\u3044\u307E\u305B\u3093",
+  runner_alreadyInitialized: "Runner \u306F\u8D77\u52D5\u4E2D\u307E\u305F\u306F\u521D\u671F\u5316\u6E08\u307F\u3067\u3059",
+  runner_invalid: "\u5B9F\u884C\u30AA\u30D7\u30B7\u30E7\u30F3\u304C\u7121\u52B9\u3067\u3059",
+  runner_notFound: "\u5B9F\u884C\u30BF\u30B9\u30AF\u307E\u305F\u306F\u5B9F\u884C\u74B0\u5883\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+  runner_conflict: "\u5B9F\u884C\u30AD\u30FC\u306E\u30AA\u30D7\u30B7\u30E7\u30F3\u304C\u7570\u306A\u308B\u304B\u3001\u5B9F\u884C\u72B6\u614B\u304C\u5909\u66F4\u3055\u308C\u307E\u3057\u305F",
+  runner_unavailable: "\u5B9F\u884C\u30B5\u30FC\u30D3\u30B9\u3092\u5229\u7528\u3067\u304D\u307E\u305B\u3093",
+  runner_capacity: "\u5B9F\u884C\u30AD\u30E5\u30FC\u307E\u305F\u306F\u30EA\u30BD\u30FC\u30B9\u306E\u4E0A\u9650\u306B\u9054\u3057\u307E\u3057\u305F",
+  runner_leaseLost: "\u5B9F\u884C\u306E\u30EA\u30FC\u30B9\u304C\u671F\u9650\u5207\u308C\u3067\u3059",
+  runner_cleanupUnconfirmed: "\u5B9F\u884C\u30EA\u30BD\u30FC\u30B9\u306E\u89E3\u653E\u3092\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093"
+};
+
+// messages/zh-CN.json
+var zh_CN_default = {
+  runner_notInitialized: "Runner \u5C1A\u672A\u521D\u59CB\u5316",
+  runner_alreadyInitialized: "Runner \u6B63\u5728\u521D\u59CB\u5316\u6216\u5DF2\u7ECF\u542F\u52A8",
+  runner_invalid: "\u8FD0\u884C\u53C2\u6570\u65E0\u6548",
+  runner_notFound: "\u672A\u627E\u5230\u6267\u884C\u4EFB\u52A1\u6216\u8FD0\u884C\u73AF\u5883",
+  runner_conflict: "\u76F8\u540C\u6267\u884C\u6807\u8BC6\u5DF2\u7ED1\u5B9A\u4E0D\u540C\u8BF7\u6C42\uFF0C\u6216\u8FD0\u884C\u72B6\u6001\u53D1\u751F\u53D8\u5316",
+  runner_unavailable: "\u6267\u884C\u670D\u52A1\u6682\u65F6\u4E0D\u53EF\u7528",
+  runner_capacity: "\u8FD0\u884C\u961F\u5217\u6216\u8D44\u6E90\u4E0A\u9650\u5DF2\u8FBE\u5230",
+  runner_leaseLost: "\u5F53\u524D\u6267\u884C\u79DF\u7EA6\u5DF2\u5931\u6548",
+  runner_cleanupUnconfirmed: "\u65E0\u6CD5\u786E\u8BA4\u6240\u6709\u8FD0\u884C\u8D44\u6E90\u5747\u5DF2\u91CA\u653E"
+};
+
+// src/runner-i18n.ts
+var runnerM = core.i18n.createMessageGetter({ "zh-CN": zh_CN_default, "en-US": en_US_default, "ja-JP": ja_JP_default });
+var HaiRunnerError = core.error.buildHaiErrorsDef("runner", {
+  NOT_INITIALIZED: "010:503",
+  ALREADY_INITIALIZED: "011:409",
+  INVALID: "020:400",
+  NOT_FOUND: "021:404",
+  CONFLICT: "022:409",
+  UNAVAILABLE: "023:503",
+  CAPACITY: "024:429",
+  LEASE_LOST: "025:409",
+  CLEANUP_UNCONFIRMED: "026:503"
+});
+
+// src/runner-container.ts
+var execute = promisify(execFile);
+var containerId = /^[\da-f]{64}$/u;
+var envKey = /^[A-Z_]\w*$/iu;
+var MAX_FILE_BYTES = 50 * 1024 * 1024;
+var artifactName = /^[\da-z][\w.-]{0,127}$/iu;
+var fileName = /^[\w.][\w.-]{0,95}$/u;
+var argument = z.string().max(8192).refine((value) => !value.includes("\0"));
+var launchSchema = z.strictObject({
+  command: argument.refine((value) => value.length > 0 && !value.startsWith("-")),
+  args: z.array(argument).max(128).default([]),
+  env: z.record(z.string().regex(envKey), z.string().max(64e3).refine((value) => !/[\r\n\0]/u.test(value))).default({}),
+  files: z.record(z.string().regex(fileName).refine((value) => value !== "." && value !== ".."), z.string().max(128e3)).default({}),
+  inputs: z.record(z.string().regex(artifactName), z.string().max(4 * Math.ceil(MAX_FILE_BYTES / 3))).optional(),
+  cwd: z.string().max(1024).default("/workspace")
+});
+var READ_ARTIFACT = `
+import os, stat, sys
+root = os.open('/output', os.O_DIRECTORY | os.O_NOFOLLOW)
+fd = os.open(sys.argv[1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=root)
+limit = int(sys.argv[2])
+meta = os.fstat(fd)
+if not stat.S_ISREG(meta.st_mode) or meta.st_size > limit:
+    raise SystemExit(2)
+with os.fdopen(fd, 'rb') as item:
+    remaining = limit + 1
+    while remaining > 0:
+        data = item.read(min(65536, remaining))
+        if not data:
+            break
+        remaining -= len(data)
+        if remaining == 0:
+            raise SystemExit(2)
+        sys.stdout.buffer.write(data)
+`;
+async function cli(engine, args) {
+  const result = await execute(engine, args, { timeout: 15e3, maxBuffer: 65536, windowsHide: true });
+  return result.stdout.trim();
+}
+function invalid() {
+  return err(HaiRunnerError.INVALID, runnerM("runner_invalid"));
+}
+function unavailable() {
+  return err(HaiRunnerError.UNAVAILABLE, runnerM("runner_unavailable"));
+}
+function uncertain() {
+  return err(HaiRunnerError.CLEANUP_UNCONFIRMED, runnerM("runner_cleanupUnconfirmed"));
+}
+var stageName = /^hai-runner-[a-z\d]{6}$/iu;
+async function stagingRoot() {
+  const path = await realpath(tmpdir());
+  const info = await stat(path, { bigint: true });
+  return { path, key: `${path}:${info.dev}:${info.ino}` };
+}
+async function engineKey(engine) {
+  const root = await stagingRoot();
+  const host = (await readFile("/etc/machine-id", "utf8")).trim();
+  if (!/^[\da-f]{32}$/u.test(host))
+    throw new Error("Host identity unavailable");
+  const value = engine === "podman" ? await cli(engine, ["info", "--format", "{{.Host.ServiceIsRemote}} {{.Store.GraphRoot}}"]) : await cli(engine, ["info", "--format", "{{.ID}}"]);
+  if (engine === "podman") {
+    if (!value.startsWith("false "))
+      throw new Error("Podman identity unavailable");
+    const storage = await stat(value.slice(6), { bigint: true });
+    return createHash("sha256").update(JSON.stringify([
+      host,
+      engine,
+      root.key,
+      value,
+      String(storage.dev),
+      String(storage.ino)
+    ])).digest("hex");
+  }
+  if (!value || value === "<no value>")
+    throw new Error("Docker identity unavailable");
+  return createHash("sha256").update(JSON.stringify([host, engine, root.key, value])).digest("hex");
+}
+async function containerAbsent(engine, id2) {
+  return !await cli(engine, [
+    "container",
+    "ls",
+    "--all",
+    "--no-trunc",
+    "--filter",
+    `id=${id2}`,
+    "--format",
+    "{{.ID}}"
+  ]);
+}
+async function identityOf(path) {
+  const info = await lstat(path, { bigint: true });
+  if (!info.isDirectory())
+    throw new Error("Runner staging path is invalid");
+  return `${info.dev}:${info.ino}`;
+}
+async function confirmContainerReleased(record) {
+  if (!containerId.test(record.id) || !stageName.test(record.stageName))
+    return uncertain();
+  try {
+    if (record.engineKey !== await engineKey(record.engine) || !await containerAbsent(record.engine, record.id))
+      return uncertain();
+    const path = join((await stagingRoot()).path, record.stageName);
+    let actual;
+    try {
+      actual = await identityOf(path);
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+        return uncertain();
+    }
+    if (actual) {
+      if (actual !== record.stageKey)
+        return uncertain();
+      for (const name of ["input", "configuration"]) {
+        const directory = join(path, name);
+        try {
+          if (!(await lstat(directory)).isDirectory())
+            return uncertain();
+          await chmod(directory, 448);
+        } catch (error) {
+          if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+            return uncertain();
+        }
+      }
+      await rm(path, { recursive: true, force: true });
+    }
+    return record.engineKey === await engineKey(record.engine) && await containerAbsent(record.engine, record.id) ? ok(void 0) : uncertain();
+  } catch {
+    return uncertain();
+  }
+}
+var STANDBY = `
+import json, os, sys
+if os.listdir('/input') or os.listdir('/output'):
+    raise SystemExit(2)
+os.write(1, b'+')
+if os.read(0, 1) != b'+':
+    raise SystemExit(2)
+with open('/run/hai-config/warm-launch.json', 'rb') as configuration:
+    data = configuration.read(524289)
+if len(data) > 524288:
+    raise SystemExit(2)
+command, *args = json.loads(data)
+os.execvp(command, [command, *args])
+`;
+function decodeInputs(inputs, resources2) {
+  const budget = Math.min(MAX_FILE_BYTES, resources2.scratchMiB * 1024 * 1024);
+  const entries = Object.entries(inputs);
+  if (entries.length > 8 || entries.reduce((total, [, value]) => total + value.length, 0) > 4 * Math.ceil(budget / 3) + 24)
+    return void 0;
+  const decoded = entries.map(([name, value]) => ({
+    name,
+    value,
+    bytes: Buffer.from(value, "base64")
+  }));
+  return decoded.some((item) => item.bytes.toString("base64") !== item.value) || decoded.reduce((total, item) => total + item.bytes.length, 0) > budget ? void 0 : decoded;
+}
+async function startContainer(engine, environment2, resources2, launch, signal, record, warm = false) {
+  const parsed = launchSchema.safeParse(launch);
+  if (!parsed.success || signal.aborted)
+    return invalid();
+  const options = parsed.data;
+  const cwd = posix.normalize(options.cwd);
+  if (cwd !== options.cwd || cwd !== "/workspace" && !cwd.startsWith("/workspace/") || cwd.includes("\0") || Object.keys(options.env).length > 128 || Object.keys(options.files).length > 32) {
+    return invalid();
+  }
+  const decoded = options.inputs === void 0 ? void 0 : decodeInputs(options.inputs, resources2);
+  if (options.inputs && !decoded)
+    return invalid();
+  let temporary;
+  let id2;
+  let envFile;
+  const readOnlyDirs = [];
+  let creationStarted = false;
+  async function removeContainer(container) {
+    try {
+      await cli(engine, [
+        "container",
+        "rm",
+        "--force",
+        "--volumes",
+        ...engine === "podman" ? ["--time", "1"] : [],
+        container
+      ]);
+    } catch {
+    }
+    try {
+      return await containerAbsent(engine, container);
+    } catch {
+      return false;
+    }
+  }
+  async function removeFiles() {
+    await Promise.all(readOnlyDirs.map((dir) => chmod(dir, 448)));
+    if (temporary)
+      await rm(temporary, { recursive: true, force: true });
+  }
+  try {
+    const mode = engine === "podman" ? await cli(engine, ["info", "--format", '{{.Host.CgroupsVersion}} {{join .Host.CgroupControllers ","}}']) : await cli(engine, ["info", "--format", "{{.OSType}} {{.CgroupVersion}} {{.CPUCfsQuota}} {{.MemoryLimit}} {{.PidsLimit}}"]);
+    if (engine === "podman" ? !mode.startsWith("v2 ") || !["cpu", "memory", "pids"].every((name) => mode.slice(3).split(",").includes(name)) : mode !== "linux 2 true true true") {
+      return unavailable();
+    }
+    const imageVolumes = await cli(engine, [
+      "image",
+      "inspect",
+      "--format",
+      "{{json .Config.Volumes}}",
+      environment2.image
+    ]);
+    if (imageVolumes !== "null" && imageVolumes !== "{}")
+      return unavailable();
+    if (environment2.networkPolicy === "internal") {
+      const isolated = await cli(engine, [
+        "network",
+        "inspect",
+        "--format",
+        "{{.Internal}}",
+        environment2.network
+      ]);
+      if (isolated !== "true")
+        return unavailable();
+    }
+    const key = await engineKey(engine);
+    temporary = await mkdtemp(join((await stagingRoot()).path, "hai-runner-"));
+    envFile = join(temporary, "environment");
+    const files = join(temporary, "configuration");
+    await writeFile(envFile, Object.entries({
+      HOME: "/state",
+      XDG_CACHE_HOME: "/state/cache",
+      XDG_CONFIG_HOME: "/state/config",
+      TMPDIR: "/tmp",
+      ...options.env
+    }).map(([key2, value]) => `${key2}=${value}`).join("\n"), { mode: 384, flag: "wx" });
+    await mkdir(files);
+    readOnlyDirs.push(files);
+    await Promise.all(Object.entries(options.files).map(([name, content]) => writeFile(join(files, name), content, { mode: 292, flag: "wx" })));
+    await chmod(files, 365);
+    const inputDir = join(temporary, "input");
+    if (decoded) {
+      await mkdir(inputDir);
+      readOnlyDirs.push(inputDir);
+      await Promise.all(decoded.map((item) => writeFile(join(inputDir, item.name), item.bytes, { mode: 292, flag: "wx" })));
+      await chmod(inputDir, 365);
+    }
+    if (signal.aborted) {
+      await removeFiles();
+      return invalid();
+    }
+    const state = Math.max(1, Math.floor(resources2.scratchMiB / 8));
+    const workspace = Math.max(1, Math.floor(resources2.scratchMiB / (decoded ? 8 : 2)));
+    const output = decoded ? Math.max(1, Math.floor(resources2.scratchMiB / 2)) : 0;
+    const scratch = resources2.scratchMiB - state - workspace - output;
+    if (scratch < 1) {
+      await removeFiles();
+      return invalid();
+    }
+    const mounts = [
+      ["state", state],
+      ["workspace", workspace],
+      ["tmp", scratch],
+      ...decoded ? [
+        ["output", output]
+      ] : []
+    ].flatMap(([name, size]) => ["--tmpfs", `/${name}:rw,nosuid,nodev,mode=1777,size=${size}m`]);
+    creationStarted = true;
+    const created = await cli(engine, [
+      "container",
+      "create",
+      "--pull=never",
+      "--interactive",
+      "--user=1000:1000",
+      "--read-only",
+      "--cap-drop=ALL",
+      "--security-opt=no-new-privileges",
+      "--cgroupns=private",
+      "--ipc=private",
+      "--shm-size=1m",
+      `--cpus=${resources2.cpu}`,
+      `--memory=${resources2.memoryMiB}m`,
+      `--memory-swap=${resources2.memoryMiB}m`,
+      `--pids-limit=${resources2.pids}`,
+      `--network=${environment2.network ?? "none"}`,
+      ...engine === "podman" ? ["--read-only-tmpfs=false", "--http-proxy=false"] : [],
+      "--env-file",
+      envFile,
+      "--mount",
+      `type=bind,source=${files},target=/run/hai-config,readonly`,
+      ...mounts,
+      ...decoded ? ["--mount", `type=bind,source=${inputDir},target=/input,readonly`] : [],
+      "--entrypoint=/bin/sh",
+      environment2.image,
+      "-c",
+      'cp -R /run/hai-config/. /state/ && cd "$1" && shift && exec "$@"',
+      "hai-runner",
+      cwd,
+      options.command,
+      ...options.args
+    ]);
+    if (!containerId.test(created))
+      return uncertain();
+    id2 = created;
+    await rm(envFile, { force: true });
+    const receipt = await record({
+      id: id2,
+      engine,
+      engineKey: key,
+      stageName: basename(temporary),
+      stageKey: await identityOf(temporary)
+    });
+    if (signal.aborted || !receipt.success) {
+      const stopped = await removeContainer(id2);
+      if (stopped)
+        await removeFiles();
+      if (!stopped)
+        return uncertain();
+      return receipt.success ? invalid() : receipt;
+    }
+    const child = spawn(engine, [
+      "container",
+      "start",
+      "--attach",
+      "--interactive",
+      id2
+    ], { stdio: "pipe", windowsHide: true });
+    child.stdin.on("error", () => {
+    });
+    const completion = new Promise((resolve) => {
+      child.once("error", () => resolve({ code: null, signal: null }));
+      child.once("close", (code, exited) => resolve({ code, signal: exited }));
+    });
+    let closing;
+    const stop = () => {
+      closing ??= (async () => {
+        if (!await removeContainer(created))
+          return uncertain();
+        child.kill();
+        try {
+          await removeFiles();
+          return ok(void 0);
+        } catch {
+          return uncertain();
+        }
+      })();
+      return closing;
+    };
+    let activated = false;
+    const process3 = {
+      stdin: child.stdin,
+      stdout: child.stdout,
+      stderr: child.stderr,
+      wait: () => completion,
+      async activate(launch2, activationSignal, authorize) {
+        if (!warm || activated || closing || activationSignal.aborted)
+          return invalid();
+        activated = true;
+        const parsed2 = launchSchema.safeParse(launch2);
+        if (!parsed2.success || parsed2.data.cwd !== "/workspace" || Object.keys(parsed2.data.env).length || Object.keys(parsed2.data.files).length || !parsed2.data.inputs) {
+          return invalid();
+        }
+        const staged = decodeInputs(parsed2.data.inputs, resources2);
+        const request = JSON.stringify([parsed2.data.command, ...parsed2.data.args]);
+        if (!staged || Buffer.byteLength(request) > 524288)
+          return invalid();
+        try {
+          await chmod(inputDir, 493);
+          await chmod(files, 493);
+          const writes = await Promise.allSettled([
+            ...staged.map((item) => writeFile(join(inputDir, item.name), item.bytes, { mode: 292, flag: "wx" })),
+            writeFile(join(files, "warm-launch.json"), request, { mode: 292, flag: "wx" })
+          ]);
+          await chmod(inputDir, 365);
+          await chmod(files, 365);
+          if (writes.some((item) => item.status === "rejected") || !await authorize() || activationSignal.aborted || closing)
+            return invalid();
+          await new Promise((resolve, reject) => {
+            child.stdin.write("+", (error) => error ? reject(error) : resolve());
+          });
+          return ok(process3);
+        } catch {
+          return unavailable();
+        }
+      },
+      async artifact(name, maxBytes) {
+        if (!decoded || closing || signal.aborted || !artifactName.test(name) || !Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > MAX_FILE_BYTES) {
+          return invalid();
+        }
+        try {
+          const { stdout } = await execute(engine, [
+            "container",
+            "exec",
+            "--user=1000:1000",
+            created,
+            "/usr/bin/python3",
+            "-I",
+            "-S",
+            "-c",
+            READ_ARTIFACT,
+            name,
+            String(maxBytes)
+          ], {
+            encoding: "buffer",
+            timeout: 15e3,
+            maxBuffer: maxBytes,
+            windowsHide: true,
+            signal
+          });
+          return stdout.length <= maxBytes ? ok(stdout.toString("base64")) : invalid();
+        } catch {
+          return invalid();
+        }
+      },
+      close: stop
+    };
+    if (warm) {
+      const readySignal = AbortSignal.any([
+        signal,
+        AbortSignal.timeout(15e3)
+      ]);
+      try {
+        const [chunk] = await once(child.stdout, "data", { signal: readySignal });
+        child.stdout.pause();
+        if (!Buffer.isBuffer(chunk) || chunk.length !== 1 || chunk[0] !== 43)
+          throw new Error("Invalid warm readiness");
+      } catch {
+        return (await stop()).success ? unavailable() : uncertain();
+      }
+    }
+    return ok(process3);
+  } catch {
+    if (envFile) {
+      try {
+        await rm(envFile, { force: true });
+      } catch {
+      }
+    }
+    if (id2 && await removeContainer(id2))
+      creationStarted = false;
+    if (!creationStarted) {
+      try {
+        await removeFiles();
+      } catch {
+        return uncertain();
+      }
+    }
+    return creationStarted ? uncertain() : unavailable();
+  }
+}
+async function prepareWarmContainer(engine, environment2, signal, record) {
+  if (environment2.networkPolicy !== "offline")
+    return invalid();
+  return startContainer(engine, environment2, environment2.resources, {
+    command: "/usr/bin/python3",
+    args: ["-I", "-S", "-c", STANDBY],
+    inputs: {}
+  }, signal, record, true);
+}
+var processIdentity = z.strictObject({
+  pid: z.number().int().positive().max(2 ** 31 - 1),
+  hostKey: z.string().regex(/^[a-f\d]{64}$/u),
+  started: z.string().regex(/^\d+$/u).max(20)
+});
+async function hostKey() {
+  const [machine, boot, namespace] = await Promise.all([
+    readFile("/etc/machine-id", "utf8"),
+    readFile("/proc/sys/kernel/random/boot_id", "utf8"),
+    readlink("/proc/self/ns/pid")
+  ]);
+  if (!/^[a-f\d]{32}$/u.test(machine.trim()) || !/^[a-f\d-]{36}$/u.test(boot.trim()) || !/^pid:\[\d+\]$/u.test(namespace)) {
+    throw new Error("Runner host identity unavailable");
+  }
+  return createHash("sha256").update(JSON.stringify([
+    machine.trim(),
+    boot.trim(),
+    namespace
+  ])).digest("hex");
+}
+async function startTime(pid) {
+  const raw = await readFile(`/proc/${pid}/stat`, "utf8");
+  const index = raw.lastIndexOf(") ");
+  const field = index < 0 ? void 0 : raw.slice(index + 2).split(/\s+/u)[19];
+  if (!field || !/^\d+$/u.test(field))
+    throw new Error("Runner process identity unavailable");
+  return field;
+}
+async function readRunnerProcess() {
+  if (process.platform !== "linux")
+    return void 0;
+  try {
+    const [host, started] = await Promise.all([
+      hostKey(),
+      startTime(process.pid)
+    ]);
+    return { pid: process.pid, hostKey: host, started };
+  } catch {
+    return void 0;
+  }
+}
+async function confirmRunnerProcessReleased(identity) {
+  const record = processIdentity.safeParse(identity);
+  if (!record.success || process.platform !== "linux")
+    return false;
+  const { pid, hostKey: previous, started } = record.data;
+  try {
+    if (previous !== await hostKey())
+      return false;
+    try {
+      return await startTime(pid) !== started;
+    } catch (error) {
+      if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+        return false;
+      try {
+        process.kill(pid, 0);
+        return false;
+      } catch (cause) {
+        return cause instanceof Error && "code" in cause && cause.code === "ESRCH";
+      }
+    }
+  } catch {
+    return false;
+  }
+}
+var EXECUTIONS = "hai_runner_executions";
+var EVENTS = "hai_runner_events";
+var GATE = "hai_runner_gate";
+var ACTIVE = "(state IN ('running', 'cancelling') OR (state = 'unknown' AND reconciled_at IS NULL))";
+var RETENTION_STATES = [
+  "succeeded",
+  "failed",
+  "cancelled",
+  "unknown"
+];
+var RETENTION_BATCH = 128;
+var MAX_EVENT_BYTES = 16 * 1024 * 1024;
+var text = { type: "TEXT", notNull: true };
+var nullableText = { type: "TEXT" };
+var integer = { type: "BIGINT", notNull: true };
+var payload = { type: "JSON" };
+var executions = {
+  id: { ...text, primaryKey: true },
+  scope_key: text,
+  reuse_key: { ...nullableText, unique: true },
+  request_key: text,
+  kind: text,
+  request_json: payload,
+  environment_key: nullableText,
+  state: text,
+  reason: nullableText,
+  owner_node: nullableText,
+  owner_generation: nullableText,
+  owner_process_json: payload,
+  pinned_node: nullableText,
+  pinned_generation: nullableText,
+  parent_id: nullableText,
+  leased_until: integer,
+  queue_until: integer,
+  run_until: integer,
+  event_sequence: integer,
+  event_bytes: { ...integer, defaultValue: 0 },
+  cpu_milli: integer,
+  memory_mib: integer,
+  pids: integer,
+  scratch_mib: integer,
+  result_json: payload,
+  created_at: integer,
+  updated_at: integer,
+  container_json: payload,
+  reconciliation_json: payload,
+  reconciled_at: { type: "BIGINT" },
+  capacity_class: text,
+  concurrency_key: nullableText,
+  concurrency_limit: integer,
+  pool_fingerprint: nullableText,
+  pool_limit: { type: "BIGINT" },
+  warm_state: nullableText
+};
+function clock() {
+  if (reldb.config?.type === "postgresql")
+    return "CAST(FLOOR(EXTRACT(EPOCH FROM clock_timestamp()) * 1000) AS BIGINT)";
+  if (reldb.config?.type === "mysql")
+    return "CAST(UNIX_TIMESTAMP(SYSDATE(3)) * 1000 AS UNSIGNED)";
+  return "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+}
+function canonical(value) {
+  if (Array.isArray(value))
+    return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function hash(value) {
+  return createHash("sha256").update(canonical(value)).digest("hex");
+}
+function databaseValue(value) {
+  return typeof value === "string" ? JSON.parse(value) : value;
+}
+function project(row, environmentId) {
+  return {
+    id: row.id,
+    status: row.state,
+    owner: row.owner_node && row.owner_generation ? { nodeId: row.owner_node, generation: row.owner_generation } : void 0,
+    environmentId,
+    output: row.result_json === null ? void 0 : databaseValue(row.result_json).value,
+    failure: row.reason ?? void 0,
+    createdAt: Number(row.created_at),
+    updatedAt: Number(row.updated_at),
+    reconciledAt: row.reconciled_at === null ? void 0 : Number(row.reconciled_at)
+  };
+}
+function projectRequest(row) {
+  return project(row, databaseValue(row.request_json).environment?.id);
+}
+function unavailable2() {
+  return err(HaiRunnerError.UNAVAILABLE, runnerM("runner_unavailable"));
+}
+function lost() {
+  return err(HaiRunnerError.LEASE_LOST, runnerM("runner_leaseLost"));
+}
+function missing() {
+  return err(HaiRunnerError.NOT_FOUND, runnerM("runner_notFound"));
+}
+function conflict() {
+  return err(HaiRunnerError.CONFLICT, runnerM("runner_conflict"));
+}
+function overflow() {
+  return err(HaiRunnerError.CAPACITY, runnerM("runner_capacity"));
+}
+function data(result) {
+  if (!result.success)
+    throw new Error("Runner database operation failed", { cause: result.error });
+  return result.data;
+}
+async function serialized(action) {
+  const response = await reldb.tx.wrap(async (tx) => {
+    data(await tx.execute(`UPDATE ${GATE} SET revision = revision + 1 WHERE id = 1`));
+    return action(tx);
+  });
+  return response.success ? response.data : unavailable2();
+}
+async function find(sql, id2, scopeKey) {
+  return data(await sql.get(`SELECT * FROM ${EXECUTIONS} WHERE id = ? AND scope_key = ?`, [id2, scopeKey]));
+}
+function columns(resources2) {
+  return resources2 ? [
+    Math.ceil(resources2.cpu * 1e3),
+    resources2.memoryMiB,
+    resources2.pids,
+    resources2.scratchMiB
+  ] : [0, 0, 0, 0];
+}
+function within(actual, ceiling) {
+  return actual.cpu <= ceiling.cpu && actual.memoryMiB <= ceiling.memoryMiB && actual.pids <= ceiling.pids && actual.scratchMiB <= ceiling.scratchMiB;
+}
+async function readyStore() {
+  if (!reldb.isInitialized)
+    return unavailable2();
+  const addedColumns = ["event_bytes", "owner_process_json"];
+  for (const [name, def] of [
+    [
+      GATE,
+      {
+        id: { ...integer, primaryKey: true },
+        revision: integer
+      }
+    ],
+    [EXECUTIONS, executions],
+    [
+      EVENTS,
+      {
+        id: { ...text, primaryKey: true },
+        execution_id: text,
+        sequence_number: integer,
+        event_json: payload,
+        created_at: integer
+      }
+    ]
+  ]) {
+    const result = await reldb.ddl.createTable(name, def);
+    if (!result.success) {
+      const existing2 = await reldb.schemaColumns(name);
+      if (!existing2.success || Object.keys(def).some((column) => !existing2.data.includes(column) && !(name === EXECUTIONS && addedColumns.includes(column))))
+        return unavailable2();
+    }
+  }
+  const existing = await reldb.schemaColumns(EXECUTIONS);
+  if (!existing.success)
+    return unavailable2();
+  for (const column of addedColumns.filter((column2) => !existing.data.includes(column2))) {
+    const added = await reldb.ddl.addColumn(EXECUTIONS, column, executions[column]);
+    if (!added.success) {
+      const refreshed = await reldb.schemaColumns(EXECUTIONS);
+      if (!refreshed.success || !refreshed.data.includes(column))
+        return unavailable2();
+    }
+  }
+  for (const [table, name, fields] of [
+    [
+      EXECUTIONS,
+      "hai_runner_queue_idx",
+      ["state", "kind", "created_at"]
+    ],
+    [
+      EXECUTIONS,
+      "hai_runner_owner_idx",
+      ["owner_node", "state", "leased_until"]
+    ],
+    [
+      EXECUTIONS,
+      "hai_runner_scope_idx",
+      ["scope_key", "capacity_class", "state"]
+    ],
+    [
+      EXECUTIONS,
+      "hai_runner_concurrency_idx",
+      ["concurrency_key", "state"]
+    ],
+    [
+      EXECUTIONS,
+      "hai_runner_parent_idx",
+      ["parent_id"]
+    ],
+    [
+      EXECUTIONS,
+      "hai_runner_retention_idx",
+      [
+        "state",
+        "reconciled_at",
+        "updated_at",
+        "id"
+      ]
+    ],
+    [
+      EXECUTIONS,
+      "hai_runner_queue_due_idx",
+      ["state", "queue_until"]
+    ],
+    [
+      EXECUTIONS,
+      "hai_runner_lease_due_idx",
+      ["state", "leased_until"]
+    ],
+    [
+      EXECUTIONS,
+      "hai_runner_run_due_idx",
+      ["state", "run_until"]
+    ],
+    [
+      EVENTS,
+      "hai_runner_event_cursor_idx",
+      ["execution_id", "sequence_number"]
+    ]
+  ]) {
+    const result = await reldb.ddl.createIndex(table, name, { columns: fields });
+    if (!result.success) {
+      if (reldb.config?.type !== "mysql")
+        return unavailable2();
+      const existing2 = await reldb.sql.query(
+        "SELECT COLUMN_NAME AS column_name FROM INFORMATION_SCHEMA.STATISTICS WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND INDEX_NAME = ? ORDER BY SEQ_IN_INDEX",
+        [table, name]
+      );
+      if (!existing2.success || JSON.stringify(existing2.data.map((row) => row.column_name)) !== JSON.stringify(fields))
+        return unavailable2();
+    }
+  }
+  const syntax = reldb.config?.type === "mysql" ? " ON DUPLICATE KEY UPDATE id = id" : " ON CONFLICT (id) DO NOTHING";
+  const seed = await reldb.sql.execute(`INSERT INTO ${GATE} (id, revision) VALUES (1, 0)${syntax}`);
+  return seed.success ? ok(void 0) : unavailable2();
+}
+function makeStore(config, owner, ownerProcess) {
+  const envById = new Map(config.environments.map((item) => [item.id, item]));
+  const envKeys = config.environments.filter((item) => !item.architecture || item.architecture === process.arch).map((item) => hash(item));
+  const now = clock();
+  const resultValue = reldb.config?.type === "postgresql" ? "CAST(? AS JSONB)" : reldb.config?.type === "mysql" ? "CAST(CONVERT(? USING utf8mb4) AS JSON)" : "?";
+  const statementTime = reldb.config?.type === "postgresql" ? "CAST(FLOOR(EXTRACT(EPOCH FROM statement_timestamp()) * 1000) AS BIGINT)" : reldb.config?.type === "mysql" ? "CAST(UNIX_TIMESTAMP(CURRENT_TIMESTAMP(3)) * 1000 AS SIGNED)" : now;
+  const processJson = ownerProcess ? JSON.stringify(ownerProcess) : null;
+  const environmentPath = reldb.json.extract("request_json", "$.environment.id");
+  const environmentProjection = reldb.config?.type === "mysql" ? `JSON_UNQUOTE(${environmentPath.sql})` : reldb.config?.type === "postgresql" ? "request_json #>> ?::text[]" : environmentPath.sql;
+  async function summary(id2, scopeKey) {
+    const row = data(await reldb.sql.get(`
+      SELECT id, state, reason, owner_node, owner_generation, result_json, created_at, updated_at, reconciled_at,
+        ${environmentProjection} AS environment_id
+      FROM ${EXECUTIONS} WHERE id = ? AND scope_key = ?`, [...environmentPath.params, id2, scopeKey]));
+    return row ? project(row, row.environment_id ?? void 0) : void 0;
+  }
+  async function parentSettled(sql, row) {
+    if (!row.parent_id)
+      return true;
+    const parent = data(await sql.get(`
+      SELECT state, reconciled_at FROM ${EXECUTIONS}
+      WHERE id = ? AND owner_node = ? AND owner_generation = ? AND scope_key = ?`, [
+      row.parent_id,
+      row.owner_node,
+      row.owner_generation,
+      row.scope_key
+    ]));
+    return !!parent && (parent.state === "unknown" ? parent.reconciled_at !== null : ["succeeded", "failed", "cancelled"].includes(parent.state));
+  }
+  async function sweep(sql) {
+    data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'failed', reason = 'queue-timeout', reuse_key = NULL, updated_at = ${now}
+      WHERE state = 'queued' AND queue_until <= ${now}`));
+    data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'unknown', reason = 'owner-lost', updated_at = ${now}
+      WHERE state IN ('running', 'cancelling') AND leased_until <= ${now}`));
+    data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'cancelling', reason = 'run-timeout', updated_at = ${now}
+      WHERE state = 'running' AND run_until <= ${now} AND leased_until > ${now}`));
+  }
+  async function expired(sql, limit) {
+    const pages = await Promise.all(RETENTION_STATES.map((state) => {
+      const endedAt = state === "unknown" ? "q.reconciled_at" : "q.updated_at";
+      return sql.query(`
+        SELECT q.id, ${endedAt} AS ended_at FROM ${EXECUTIONS} q
+        WHERE q.state = ? AND q.reconciled_at ${state === "unknown" ? "IS NOT NULL" : "IS NULL"}
+          AND ${endedAt} <= ${statementTime} - ?
+          AND NOT EXISTS (SELECT 1 FROM ${EXECUTIONS} child WHERE child.parent_id = q.id)
+        ORDER BY ${endedAt}, q.updated_at, q.id LIMIT ?`, [state, config.retentionMs, limit]);
+    }));
+    return pages.flatMap((page) => data(page)).sort((left, right) => Number(left.ended_at) - Number(right.ended_at)).slice(0, limit);
+  }
+  return {
+    async sweep() {
+      const due = await reldb.sql.get(`
+        SELECT id FROM ${EXECUTIONS} WHERE (state = 'queued' AND queue_until <= ${statementTime})
+          OR (state IN ('running', 'cancelling') AND leased_until <= ${statementTime})
+          OR (state = 'running' AND run_until <= ${statementTime}) LIMIT 1`);
+      if (!due.success)
+        return unavailable2();
+      if (!due.data)
+        return ok(void 0);
+      return serialized(async (sql) => {
+        await sweep(sql);
+        return ok(void 0);
+      });
+    },
+    async prune() {
+      try {
+        if (!(await expired(reldb.sql, 1)).length)
+          return ok(0);
+      } catch {
+        return unavailable2();
+      }
+      return serialized(async (sql) => {
+        const entries = await expired(sql, RETENTION_BATCH);
+        if (!entries.length)
+          return ok(0);
+        const ids = entries.map((entry) => entry.id);
+        const keys = ids.map(() => "?").join(", ");
+        data(await sql.execute(`DELETE FROM ${EVENTS} WHERE execution_id IN (${keys})`, ids));
+        const removed = data(await sql.execute(`DELETE FROM ${EXECUTIONS} WHERE id IN (${keys})`, ids));
+        return ok(removed.changes);
+      });
+    },
+    async submit(request, pool) {
+      const scopeKey = hash([request.scope.tenantId, request.scope.userId]);
+      const id2 = hash([scopeKey, request.kind, request.idempotencyKey ?? randomUUID()]);
+      const reuse = request.reuseKey === void 0 ? null : hash([scopeKey, request.kind, request.reuseKey]);
+      const requestKey = hash({
+        kind: request.kind,
+        input: request.input,
+        environmentId: request.environmentId ?? null,
+        resources: request.resources ?? null,
+        parentId: request.parentId ?? null,
+        nodeId: request.nodeId ?? null,
+        queueTimeoutMs: request.queueTimeoutMs,
+        capacityClass: request.capacityClass,
+        concurrency: request.concurrency ?? null,
+        warmPool: pool ? { ...pool } : null,
+        runTimeoutMs: request.runTimeoutMs
+      });
+      return serialized(async (sql) => {
+        const existing = await find(sql, id2, scopeKey) ?? (reuse ? data(await sql.get(`SELECT * FROM ${EXECUTIONS} WHERE reuse_key = ?`, [reuse])) : null);
+        if (existing) {
+          return existing.request_key === requestKey ? ok(projectRequest(existing)) : conflict();
+        }
+        const environment2 = request.environmentId ? envById.get(request.environmentId) : void 0;
+        if (request.warmPool && (!pool || !environment2))
+          return missing();
+        if (request.environmentId && !environment2)
+          return missing();
+        const resources2 = environment2 ? {
+          ...environment2.resources,
+          ...request.resources
+        } : request.resources ? {
+          cpu: 1,
+          memoryMiB: 64,
+          pids: 16,
+          scratchMiB: 16,
+          ...request.resources
+        } : void 0;
+        if (environment2 && resources2 && !within(resources2, environment2.resources))
+          return overflow();
+        const parent = request.parentId ? await find(sql, request.parentId, scopeKey) : null;
+        if (request.parentId && (!parent || parent.state !== "running"))
+          return conflict();
+        const parentFilter = request.parentId ? "IS NOT NULL" : "IS NULL";
+        const queued = data(await sql.get(`SELECT COUNT(*) AS total FROM ${EXECUTIONS} WHERE state = 'queued' AND parent_id ${parentFilter}`));
+        if (Number(queued?.total) >= config.maxQueued)
+          return overflow();
+        const saved = {
+          scope: request.scope,
+          input: request.input,
+          environment: environment2,
+          resources: resources2,
+          runTimeoutMs: request.runTimeoutMs
+        };
+        data(await sql.execute(`INSERT INTO ${EXECUTIONS}
+          (id, scope_key, reuse_key, request_key, kind, request_json, environment_key, state, pinned_node, pinned_generation, parent_id,
+            leased_until, queue_until, run_until, event_sequence, cpu_milli, memory_mib, pids, scratch_mib, created_at, updated_at, capacity_class, concurrency_key, concurrency_limit, pool_fingerprint, pool_limit)
+          VALUES (?, ?, ?, ?, ?, ?, ?, 'queued', ?, ?, ?, 0, ${now} + ?, 0, 0, ?, ?, ?, ?, ${now}, ${now}, ?, ?, ?, ?, ?)`, [
+          id2,
+          scopeKey,
+          reuse,
+          requestKey,
+          request.kind,
+          JSON.stringify(saved),
+          environment2 ? hash(environment2) : null,
+          parent?.owner_node ?? request.nodeId ?? null,
+          parent?.owner_generation ?? null,
+          request.parentId ?? null,
+          request.queueTimeoutMs,
+          ...columns(resources2),
+          request.capacityClass,
+          request.concurrency ? hash([request.kind, request.concurrency.key]) : null,
+          request.concurrency?.limit ?? 0,
+          pool && environment2 ? hash({
+            pool: { ...pool },
+            environment: environment2
+          }) : null,
+          pool?.maxTotal ?? null
+        ]));
+        const row = await find(sql, id2, scopeKey);
+        if (!row)
+          throw new Error("Newly inserted execution could not be read");
+        return ok(projectRequest(row));
+      });
+    },
+    async find(scope, kind, key) {
+      try {
+        const scopeKey = hash([scope.tenantId, scope.userId]);
+        return ok(await summary(hash([scopeKey, kind, key]), scopeKey));
+      } catch {
+        return unavailable2();
+      }
+    },
+    async get(scope, id2) {
+      try {
+        const found = await summary(id2, hash([scope.tenantId, scope.userId]));
+        return found ? ok(found) : missing();
+      } catch {
+        return unavailable2();
+      }
+    },
+    async cancel(scope, id2) {
+      return serialized(async (sql) => {
+        const row = await find(sql, id2, hash([scope.tenantId, scope.userId]));
+        if (!row)
+          return missing();
+        data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'cancelled', reuse_key = NULL, updated_at = ${now} WHERE id = ? AND state = 'queued'`, [id2]));
+        data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'cancelling', updated_at = ${now} WHERE id = ? AND state = 'running'`, [id2]));
+        data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'cancelled', reason = 'parent-ended', updated_at = ${now} WHERE parent_id = ? AND state = 'queued'`, [id2]));
+        data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'cancelling', reason = 'parent-ended', updated_at = ${now} WHERE parent_id = ? AND state = 'running'`, [id2]));
+        const changed = await find(sql, id2, row.scope_key);
+        return changed ? ok(projectRequest(changed)) : missing();
+      });
+    },
+    async reserveWarm(pool) {
+      const environment2 = envById.get(pool.environmentId);
+      if (!environment2 || !pool.minReady || !envKeys.includes(hash(environment2)))
+        return ok(null);
+      const fingerprint = hash({
+        pool: { ...pool },
+        environment: environment2
+      });
+      const key = hash([pool.kind, pool.key]);
+      const usage = columns(environment2.resources);
+      async function canReserve(sql) {
+        const [totalsResult, reservedResult] = await Promise.all([
+          sql.get(`
+            SELECT COUNT(*) AS total, COALESCE(SUM(CASE WHEN state = 'running' AND pool_fingerprint = ?
+              AND warm_state IN ('starting','ready') THEN 1 ELSE 0 END),0) AS warm,
+              COALESCE(MIN(pool_limit), ?) AS ceiling
+            FROM ${EXECUTIONS} WHERE concurrency_key = ? AND ${ACTIVE}`, [fingerprint, pool.maxTotal, key]),
+          sql.get(`
+            SELECT COUNT(*) AS active, COALESCE(SUM(cpu_milli),0) AS cpu, COALESCE(SUM(memory_mib),0) AS memory,
+              COALESCE(SUM(pids),0) AS pids, COALESCE(SUM(scratch_mib),0) AS scratch
+            FROM ${EXECUTIONS} WHERE owner_node = ? AND capacity_class = 'tool' AND ${ACTIVE}`, [owner.nodeId])
+        ]);
+        const totals = data(totalsResult);
+        const reserved = data(reservedResult);
+        if (!totals || !reserved || Number(totals.warm) >= pool.minReady || Number(totals.total) >= Math.min(pool.maxTotal, Number(totals.ceiling)) || Number(reserved.active) >= config.toolMaxRunning) {
+          return false;
+        }
+        const capacity = columns(config.toolCapacity);
+        const occupied = [
+          Number(reserved.cpu),
+          Number(reserved.memory),
+          Number(reserved.pids),
+          Number(reserved.scratch)
+        ];
+        return !usage.some((amount, index) => amount + occupied[index] > capacity[index]);
+      }
+      try {
+        if (!await canReserve(reldb.sql))
+          return ok(null);
+      } catch {
+        return unavailable2();
+      }
+      return serialized(async (sql) => {
+        if (!await canReserve(sql))
+          return ok(null);
+        const id2 = hash([
+          owner.generation,
+          randomUUID()
+        ]);
+        const request = {
+          scope: { tenantId: "@runner", userId: "@warm" },
+          input: null,
+          environment: environment2,
+          resources: environment2.resources,
+          runTimeoutMs: 864e5
+        };
+        data(await sql.execute(`INSERT INTO ${EXECUTIONS}
+          (id, scope_key, request_key, kind, request_json, environment_key, state, owner_node, owner_generation,
+           leased_until, queue_until, run_until, event_sequence, cpu_milli, memory_mib, pids, scratch_mib,
+           created_at, updated_at, capacity_class, concurrency_key, concurrency_limit, pool_fingerprint, pool_limit, warm_state)
+          VALUES (?, ?, ?, ?, ?, ?, 'running', ?, ?, ${now} + ?, 0, ${now} + ?, 0, ?, ?, ?, ?,
+            ${now}, ${now}, 'tool', ?, ?, ?, ?, 'starting')`, [
+          id2,
+          hash(["@runner", "@warm"]),
+          id2,
+          pool.kind,
+          JSON.stringify(request),
+          hash(environment2),
+          owner.nodeId,
+          owner.generation,
+          config.leaseMs,
+          request.runTimeoutMs,
+          ...usage,
+          key,
+          pool.maxRunning,
+          fingerprint,
+          pool.maxTotal
+        ]));
+        return ok({ id: id2, kind: pool.kind, request });
+      });
+    },
+    async markWarmReady(id2) {
+      const result = await reldb.sql.execute(`UPDATE ${EXECUTIONS} SET warm_state = 'ready', updated_at = ${now}
+        WHERE id = ? AND owner_generation = ? AND state = 'running' AND warm_state = 'starting'
+          AND leased_until > ${now} AND container_json IS NOT NULL`, [id2, owner.generation]);
+      return result.success && result.data.changes === 1 ? ok(void 0) : lost();
+    },
+    async claim(kinds, category, pools = [], warmIds = []) {
+      if (!kinds.length)
+        return ok(null);
+      const capacityClass = category === "tool" ? "tool" : "default";
+      const parentFilter = category === "control" ? "IS NOT NULL" : "IS NULL";
+      const queued = await reldb.sql.get(`
+        SELECT id FROM ${EXECUTIONS} WHERE state = 'queued' AND capacity_class = ? AND parent_id ${parentFilter}
+          AND queue_until > ${now} AND kind IN (${kinds.map(() => "?").join(",")})
+          AND (pinned_node IS NULL OR pinned_node = ?) AND (pinned_generation IS NULL OR pinned_generation = ?) LIMIT 1`, [
+        capacityClass,
+        ...kinds,
+        owner.nodeId,
+        owner.generation
+      ]);
+      if (!queued.success)
+        return unavailable2();
+      if (!queued.data)
+        return ok(null);
+      async function eligible(sql, includeRequest) {
+        const maxRunning = category === "tool" ? config.toolMaxRunning : category === "control" ? config.maxControlRunning : config.maxRunning;
+        const reserved = data(await sql.get(
+          `SELECT COUNT(*) AS active, COALESCE(SUM(cpu_milli),0) AS cpu, COALESCE(SUM(memory_mib),0) AS memory,
+             COALESCE(SUM(pids),0) AS pids, COALESCE(SUM(scratch_mib),0) AS scratch
+           FROM ${EXECUTIONS} WHERE owner_node = ? AND capacity_class = ? AND ${ACTIVE} AND parent_id ${parentFilter}`,
+          [owner.nodeId, capacityClass]
+        ));
+        if (!reserved)
+          return null;
+        const fingerprints = category === "tool" ? pools.flatMap((pool) => {
+          const environment2 = envById.get(pool.environmentId);
+          return environment2 ? [
+            hash({
+              pool: { ...pool },
+              environment: environment2
+            })
+          ] : [];
+        }) : [];
+        const eligiblePool = fingerprints.length ? ` OR q.pool_fingerprint IN (${fingerprints.map(() => "?").join(",")})` : "";
+        const ready = category === "tool" && warmIds.length ? `EXISTS (SELECT 1 FROM ${EXECUTIONS} w WHERE w.id IN (${warmIds.map(() => "?").join(",")})
+            AND w.pool_fingerprint = q.pool_fingerprint AND w.state = 'running' AND w.warm_state = 'ready' AND w.leased_until > ${now})` : "1 = 0";
+        const canStartCold = Number(reserved.active) < maxRunning;
+        const eligibleEnvironment = envKeys.length ? ` OR q.environment_key IN (${envKeys.map(() => "?").join(",")})` : "";
+        const [cpu, memory, pids, scratch] = columns(category === "tool" ? config.toolCapacity : config.capacity);
+        return data(await sql.get(`
+          SELECT q.id${includeRequest ? ", q.kind, q.request_json, q.parent_id, q.pool_fingerprint" : ""} FROM ${EXECUTIONS} q
+          WHERE q.state = 'queued' AND q.capacity_class = ? AND q.queue_until > ${now} AND q.parent_id ${parentFilter}
+          AND (q.pinned_node IS NULL OR q.pinned_node = ?) AND (q.pinned_generation IS NULL OR q.pinned_generation = ?)
+          AND q.kind IN (${kinds.map(() => "?").join(",")}) AND (q.environment_key IS NULL${eligibleEnvironment})
+          AND (q.pool_fingerprint IS NULL${eligiblePool})
+          AND ((${ready}) OR (? = 1 AND q.cpu_milli <= ? AND q.memory_mib <= ? AND q.pids <= ? AND q.scratch_mib <= ?
+            AND (q.pool_fingerprint IS NULL OR (
+              NOT EXISTS (SELECT 1 FROM ${EXECUTIONS} w WHERE w.pool_fingerprint = q.pool_fingerprint
+                AND w.state = 'running' AND w.warm_state IN ('starting','ready') AND w.leased_until > ${now}
+                AND (q.pinned_node IS NULL OR q.pinned_node = w.owner_node))
+              AND (SELECT COUNT(*) FROM ${EXECUTIONS} a WHERE a.concurrency_key = q.concurrency_key AND ${ACTIVE})
+                < ${reldb.config?.type === "sqlite" ? "MIN" : "LEAST"}(q.pool_limit, COALESCE((SELECT MIN(a.pool_limit) FROM ${EXECUTIONS} a
+                  WHERE a.concurrency_key = q.concurrency_key AND ${ACTIVE}), q.pool_limit))))))
+          AND (q.parent_id IS NULL OR EXISTS (SELECT 1 FROM ${EXECUTIONS} p
+            WHERE p.id = q.parent_id AND p.state = 'running' AND p.leased_until > ${now} AND p.run_until > ${now}))
+          AND (SELECT COUNT(*) FROM ${EXECUTIONS} a WHERE a.scope_key = q.scope_key AND a.warm_state IS NULL AND ${ACTIVE}
+            AND a.capacity_class = q.capacity_class AND a.parent_id ${parentFilter}) < ?
+          AND (q.concurrency_key IS NULL OR (
+            (SELECT COUNT(*) FROM ${EXECUTIONS} a WHERE a.concurrency_key = q.concurrency_key AND a.warm_state IS NULL AND ${ACTIVE}) < q.concurrency_limit
+            AND (SELECT COUNT(*) FROM ${EXECUTIONS} a WHERE a.concurrency_key = q.concurrency_key AND a.warm_state IS NULL AND ${ACTIVE})
+              < COALESCE((SELECT MIN(a.concurrency_limit) FROM ${EXECUTIONS} a WHERE a.concurrency_key = q.concurrency_key AND ${ACTIVE}), q.concurrency_limit)))
+          ORDER BY (SELECT COUNT(*) FROM ${EXECUTIONS} a WHERE a.scope_key = q.scope_key
+            AND ${ACTIVE} AND a.capacity_class = q.capacity_class AND a.parent_id ${parentFilter}) ASC, q.created_at ASC, q.id ASC
+          LIMIT 1
+        `, [
+          capacityClass,
+          owner.nodeId,
+          owner.generation,
+          ...kinds,
+          ...envKeys,
+          ...fingerprints,
+          ...category === "tool" ? warmIds : [],
+          Number(canStartCold),
+          cpu - Number(reserved.cpu),
+          memory - Number(reserved.memory),
+          pids - Number(reserved.pids),
+          scratch - Number(reserved.scratch),
+          config.maxRunningPerScope
+        ]));
+      }
+      try {
+        if (!await eligible(reldb.sql, false))
+          return ok(null);
+      } catch {
+        return unavailable2();
+      }
+      return serialized(async (sql) => {
+        const row = await eligible(sql, true);
+        if (!row)
+          return ok(null);
+        const request = databaseValue(row.request_json);
+        const standby = row.pool_fingerprint && warmIds.length ? data(await sql.get(`
+          SELECT * FROM ${EXECUTIONS} WHERE id IN (${warmIds.map(() => "?").join(",")}) AND pool_fingerprint = ?
+            AND state = 'running' AND warm_state = 'ready' AND leased_until > ${now} ORDER BY created_at, id LIMIT 1`, [...warmIds, row.pool_fingerprint])) : null;
+        const changed = data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'running', owner_node = ?, owner_generation = ?,
+          container_json = ${resultValue}, owner_process_json = ${resultValue}, leased_until = ${now} + ?, run_until = ${now} + ?, updated_at = ${now}
+          WHERE id = ? AND state = 'queued' AND queue_until > ${now}`, [
+          owner.nodeId,
+          owner.generation,
+          standby?.container_json ? JSON.stringify(databaseValue(standby.container_json)) : null,
+          request.environment ? null : processJson,
+          config.leaseMs,
+          request.runTimeoutMs,
+          row.id
+        ]));
+        if (changed.changes === 1 && standby) {
+          const transferred = data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'succeeded', warm_state = 'transferred', updated_at = ${now}
+            WHERE id = ? AND owner_generation = ? AND state = 'running' AND warm_state = 'ready' AND leased_until > ${now}`, [standby.id, owner.generation]));
+          if (transferred.changes !== 1)
+            throw new Error("Warm container reservation expired");
+        }
+        return ok(changed.changes === 1 ? {
+          id: row.id,
+          kind: row.kind,
+          parentId: row.parent_id ?? void 0,
+          warmId: standby?.id,
+          request
+        } : null);
+      });
+    },
+    async cancelOwned(id2) {
+      const result = await reldb.sql.execute(`UPDATE ${EXECUTIONS} SET state = 'cancelling', updated_at = ${now}
+        WHERE id = ? AND owner_generation = ? AND state = 'running' AND leased_until > ${now}`, [id2, owner.generation]);
+      return result.success ? ok(void 0) : unavailable2();
+    },
+    async recordContainer(id2, container) {
+      const result = await reldb.sql.execute(`UPDATE ${EXECUTIONS} SET container_json = ${resultValue}
+        WHERE id = ? AND owner_generation = ? AND state = 'running' AND container_json IS NULL
+          AND leased_until > ${now} AND run_until > ${now}`, [
+        JSON.stringify(container),
+        id2,
+        owner.generation
+      ]);
+      return result.success && result.data.changes === 1 ? ok(void 0) : lost();
+    },
+    async reconciliation(scope, id2) {
+      try {
+        const row = await find(reldb.sql, id2, hash([scope.tenantId, scope.userId]));
+        if (!row)
+          return missing();
+        if (row.state !== "unknown" || row.owner_node !== owner.nodeId || row.reconciled_at !== null || !row.owner_generation) {
+          return conflict();
+        }
+        if (row.container_json) {
+          const container = databaseValue(row.container_json);
+          return container.engine === config.engine ? ok({ container, generation: row.owner_generation }) : conflict();
+        }
+        if (row.environment_key !== null || !row.owner_process_json || !await parentSettled(reldb.sql, row))
+          return conflict();
+        return ok({
+          container: void 0,
+          process: databaseValue(row.owner_process_json),
+          generation: row.owner_generation
+        });
+      } catch {
+        return unavailable2();
+      }
+    },
+    async reconcile(scope, id2, generation, review) {
+      return serialized(async (sql) => {
+        const scopeKey = hash([scope.tenantId, scope.userId]);
+        if (review.hostResourcesStopped) {
+          const row2 = await find(sql, id2, scopeKey);
+          if (!row2 || !await parentSettled(sql, row2))
+            return conflict();
+        }
+        const proof = review.hostResourcesStopped ? "container_json IS NULL AND environment_key IS NULL AND owner_process_json IS NOT NULL" : "container_json IS NOT NULL";
+        const result = data(await sql.execute(`UPDATE ${EXECUTIONS}
+          SET reconciled_at = ${now}, reconciliation_json = ${resultValue}, reuse_key = NULL, updated_at = ${now}
+          WHERE id = ? AND scope_key = ? AND owner_node = ? AND owner_generation = ? AND state = 'unknown'
+            AND reconciled_at IS NULL AND ${proof}`, [
+          JSON.stringify(review),
+          id2,
+          scopeKey,
+          owner.nodeId,
+          generation
+        ]));
+        if (result.changes !== 1)
+          return conflict();
+        const row = await find(sql, id2, scopeKey);
+        return row ? ok(projectRequest(row)) : missing();
+      });
+    },
+    async renew(id2) {
+      const renewed = await reldb.sql.execute(`UPDATE ${EXECUTIONS} SET leased_until = ${now} + ?, updated_at = ${now}
+        WHERE id = ? AND owner_generation = ? AND state IN ('running', 'cancelling') AND leased_until > ${now}`, [config.leaseMs, id2, owner.generation]);
+      if (!renewed.success)
+        return unavailable2();
+      if (renewed.data.changes !== 1)
+        return lost();
+      const row = await reldb.sql.get(
+        `SELECT state, parent_id FROM ${EXECUTIONS} WHERE id = ? AND owner_generation = ? AND leased_until > ${now}`,
+        [id2, owner.generation]
+      );
+      if (!row.success)
+        return unavailable2();
+      if (!row.data)
+        return lost();
+      if (row.data.parent_id) {
+        const parent = await reldb.sql.get(`SELECT id FROM ${EXECUTIONS} WHERE id = ?
+          AND owner_generation = ? AND state = 'running' AND leased_until > ${now} AND run_until > ${now}`, [row.data.parent_id, owner.generation]);
+        if (!parent.success)
+          return unavailable2();
+        if (!parent.data) {
+          const cancelled = await this.cancelOwned(id2);
+          return cancelled.success ? ok("cancelling") : cancelled;
+        }
+      }
+      return ok(row.data.state);
+    },
+    async emit(id2, value) {
+      const encoded = JSON.stringify({ value });
+      const bytes = Buffer.byteLength(encoded);
+      const result = await reldb.tx.wrap(async (sql) => {
+        const changed = data(await sql.execute(`UPDATE ${EXECUTIONS} SET event_sequence = event_sequence + 1, event_bytes = event_bytes + ?
+          WHERE id = ? AND owner_generation = ? AND state = 'running' AND leased_until > ${now}
+            AND run_until > ${now} AND event_sequence < ? AND event_bytes <= ?`, [
+          bytes,
+          id2,
+          owner.generation,
+          config.maxEvents,
+          MAX_EVENT_BYTES - bytes
+        ]));
+        if (changed.changes !== 1)
+          return lost();
+        const row = data(await sql.get(`SELECT event_sequence FROM ${EXECUTIONS} WHERE id = ?`, [id2]));
+        const sequence = Number(row?.event_sequence);
+        const published = data(await sql.execute(`INSERT INTO ${EVENTS} (id, execution_id, sequence_number, event_json, created_at)
+          SELECT ?, ?, ?, ${resultValue}, ${now} FROM ${EXECUTIONS} q LEFT JOIN ${EXECUTIONS} p ON p.id = q.parent_id
+          WHERE q.id = ? AND q.leased_until > ${now} AND q.run_until > ${now}
+          AND (q.parent_id IS NULL OR (p.state = 'running' AND p.owner_generation = q.owner_generation
+            AND p.leased_until > ${now} AND p.run_until > ${now}))`, [
+          hash([id2, sequence]),
+          id2,
+          sequence,
+          encoded,
+          id2
+        ]));
+        if (published.changes !== 1)
+          throw new Error("Event owner lost");
+        return ok(void 0);
+      });
+      return result.success ? result.data : unavailable2();
+    },
+    async events(scope, id2, after, limit) {
+      const owner2 = await reldb.sql.get(`SELECT id FROM ${EXECUTIONS} WHERE id = ? AND scope_key = ?`, [
+        id2,
+        hash([scope.tenantId, scope.userId])
+      ]);
+      if (!owner2.success)
+        return unavailable2();
+      if (!owner2.data)
+        return missing();
+      const page = await reldb.sql.query(
+        `SELECT sequence_number, event_json, created_at FROM ${EVENTS}
+          WHERE execution_id = ? AND sequence_number > ? ORDER BY sequence_number ASC LIMIT ?`,
+        [id2, after, limit]
+      );
+      if (!page.success)
+        return unavailable2();
+      try {
+        return ok(page.data.map((row) => ({
+          sequence: Number(row.sequence_number),
+          data: databaseValue(row.event_json).value,
+          createdAt: Number(row.created_at)
+        })));
+      } catch {
+        return unavailable2();
+      }
+    },
+    async finish(id2, output, stopped) {
+      return serialized(async (sql) => {
+        if (!stopped) {
+          data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'unknown', reason = 'cleanup-unconfirmed', updated_at = ${now}
+            WHERE id = ? AND owner_generation = ? AND state IN ('running', 'cancelling') AND leased_until > ${now}`, [id2, owner.generation]));
+          return lost();
+        }
+        const child = data(await sql.get(
+          `SELECT parent_id FROM ${EXECUTIONS} WHERE id = ? AND owner_generation = ?`,
+          [id2, owner.generation]
+        ));
+        if (!child)
+          return lost();
+        const parentLock = reldb.config?.type === "sqlite" ? "" : " FOR UPDATE";
+        const parent = child.parent_id ? data(await sql.get(
+          `SELECT * FROM ${EXECUTIONS} WHERE id = ?${parentLock}`,
+          [child.parent_id]
+        )) : null;
+        const parentUntil = child.parent_id ? parent?.state === "running" && parent.owner_generation === owner.generation ? Math.min(Number(parent.leased_until), Number(parent.run_until)) : 0 : Number.MAX_SAFE_INTEGER;
+        const changed = data(await sql.execute(`UPDATE ${EXECUTIONS}
+          SET result_json = CASE WHEN state = 'running' AND run_until > ${now} AND ? > ${now} THEN ${resultValue} ELSE NULL END,
+            reason = CASE WHEN reason = 'run-timeout' OR run_until <= ${now} THEN 'run-timeout'
+              WHEN ? <= ${now} THEN 'parent-ended' WHEN state = 'cancelling' THEN reason ELSE ? END,
+            state = CASE WHEN reason = 'run-timeout' OR run_until <= ${now} THEN 'failed'
+              WHEN state = 'cancelling' OR ? <= ${now} THEN 'cancelled' ELSE ? END,
+            reuse_key = NULL, updated_at = ${now}
+          WHERE id = ? AND owner_generation = ? AND state IN ('running', 'cancelling') AND leased_until > ${now}`, [
+          parentUntil,
+          output === void 0 ? null : JSON.stringify({ value: output }),
+          parentUntil,
+          output === void 0 ? "handler-failed" : null,
+          parentUntil,
+          output === void 0 ? "failed" : "succeeded",
+          id2,
+          owner.generation
+        ]));
+        if (changed.changes !== 1)
+          return lost();
+        data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'cancelled', reason = 'parent-ended', updated_at = ${now} WHERE parent_id = ? AND state = 'queued'`, [id2]));
+        data(await sql.execute(`UPDATE ${EXECUTIONS} SET state = 'cancelling', reason = 'parent-ended', updated_at = ${now} WHERE parent_id = ? AND state = 'running'`, [id2]));
+        return ok(void 0);
+      });
+    }
+  };
+}
+
+// src/runner-main.ts
+var logger = core.logger.child({ module: "runner" });
+var inactive = core.module.createNotInitializedKit(HaiRunnerError.NOT_INITIALIZED, () => runnerM("runner_notInitialized")).result;
+var MAX_PAYLOAD_BYTES = 512 * 1024;
+function invalid2() {
+  return err(HaiRunnerError.INVALID, runnerM("runner_invalid"));
+}
+function cleanupUnconfirmed() {
+  return err(HaiRunnerError.CLEANUP_UNCONFIRMED, runnerM("runner_cleanupUnconfirmed"));
+}
+function notFound() {
+  return err(HaiRunnerError.NOT_FOUND, runnerM("runner_notFound"));
+}
+function validAddress(scope, id2) {
+  return !!scope && typeof scope.tenantId === "string" && typeof scope.userId === "string" && scope.tenantId.length > 0 && scope.tenantId.length <= 200 && scope.userId.length > 0 && scope.userId.length <= 200 && /^[a-f\d]{64}$/u.test(id2);
+}
+function bounded(input) {
+  try {
+    return Buffer.byteLength(JSON.stringify(input)) <= MAX_PAYLOAD_BYTES;
+  } catch {
+    return false;
+  }
+}
+function createRunner() {
+  let config;
+  let store;
+  let owner;
+  let initializing = false;
+  let closing;
+  let closingRequested = false;
+  let timer;
+  let tick;
+  let sweepAt = 0;
+  let pruneAt = 0;
+  let unconfirmedCleanup = false;
+  const running = /* @__PURE__ */ new Map();
+  const handlers = /* @__PURE__ */ new Map();
+  const pools = /* @__PURE__ */ new Map();
+  const warmReservations = /* @__PURE__ */ new Map();
+  const standby = /* @__PURE__ */ new Map();
+  let warmAt = 0;
+  const poolKey = (kind, key) => `${kind}:${key}`;
+  function prewarm(claim, pool, current, settings) {
+    const abort = new AbortController();
+    const environment2 = claim.request.environment;
+    warmReservations.set(claim.id, pool);
+    const done = (async () => {
+      const launched = await prepareWarmContainer(settings.engine, environment2, abort.signal, (identity) => current.recordContainer(claim.id, identity));
+      if (!launched.success) {
+        const stopped = launched.error.code !== HaiRunnerError.CLEANUP_UNCONFIRMED.code;
+        await current.finish(claim.id, void 0, stopped);
+        if (!stopped)
+          unconfirmedCleanup = true;
+        return stopped;
+      }
+      const handle = launched.data;
+      handle.stderr.resume();
+      let transferred = false;
+      const released = new Promise((resolve) => {
+        standby.set(claim.id, {
+          handle,
+          pool,
+          transferred: () => {
+            transferred = true;
+            resolve();
+          }
+        });
+        abort.signal.addEventListener("abort", () => resolve(), { once: true });
+        if (abort.signal.aborted)
+          resolve();
+      });
+      const ready = await current.markWarmReady(claim.id);
+      if (ready.success && !abort.signal.aborted) {
+        await Promise.race([
+          released,
+          handle.wait()
+        ]);
+      }
+      standby.delete(claim.id);
+      if (transferred)
+        return true;
+      const closed = await handle.close();
+      await current.finish(claim.id, void 0, closed.success);
+      if (!closed.success)
+        unconfirmedCleanup = true;
+      return closed.success;
+    })().catch(() => {
+      unconfirmedCleanup = true;
+      logger.warn("Warm container cleanup could not be confirmed", { executionId: claim.id });
+      return false;
+    }).finally(() => {
+      running.delete(claim.id);
+      warmReservations.delete(claim.id);
+    });
+    running.set(claim.id, { abort, done, renewAt: performance.now() + settings.pollMs });
+  }
+  function launch(claim, handler, current, settings, holder, warmed) {
+    const abort = new AbortController();
+    let process3;
+    let uncertain2 = false;
+    const closeProcess = async () => {
+      const started = await process3;
+      if (started?.success)
+        return (await started.data.close()).success;
+      return warmed ? (await warmed.close()).success : !uncertain2;
+    };
+    async function start(options) {
+      const { environment: environment2, resources: resources2 } = claim.request;
+      if (abort.signal.aborted || process3 || !environment2 || !resources2)
+        return invalid2();
+      process3 = (async () => {
+        const renewed = await current.renew(claim.id);
+        if (!renewed.success)
+          return renewed;
+        if (renewed.data !== "running" || abort.signal.aborted)
+          return err(HaiRunnerError.LEASE_LOST, runnerM("runner_leaseLost"));
+        const started = warmed ? await warmed.activate(options, abort.signal, async () => {
+          const lease = await current.renew(claim.id);
+          return lease.success && lease.data === "running";
+        }) : await startContainer(settings.engine, environment2, resources2, options, abort.signal, (identity) => current.recordContainer(claim.id, identity));
+        if (!started.success && started.error.code === HaiRunnerError.CLEANUP_UNCONFIRMED.code)
+          uncertain2 = true;
+        return started;
+      })();
+      return process3;
+    }
+    async function execute2() {
+      const context = {
+        id: claim.id,
+        parentId: claim.parentId,
+        scope: claim.request.scope,
+        owner: holder,
+        signal: abort.signal,
+        start,
+        emit: async (value) => {
+          if (abort.signal.aborted || !bounded(value))
+            return invalid2();
+          try {
+            const parsed = json.safeParse(value);
+            return parsed.success ? await current.emit(claim.id, parsed.data) : invalid2();
+          } catch {
+            return invalid2();
+          }
+        }
+      };
+      const stop = () => {
+        void closeProcess();
+      };
+      abort.signal.addEventListener("abort", stop, { once: true });
+      let output;
+      try {
+        const lease = await current.renew(claim.id);
+        if (lease.success && lease.data === "running" && !abort.signal.aborted) {
+          const value = await handler(claim.request.input, context);
+          if (!bounded(value))
+            throw new Error("Runner handler output exceeded its bound");
+          const parsed = json.safeParse(value);
+          if (parsed.success)
+            output = parsed.data;
+        }
+      } catch {
+        logger.warn("Managed execution handler failed", { executionId: claim.id, kind: claim.kind });
+      } finally {
+        abort.signal.removeEventListener("abort", stop);
+      }
+      const stopped = await closeProcess();
+      if (!stopped)
+        unconfirmedCleanup = true;
+      const result = await current.finish(claim.id, output, stopped);
+      if (!result.success)
+        logger.warn("Managed execution final state could not be committed", { executionId: claim.id, code: result.error.code });
+      return stopped;
+    }
+    const done = Promise.resolve().then(execute2).catch(() => {
+      unconfirmedCleanup = true;
+      logger.warn("Managed execution failed to finish", { executionId: claim.id });
+      return false;
+    }).finally(() => running.delete(claim.id));
+    running.set(claim.id, { abort, done, renewAt: performance.now() + settings.pollMs });
+  }
+  function poll() {
+    if (tick || !store || !config || !owner)
+      return;
+    const current = store;
+    const settings = config;
+    const holder = owner;
+    tick = (async () => {
+      await Promise.all([...running].map(async ([id2, execution]) => {
+        if (execution.renewAt > performance.now())
+          return;
+        const result = await current.renew(id2);
+        execution.renewAt = performance.now() + (result.success && result.data === "running" ? Math.min(250, settings.leaseMs / 4) : settings.pollMs);
+        if (!result.success || result.data !== "running")
+          execution.abort.abort();
+      }));
+      if (!closingRequested && sweepAt <= performance.now()) {
+        const maintenance = await current.sweep();
+        if (!maintenance.success)
+          logger.warn("Managed execution maintenance failed", { code: maintenance.error.code });
+        sweepAt = performance.now() + Math.min(250, settings.leaseMs / 4);
+      }
+      if (closingRequested)
+        return;
+      if (pruneAt <= performance.now()) {
+        const pruned = await current.prune();
+        if (!pruned.success)
+          logger.warn("Managed execution retention failed", { code: pruned.error.code });
+        pruneAt = performance.now() + (pruned.success && pruned.data ? 250 : 1e3);
+      }
+      const kinds = [
+        ...handlers.keys()
+      ];
+      if (!kinds.length)
+        return;
+      const configuredPools = [
+        ...pools.values()
+      ].filter((pool) => handlers.has(pool.kind));
+      for (const category of ["control", "tool", "default"]) {
+        const available = [...standby].filter(([, candidate]) => pools.get(poolKey(candidate.pool.kind, candidate.pool.key)) === candidate.pool).map(([id2]) => id2);
+        const claimed = await current.claim(kinds, category, configuredPools, available);
+        if (!claimed.success) {
+          logger.warn("Managed execution claim failed", { code: claimed.error.code });
+          continue;
+        }
+        if (!claimed.data)
+          continue;
+        const handler = handlers.get(claimed.data.kind);
+        const warmed = claimed.data.warmId ? standby.get(claimed.data.warmId) : void 0;
+        warmed?.transferred();
+        if (handler && !closingRequested && (!claimed.data.warmId || warmed)) {
+          launch(claimed.data, handler, current, settings, holder, warmed?.handle);
+        } else {
+          const stopped = warmed ? (await warmed.handle.close()).success : !claimed.data.warmId;
+          await current.finish(claimed.data.id, void 0, stopped);
+        }
+      }
+      if (!closingRequested && performance.now() >= warmAt) {
+        warmAt = performance.now() + Math.max(250, settings.pollMs);
+        for (const pool of configuredPools) {
+          const reserved = await current.reserveWarm(pool);
+          if (reserved.success && reserved.data)
+            prewarm(reserved.data, pool, current, settings);
+        }
+      }
+    })().catch(() => {
+      for (const execution of running.values())
+        execution.abort.abort();
+      logger.warn("Managed execution polling failed");
+    }).finally(() => {
+      tick = void 0;
+    });
+  }
+  async function init(input) {
+    if (initializing || config || closing)
+      return err(HaiRunnerError.ALREADY_INITIALIZED, runnerM("runner_alreadyInitialized"));
+    const parsed = RunnerConfigSchema.safeParse(input);
+    if (!parsed.success)
+      return invalid2();
+    initializing = true;
+    try {
+      const ready = await readyStore();
+      if (!ready.success)
+        return ready;
+      owner = {
+        nodeId: parsed.data.nodeId,
+        generation: randomUUID()
+      };
+      config = parsed.data;
+      store = makeStore(config, owner, config.executor ? await readRunnerProcess() : void 0);
+      unconfirmedCleanup = false;
+      sweepAt = 0;
+      pruneAt = 0;
+      warmAt = 0;
+      if (config.executor) {
+        timer = setInterval(poll, config.pollMs);
+        timer.unref();
+      }
+      return ok(void 0);
+    } finally {
+      initializing = false;
+    }
+  }
+  function close() {
+    if (closing)
+      return closing;
+    if (initializing)
+      return Promise.resolve(err(HaiRunnerError.ALREADY_INITIALIZED, runnerM("runner_alreadyInitialized")));
+    if (!config)
+      return Promise.resolve(ok(void 0));
+    closingRequested = true;
+    closing = (async () => {
+      await tick;
+      await Promise.all([...running].map(async ([id2, execution]) => {
+        const requested = await store?.cancelOwned(id2);
+        if (!requested?.success)
+          unconfirmedCleanup = true;
+        execution.abort.abort();
+      }));
+      let deadline;
+      try {
+        const drained = await Promise.race([
+          Promise.all([
+            ...running.values()
+          ].map((execution) => execution.done)).then(() => true),
+          new Promise((resolve) => {
+            deadline = setTimeout(resolve, config.closeTimeoutMs, false);
+          })
+        ]);
+        if (!drained)
+          return cleanupUnconfirmed();
+        clearInterval(timer);
+        handlers.clear();
+        pools.clear();
+        config = void 0;
+        owner = void 0;
+        store = void 0;
+        closingRequested = false;
+        return unconfirmedCleanup ? cleanupUnconfirmed() : ok(void 0);
+      } finally {
+        clearTimeout(deadline);
+      }
+    })().finally(() => {
+      closing = void 0;
+    });
+    return closing;
+  }
+  return {
+    init,
+    close,
+    get isExecutor() {
+      return config?.executor === true && !closingRequested;
+    },
+    environment(id2) {
+      if (!config || closingRequested)
+        return inactive();
+      const found = config.environments.find((item) => item.id === id2);
+      return found ? ok(structuredClone(found)) : notFound();
+    },
+    register(kind, handler) {
+      if (!config || closingRequested)
+        return inactive();
+      if (!runnerKind.safeParse(kind).success || typeof handler !== "function")
+        return invalid2();
+      if (!config.executor)
+        return ok(() => {
+        });
+      if (handlers.has(kind) || handlers.size >= 100)
+        return err(HaiRunnerError.CONFLICT, runnerM("runner_conflict"));
+      handlers.set(kind, handler);
+      return ok(() => {
+        if (handlers.get(kind) === handler)
+          handlers.delete(kind);
+      });
+    },
+    registerWarmPool(input) {
+      if (!config || closingRequested)
+        return inactive();
+      const parsed = warmPoolSchema.safeParse(input);
+      if (!parsed.success)
+        return invalid2();
+      const pool = parsed.data;
+      const environment2 = config.environments.find((item) => item.id === pool.environmentId);
+      if (!environment2 || environment2.networkPolicy !== "offline" || config.executor && !handlers.has(pool.kind))
+        return invalid2();
+      const key = poolKey(pool.kind, pool.key);
+      if (pools.has(key) || pools.size >= 100)
+        return err(HaiRunnerError.CONFLICT, runnerM("runner_conflict"));
+      pools.set(key, pool);
+      return ok(() => {
+        if (pools.get(key) !== pool)
+          return;
+        pools.delete(key);
+        for (const [id2, candidate] of warmReservations) {
+          if (candidate === pool)
+            running.get(id2)?.abort.abort();
+        }
+      });
+    },
+    async submit(input) {
+      if (!store || closingRequested)
+        return inactive();
+      if (!bounded(input))
+        return invalid2();
+      try {
+        const parsed = submitSchema.safeParse(input);
+        if (!parsed.success)
+          return invalid2();
+        const request = parsed.data;
+        const pool = request.concurrency && pools.get(poolKey(request.kind, request.concurrency.key));
+        if (request.warmPool && (!pool || pool.environmentId !== request.environmentId || pool.maxRunning !== request.concurrency?.limit)) {
+          return invalid2();
+        }
+        if (pool && !request.warmPool)
+          return invalid2();
+        return await store.submit(request, pool);
+      } catch {
+        return invalid2();
+      }
+    },
+    async find(scope, kind, key) {
+      if (!store)
+        return inactive();
+      return validAddress(scope, "0".repeat(64)) && runnerKind.safeParse(kind).success && typeof key === "string" && key.length > 0 && key.length <= 200 ? store.find(scope, kind, key) : invalid2();
+    },
+    async get(scope, id2) {
+      if (!store)
+        return inactive();
+      return validAddress(scope, id2) ? store.get(scope, id2) : invalid2();
+    },
+    async cancel(scope, id2) {
+      if (!store)
+        return inactive();
+      return validAddress(scope, id2) ? store.cancel(scope, id2) : invalid2();
+    },
+    async reconcileUnknown(scope, id2, review) {
+      const current = store;
+      if (!current || !config?.executor || closingRequested)
+        return inactive();
+      if (!validAddress(scope, id2) || !review || typeof review.operatorId !== "string" || !runnerKind.safeParse(review.operatorId).success || typeof review.reason !== "string" || review.hostResourcesStopped !== void 0 && review.hostResourcesStopped !== true || !review.reason.trim() || review.reason.length > 300 || /[\r\n\0]/u.test(review.reason)) {
+        return invalid2();
+      }
+      if (running.has(id2))
+        return cleanupUnconfirmed();
+      const evidence = await current.reconciliation(scope, id2);
+      if (!evidence.success)
+        return evidence;
+      if (evidence.data.container) {
+        const verified = await confirmContainerReleased(evidence.data.container);
+        if (!verified.success)
+          return verified;
+      } else if (review.hostResourcesStopped !== true || !await confirmRunnerProcessReleased(evidence.data.process)) {
+        return cleanupUnconfirmed();
+      }
+      if (current !== store || closingRequested)
+        return inactive();
+      const reconciled = await current.reconcile(scope, id2, evidence.data.generation, {
+        operatorId: review.operatorId,
+        reason: review.reason.trim(),
+        ...!evidence.data.container && { hostResourcesStopped: true }
+      });
+      if (reconciled.success)
+        logger.info("Unknown execution resources reconciled", { executionId: id2, operatorId: review.operatorId });
+      return reconciled;
+    },
+    async events(scope, id2, after = 0, limit = 100) {
+      if (!store)
+        return inactive();
+      return validAddress(scope, id2) && Number.isSafeInteger(after) && after >= 0 && Number.isSafeInteger(limit) && limit >= 1 && limit <= 100 ? store.events(scope, id2, after, limit) : invalid2();
+    }
+  };
+}
+var runner = createRunner();
+
+export { HaiRunnerError, RunnerConfigSchema, createRunner, runner };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map