@ricsam/r5d-worker 0.0.136 → 0.0.138

package/dist/mjs/runtime/executor.mjs

@@ -0,0 +1,436 @@
+import { createHash, timingSafeEqual } from "node:crypto";
+import { spawn } from "node:child_process";
+import { realpathSync, rmSync, writeFileSync, lstatSync, openSync, fstatSync, readFileSync, closeSync, constants } from "node:fs";
+import { isAbsolute, join, relative } from "node:path";
+import { PtySession } from "./pty.mjs";
+import {
+  canonicalJson,
+  negotiateProtocol,
+  operationPayloadHash,
+  OwnershipFence
+} from "@ricsam/r5d-api/runtime-protocol";
+import { terminateProcessTree } from "../process-tree.mjs";
+import {
+  ExecutorConfig,
+  ExecutorCredential,
+  ExecutorError,
+  ExecutorRequest,
+  EXECUTOR_CAPABILITY,
+  ShellPayload
+} from "./protocol.mjs";
+import { ExecutorStore, privateDirectory } from "./storage.mjs";
+import { AdapterGrantRegistry, digest } from "./releases/grants.mjs";
+const tokenHash = (token) => createHash("sha256").update(token).digest("hex");
+class HostExecutor {
+  constructor(config, nativePty) {
+    this.nativePty = nativePty;
+    this.config = ExecutorConfig.parse(config);
+    this.store = new ExecutorStore(this.config.stateDir, this.config.installationId, this.config.workerId);
+    try {
+      this.adapters = new AdapterGrantRegistry(this.store.db, this.config);
+    } catch (error) {
+      this.store.close();
+      throw error;
+    }
+    this.hello = {
+      installationId: this.config.installationId,
+      instanceId: this.config.instanceId,
+      releaseId: this.config.releaseId,
+      role: "executor",
+      protocol: { min: 1, max: 1 },
+      capabilities: [EXECUTOR_CAPABILITY, ...nativePty ? ["host-pty-v1"] : []]
+    };
+    this.leaseTimer = setInterval(() => {
+      const authority = this.authority();
+      if (!authority || authority.validUntil <= Date.now()) {
+        for (const run of this.active.values())
+          void this.finish(run, true, "authority_expired").catch(() => {
+            this.poisoned = true;
+          });
+      }
+    }, 100);
+    this.leaseTimer.unref();
+  }
+  nativePty;
+  config;
+  store;
+  adapters;
+  hello;
+  active = /* @__PURE__ */ new Map();
+  leaseTimer;
+  closing = false;
+  poisoned = false;
+  serial = Promise.resolve();
+  /** Authority is synchronous and authenticated; never queue lease renewal behind a blocked OS write.
+   * Resource commands retain one ordered admission/action boundary. Commands already admitted may
+   * complete after promotion; queued commands and yielded admission hashes must recheck the fence.
+   */
+  handle(input) {
+    try {
+      const request = ExecutorRequest.parse(input);
+      if (request.command.method === "authority") return this.dispatch(request);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    const task = this.serial.then(() => this.dispatch(input));
+    this.serial = task.catch(() => {
+    });
+    return task;
+  }
+  authenticate(request) {
+    const grant = this.adapters.find(request.auth.principalId);
+    const principal = this.config.principals.find((p) => p.id === request.auth.principalId) ?? grant?.principal;
+    const actual = Buffer.from(tokenHash(request.auth.token), "hex");
+    const expected = Buffer.from(principal?.tokenHash ?? "0".repeat(64), "hex");
+    if (!timingSafeEqual(actual, expected) || !principal) throw new ExecutorError("unauthenticated");
+    if (grant && digest(grant.hello) !== digest(request.hello)) throw new ExecutorError("grant_hello_mismatch");
+    negotiateProtocol(this.hello, request.hello, [EXECUTOR_CAPABILITY]);
+    if (request.hello.role !== (principal.role === "adapter" ? "worker-adapter" : "scheduler") || request.hello.instanceId !== principal.ownerId)
+      throw new ExecutorError("wrong_principal");
+    return principal;
+  }
+  authority() {
+    const row = this.store.db.query("SELECT fence, valid_until FROM authority WHERE id=1").get();
+    return row ? { fence: OwnershipFence.parse(JSON.parse(row.fence)), validUntil: row.valid_until } : null;
+  }
+  workerFence(fence) {
+    if (fence.installationId !== this.config.installationId || fence.resourceType !== "worker" || fence.resourceId !== this.config.workerId)
+      throw new ExecutorError("wrong_resource");
+  }
+  authorize(principal, run) {
+    this.workerFence(run.fence);
+    if (principal.role !== "adapter" || !principal.userIds.includes(run.userId) || principal.ownerId !== run.fence.ownerId)
+      throw new ExecutorError("forbidden");
+    const authority = this.authority();
+    if (!authority || authority.validUntil <= Date.now() || canonicalJson(authority.fence) !== canonicalJson(run.fence))
+      throw new ExecutorError("stale_fence");
+  }
+  authorizeAdmission(principal, run) {
+    try {
+      this.authorize(principal, run);
+    } catch (error) {
+      if (error instanceof ExecutorError && error.code === "stale_fence") throw new ExecutorError("stale_fence", "stale_fence", true);
+      throw error;
+    }
+  }
+  receipt(principal, identity) {
+    this.authorize(principal, identity);
+    const run = this.store.get(identity.operationId);
+    if (!run || run.userId !== identity.userId || run.sessionId !== (identity.sessionId ?? null)) throw new ExecutorError("run_not_found");
+    return run;
+  }
+  async dispatch(input) {
+    if (this.closing) throw new ExecutorError("executor_unavailable");
+    const request = ExecutorRequest.parse(input);
+    const principal = this.authenticate(request);
+    const command = request.command;
+    if (command.method === "adapter.register") return this.adapters.register(principal, command.grant, this.hello);
+    if (command.method === "adapter.retire") return this.adapters.retire(principal, command.principalId, this.authority()?.fence.ownerId);
+    if (command.method === "status")
+      return {
+        hello: this.hello,
+        workerId: this.config.workerId,
+        authority: this.authority(),
+        capacity: this.config.capacity,
+        active: Object.fromEntries(
+          Object.keys(this.config.capacity).map((lane) => [lane, [...this.active.values()].filter((r) => r.receipt.lane === lane).length])
+        ),
+        unknown: this.store.all().filter((run2) => run2.state === "unknown").length,
+        degraded: this.poisoned,
+        ...principal.role === "controller" ? { adapters: this.adapters.list() } : {}
+      };
+    if (command.method === "authority") {
+      if (principal.role !== "controller") throw new ExecutorError("forbidden");
+      this.workerFence(command.fence);
+      if (!this.config.principals.some((p) => p.role === "adapter" && p.ownerId === command.fence.ownerId) && !this.adapters.hasOwner(command.fence.ownerId))
+        throw new ExecutorError("unknown_owner");
+      const previous = this.authority();
+      if (previous && (command.fence.epoch < previous.fence.epoch || command.fence.epoch === previous.fence.epoch && (canonicalJson(command.fence) !== canonicalJson(previous.fence) || previous.validUntil <= Date.now() || command.validUntil < previous.validUntil)))
+        throw new ExecutorError("stale_fence");
+      if (command.validUntil <= Date.now() || command.validUntil > Date.now() + this.config.maxLeaseMs)
+        throw new ExecutorError("invalid_lease");
+      this.store.db.query("INSERT INTO authority VALUES (1,?,?) ON CONFLICT(id) DO UPDATE SET fence=excluded.fence,valid_until=excluded.valid_until").run(canonicalJson(command.fence), command.validUntil);
+      return this.authority();
+    }
+    if (command.method === "start") {
+      const operation = command.operation;
+      this.authorizeAdmission(principal, operation);
+      if (operation.installationId !== this.config.installationId || operation.kind !== "host.shell")
+        throw new ExecutorError("unsupported_operation");
+      const payload = ShellPayload.parse(operation.payload);
+      const hash = await operationPayloadHash(operation);
+      this.authorizeAdmission(principal, operation);
+      const previous = this.store.get(operation.operationId);
+      if (previous) {
+        if (previous.payloadHash !== hash) throw new ExecutorError("operation_payload_mismatch");
+        return previous;
+      }
+      if (this.poisoned || this.store.all().some((run2) => run2.state === "unknown")) throw new ExecutorError("reconciliation_required");
+      if (!principal.lanes.includes(payload.lane)) throw new ExecutorError("forbidden_lane");
+      if ([...this.active.values()].filter((run2) => run2.receipt.lane === payload.lane).length >= this.config.capacity[payload.lane])
+        throw new ExecutorError("capacity_busy", "capacity_busy", true);
+      if (payload.pty && !this.nativePty) throw new ExecutorError("pty_unavailable");
+      if (payload.pty && !payload.interactive) throw new ExecutorError("pty_requires_interactive");
+      const cwd = realpathSync(payload.cwd);
+      if (!principal.cwdRoots.some((root) => {
+        const rel = relative(realpathSync(root), cwd);
+        return rel === "" || !rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) && rel !== ".." && !isAbsolute(rel);
+      }))
+        throw new ExecutorError("forbidden_cwd");
+      const credentials = payload.credentials.map((reference) => {
+        let credential = this.config.credentials.find(
+          (c) => c.id === reference.id && c.generation === reference.generation && c.userId === operation.userId
+        );
+        let product = false;
+        if (!credential && this.config.productCredentialDirectory && /^product-[a-f0-9]{40}$/.test(reference.id)) {
+          const root = this.config.productCredentialDirectory, stat = lstatSync(root);
+          if (!stat.isDirectory() || stat.isSymbolicLink() || realpathSync(root) !== root || stat.uid !== process.getuid?.() || stat.mode & 63) throw new ExecutorError("forbidden_credential");
+          const fd = openSync(join(root, `${reference.id}-${reference.generation}.json`), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+          try {
+            const file = fstatSync(fd);
+            if (!file.isFile() || file.uid !== process.getuid?.() || file.mode & 63 || file.nlink !== 1 || file.size > 1024 * 1024) throw new ExecutorError("forbidden_credential");
+            credential = ExecutorCredential.parse(JSON.parse(readFileSync(fd, "utf8")));
+            product = credential.id === reference.id && credential.generation === reference.generation && credential.userId === operation.userId && credential.installationId === this.config.installationId && principal.userIds.includes(operation.userId);
+            if (!product) throw new ExecutorError("forbidden_credential");
+          } finally {
+            closeSync(fd);
+          }
+        }
+        if (!credential || !product && !principal.credentialIds.includes(reference.id)) throw new ExecutorError("forbidden_credential");
+        return credential;
+      });
+      const receipt2 = {
+        operationId: operation.operationId,
+        userId: operation.userId,
+        sessionId: operation.sessionId ?? null,
+        payloadHash: hash,
+        state: "accepted",
+        pid: null,
+        pty: !!payload.pty,
+        lane: payload.lane,
+        stdoutBytes: 0,
+        stderrBytes: 0,
+        stdinClosed: !payload.interactive,
+        exitCode: null,
+        signal: null,
+        reason: null
+      };
+      this.store.put(receipt2);
+      const secrets = join(this.config.stateDir, "secrets", tokenHash(operation.operationId));
+      try {
+        privateDirectory(secrets);
+        const env = { PATH: "/usr/local/bin:/usr/bin:/bin", LANG: "C.UTF-8", HOME: cwd, ...payload.env };
+        for (const credential of credentials) {
+          Object.assign(env, credential.env);
+          for (const [name, content] of Object.entries(credential.files)) {
+            const path = join(secrets, `${tokenHash(credential.id)}-${name}`);
+            writeFileSync(path, content, { flag: "wx", mode: 384 });
+            env[name] = path;
+          }
+        }
+        let child;
+        let pty;
+        let resolveExit;
+        const exited = new Promise((resolve) => {
+          resolveExit = resolve;
+        });
+        if (payload.pty) {
+          pty = new PtySession({ argv: payload.argv, cwd, env, cols: payload.pty.cols, rows: payload.pty.rows });
+          await pty.ready;
+        } else {
+          child = spawn(payload.argv[0], payload.argv.slice(1), { cwd, env, detached: true, stdio: "pipe" });
+        }
+        receipt2.pid = pty?.pid ?? child?.pid ?? null;
+        receipt2.state = "running";
+        const run2 = {
+          receipt: receipt2,
+          child,
+          pty,
+          secrets,
+          cancelled: false,
+          process: {
+            pid: receipt2.pid ?? 0,
+            exited,
+            kill: (signal) => {
+              if (pty) pty.kill(typeof signal === "string" ? signal : void 0);
+              else child.kill(signal);
+            }
+          },
+          timer: setTimeout(
+            () => {
+              void this.finish(run2, true, "runtime_limit").catch(() => {
+                this.poisoned = true;
+              });
+            },
+            Math.min(payload.timeoutMs ?? this.config.maxRunMs, this.config.maxRunMs, payload.lane === "control" ? 12e4 : Infinity)
+          )
+        };
+        this.active.set(receipt2.operationId, run2);
+        this.store.put(receipt2);
+        const onExit = (code, signal) => {
+          resolveExit(code ?? -1);
+          receipt2.exitCode = code;
+          receipt2.signal = signal;
+          void this.finish(run2, false).catch(() => {
+            this.poisoned = true;
+          });
+        };
+        if (pty) {
+          pty.onData((data) => this.output(run2, "stdout", Buffer.from(data)));
+          pty.onExit(({ exitCode, signal }) => {
+            if (exitCode === -1) receipt2.reason = "pty_helper_lost";
+            onExit(exitCode, signal ? String(signal) : null);
+          });
+        } else {
+          child.stdout.on("data", (data) => this.output(run2, "stdout", data));
+          child.stderr.on("data", (data) => this.output(run2, "stderr", data));
+          child.stdin.on("error", () => {
+            receipt2.stdinClosed = true;
+          });
+          child.once("error", () => {
+            receipt2.reason = "spawn_failed";
+          });
+          child.once("exit", () => {
+            void this.finish(run2, false).catch(() => {
+              this.poisoned = true;
+            });
+          });
+          child.once("close", onExit);
+          if (!payload.interactive) child.stdin.end();
+        }
+        return { ...receipt2 };
+      } catch {
+        receipt2.state = "unknown";
+        receipt2.reason = "admission_outcome_uncertain";
+        this.store.put(receipt2);
+        rmSync(secrets, { force: true, recursive: true });
+        return receipt2;
+      }
+    }
+    let receipt = this.receipt(principal, command.run);
+    if (command.method === "poll")
+      return {
+        receipt,
+        stdout: this.store.read(receipt.operationId, "stdout", command.stdoutOffset, receipt.stdoutBytes, command.maxBytes),
+        stderr: this.store.read(receipt.operationId, "stderr", command.stderrOffset, receipt.stderrBytes, command.maxBytes)
+      };
+    const actionHash = tokenHash(
+      canonicalJson({
+        method: command.method,
+        ...command.method === "write" ? { data: command.data, eof: command.eof } : command.method === "resize" ? { cols: command.cols, rows: command.rows } : {}
+      })
+    );
+    const prior = this.store.db.query("SELECT hash,state FROM actions WHERE run_id=? AND id=?").get(receipt.operationId, command.actionId);
+    if (prior) {
+      if (prior.hash !== actionHash) throw new ExecutorError("action_payload_mismatch");
+      return { actionId: command.actionId, state: prior.state };
+    }
+    const run = this.active.get(receipt.operationId);
+    if (command.method === "cancel") {
+      if (run?.finishing) {
+        await run.finishing.catch(() => {
+        });
+        receipt = this.receipt(principal, command.run);
+      }
+      if (receipt.state === "completed" || receipt.state === "cancelled") {
+        this.store.db.query("INSERT INTO actions VALUES (?,?,?,'completed')").run(receipt.operationId, command.actionId, actionHash);
+        return { actionId: command.actionId, state: "completed" };
+      }
+    }
+    if (!run || run.finishing) throw new ExecutorError(receipt.state === "unknown" ? "outcome_unknown" : "run_not_running");
+    if (command.method === "write" && receipt.stdinClosed) throw new ExecutorError("stdin_closed");
+    if (command.method === "resize" && !run.pty) throw new ExecutorError("not_a_pty");
+    this.store.db.query("INSERT INTO actions VALUES (?,?,?,'accepted')").run(receipt.operationId, command.actionId, actionHash);
+    try {
+      if (command.method === "cancel") await this.finish(run, true, "requested");
+      else if (command.method === "resize") await run.pty.resize(command.cols, command.rows);
+      else {
+        if (run.pty) {
+          await run.pty.write(command.data);
+          if (command.eof) await run.pty.write("");
+        } else {
+          await new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new ExecutorError("input_outcome_unknown")), 2e3);
+            run.child.stdin.write(command.data, (error) => {
+              clearTimeout(timer);
+              if (error) reject(error);
+              else resolve();
+            });
+          });
+          if (command.eof) run.child.stdin.end();
+        }
+        if (command.eof) {
+          receipt.stdinClosed = true;
+          run.receipt.stdinClosed = true;
+          this.store.put(run.receipt);
+        }
+      }
+      this.store.db.query("UPDATE actions SET state='completed' WHERE run_id=? AND id=?").run(receipt.operationId, command.actionId);
+      return { actionId: command.actionId, state: "completed" };
+    } catch {
+      if (command.method === "write") {
+        run.receipt.stdinClosed = true;
+        this.store.put(run.receipt);
+      }
+      this.store.db.query("UPDATE actions SET state='unknown' WHERE run_id=? AND id=?").run(receipt.operationId, command.actionId);
+      return { actionId: command.actionId, state: "unknown" };
+    }
+  }
+  output(run, stream, data) {
+    try {
+      if (run.receipt.stdoutBytes + run.receipt.stderrBytes + data.length > this.config.maxLogBytes) {
+        void this.finish(run, true, "output_limit").catch(() => {
+          this.poisoned = true;
+        });
+        return;
+      }
+      this.store.append(run.receipt.operationId, stream, data);
+      run.receipt[stream === "stdout" ? "stdoutBytes" : "stderrBytes"] += data.length;
+      this.store.put(run.receipt);
+    } catch {
+      this.poisoned = true;
+      void this.finish(run, true, "output_persistence_failed").catch(() => {
+      });
+    }
+  }
+  finish(run, cancelled, reason) {
+    if (cancelled) run.cancelled = true;
+    if (reason) run.receipt.reason = reason;
+    if (run.finishing) return run.finishing;
+    run.finishing = (async () => {
+      clearTimeout(run.timer);
+      let cleanupFailed = run.receipt.reason === "pty_helper_lost";
+      try {
+        if (run.process.pid) await terminateProcessTree(run.process, { graceMs: 200, forceKillWaitMs: 1e3 });
+        await Promise.race([
+          run.process.exited,
+          new Promise((_, reject) => {
+            const timer = setTimeout(() => reject(new ExecutorError("process_exit_unknown")), 2e3);
+            void run.process.exited.then(() => clearTimeout(timer));
+          })
+        ]);
+      } catch {
+        cleanupFailed = true;
+      }
+      rmSync(run.secrets, { recursive: true, force: true });
+      run.receipt.state = cleanupFailed ? "unknown" : run.cancelled ? "cancelled" : "completed";
+      run.receipt.stdinClosed = true;
+      if (cleanupFailed) run.receipt.reason = "process_cleanup_uncertain";
+      this.store.put(run.receipt);
+      this.active.delete(run.receipt.operationId);
+      if (cleanupFailed) throw new ExecutorError("process_cleanup_uncertain");
+    })();
+    return run.finishing;
+  }
+  async close() {
+    this.closing = true;
+    clearInterval(this.leaseTimer);
+    await this.serial;
+    await Promise.allSettled([...this.active.values()].map((run) => this.finish(run, true, "executor_shutdown")));
+    this.store.close();
+  }
+}
+export {
+  HostExecutor,
+  tokenHash
+};

package/dist/mjs/runtime/index.mjs

@@ -0,0 +1,15 @@
+import { startHostExecutor } from "./daemon.mjs";
+import { HostExecutorClient } from "./client.mjs";
+import { tokenHash } from "./executor.mjs";
+import { AdapterConfig, ExecutorConfig, ExecutorCommand, ExecutorError, EXECUTOR_CAPABILITY, ShellPayload } from "./protocol.mjs";
+export {
+  AdapterConfig,
+  EXECUTOR_CAPABILITY,
+  ExecutorCommand,
+  ExecutorConfig,
+  ExecutorError,
+  HostExecutorClient,
+  ShellPayload,
+  startHostExecutor,
+  tokenHash
+};

package/dist/mjs/runtime/protocol.mjs

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import { OperationEnvelope, OwnershipFence, RUNTIME_PROTOCOL, RuntimeHello, RuntimeId } from "@ricsam/r5d-api/runtime-protocol";
+const EXECUTOR_CAPABILITY = "host-executor-v1";
+const MAX_FRAME_BYTES = 1024 * 1024;
+const text = z.string().max(256 * 1024).refine((s) => !s.includes("\0"), "NUL is not allowed");
+const absolutePath = z.string().min(1).max(4096).refine((s) => s.startsWith("/") && !s.includes("\0"), "Absolute POSIX path required");
+const Lane = z.enum(["general", "utility", "control"]);
+const ShellPayload = z.object({
+  argv: z.array(text).min(1).max(256).refine((argv) => !!argv[0]),
+  cwd: absolutePath,
+  env: z.record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), text).default({}),
+  lane: Lane.default("general"),
+  interactive: z.boolean().default(false),
+  pty: z.object({ cols: z.number().int().min(1).max(1e3), rows: z.number().int().min(1).max(1e3) }).strict().optional(),
+  credentials: z.array(z.object({ id: RuntimeId, generation: z.number().int().positive() }).strict()).max(32).default([]),
+  timeoutMs: z.number().int().min(100).max(864e5).optional()
+}).strict();
+const RunIdentity = z.object({ operationId: RuntimeId, userId: RuntimeId, sessionId: RuntimeId.optional(), fence: OwnershipFence }).strict();
+const Principal = z.object({
+  id: RuntimeId,
+  tokenHash: z.string().regex(/^[a-f0-9]{64}$/),
+  role: z.enum(["controller", "adapter"]),
+  ownerId: RuntimeId,
+  userIds: z.array(RuntimeId).min(1),
+  cwdRoots: z.array(absolutePath),
+  lanes: z.array(Lane),
+  credentialIds: z.array(RuntimeId)
+}).strict();
+const AdapterGrant = z.object({
+  installationId: RuntimeId,
+  workerId: RuntimeId,
+  principal: Principal.extend({ role: z.literal("adapter") }),
+  hello: RuntimeHello,
+  artifactDigest: z.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+const ExecutorCommand = z.discriminatedUnion("method", [
+  z.object({ method: z.literal("adapter.register"), grant: AdapterGrant }).strict(),
+  z.object({ method: z.literal("adapter.retire"), principalId: RuntimeId }).strict(),
+  z.object({ method: z.literal("status") }).strict(),
+  z.object({ method: z.literal("authority"), fence: OwnershipFence, validUntil: z.number().int().positive() }).strict(),
+  z.object({ method: z.literal("start"), operation: OperationEnvelope }).strict(),
+  z.object({
+    method: z.literal("poll"),
+    run: RunIdentity,
+    stdoutOffset: z.number().int().nonnegative().default(0),
+    stderrOffset: z.number().int().nonnegative().default(0),
+    maxBytes: z.number().int().min(1).max(65536).default(32768)
+  }).strict(),
+  z.object({ method: z.literal("write"), run: RunIdentity, actionId: RuntimeId, data: text, eof: z.boolean().default(false) }).strict(),
+  z.object({
+    method: z.literal("resize"),
+    run: RunIdentity,
+    actionId: RuntimeId,
+    cols: z.number().int().min(1).max(1e3),
+    rows: z.number().int().min(1).max(1e3)
+  }).strict(),
+  z.object({ method: z.literal("cancel"), run: RunIdentity, actionId: RuntimeId }).strict()
+]);
+const ExecutorRequest = z.object({
+  protocol: z.literal(RUNTIME_PROTOCOL),
+  requestId: RuntimeId,
+  auth: z.object({ principalId: RuntimeId, token: z.string().min(32).max(512) }).strict(),
+  hello: RuntimeHello,
+  command: ExecutorCommand
+}).strict();
+const ExecutorCredential = z.object({
+  id: RuntimeId,
+  installationId: RuntimeId,
+  userId: RuntimeId,
+  generation: z.number().int().positive(),
+  env: z.record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), text),
+  files: z.record(z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/), text)
+}).strict().refine((value) => !["R5D_ROOT", "R5D_SESSION_ID"].some((name) => name in value.env || name in value.files), "Workspace identity environment is authority controlled");
+const ExecutorConfig = z.object({
+  installationId: RuntimeId,
+  workerId: RuntimeId,
+  instanceId: RuntimeId,
+  releaseId: RuntimeId,
+  stateDir: absolutePath,
+  /** Private immutable snapshots materialized by the independent workspace service. */
+  productCredentialDirectory: absolutePath.optional(),
+  capacity: z.object({
+    general: z.number().int().min(1).max(100),
+    utility: z.number().int().min(0).max(100),
+    control: z.number().int().min(0).max(100)
+  }).strict(),
+  maxLeaseMs: z.number().int().min(1e3).max(3e5).default(3e5),
+  maxRunMs: z.number().int().min(100).max(864e5).default(36e5),
+  maxLogBytes: z.number().int().min(1024).max(1024 * 1024 * 1024).default(64 * 1024 * 1024),
+  principals: z.array(Principal).min(1),
+  credentials: z.array(ExecutorCredential).default([])
+}).strict().superRefine((value, ctx) => {
+  for (const field of ["principals", "credentials"]) {
+    if (new Set(value[field].map((item) => item.id)).size !== value[field].length)
+      ctx.addIssue({ code: "custom", message: `Duplicate ${field}` });
+  }
+  if (value.credentials.some((credential) => credential.installationId !== value.installationId))
+    ctx.addIssue({ code: "custom", message: "Cross-installation credential" });
+});
+const AdapterConfig = z.object({
+  socketPath: absolutePath,
+  principalId: RuntimeId,
+  token: z.string().min(32).max(512),
+  hello: RuntimeHello,
+  timeoutMs: z.number().int().min(100).max(6e4).default(1e4)
+}).strict();
+class ExecutorError extends Error {
+  constructor(code, message = code, rejectedBeforeAdmission = false) {
+    super(message);
+    this.code = code;
+    this.rejectedBeforeAdmission = rejectedBeforeAdmission;
+    this.name = "ExecutorError";
+  }
+  code;
+  rejectedBeforeAdmission;
+}
+function isStartNonAdmissionCode(code) {
+  return code === "stale_fence" || code === "capacity_busy";
+}
+function isDefiniteStartRejection(error) {
+  return error instanceof ExecutorError && error.rejectedBeforeAdmission === true && isStartNonAdmissionCode(error.code);
+}
+export {
+  AdapterConfig,
+  AdapterGrant,
+  EXECUTOR_CAPABILITY,
+  ExecutorCommand,
+  ExecutorConfig,
+  ExecutorCredential,
+  ExecutorError,
+  ExecutorRequest,
+  Lane,
+  MAX_FRAME_BYTES,
+  Principal,
+  RunIdentity,
+  ShellPayload,
+  isDefiniteStartRejection,
+  isStartNonAdmissionCode
+};