@vzn/vx 0.0.650 → 0.0.652

package/src/exec/spawn-off.ts

@@ -0,0 +1,154 @@
+// A task's spawn on a thread of its own. Bun's spawn holds the calling
+// thread until the child has exec'd (vfork), ~0.6 ms a task, and on a cold
+// run that thread is the scheduler's: 2,000 tasks with 1.8 ms of the
+// scheduler's own work each took 4.96 s spawned there and 3.71 s spawned
+// here, the 3.6 s of that work the floor (2026-10-29). The child's
+// descriptors are numbers in the one table every thread shares, so its
+// pipes are made and read where they were; only the spawn and the wait
+// for its exit move.
+
+import type { ResourceUsage } from 'bun'
+
+/** What `runCommand` reads of a child spawned here. */
+export interface OffChild {
+  readonly pid: number
+  readonly exited: Promise<number>
+  readonly exitCode: number | null
+  readonly signalCode: NodeJS.Signals | null
+  resourceUsage(): ResourceUsage | undefined
+  kill(signal?: NodeJS.Signals | number): void
+  /** Hold the process open from now until the child exits: a spawn with `held: false` does not. */
+  hold(): void
+}
+
+export interface OffSpawn {
+  cmd: string[]
+  argv0?: string
+  cwd?: string
+  env?: Record<string, string>
+  /** Each a descriptor number or `'ignore'`: a stream cannot cross threads. */
+  stdio: Array<number | 'ignore'>
+  detached?: boolean
+  /** False: the child keeps no run alive until `hold()` (a spare shell waiting for its task). */
+  held?: boolean
+}
+
+// The worker as source, not a file: a compiled vx carries only its entry
+// point's graph, and a worker file would need an entry point of its own.
+const WORKER = `
+const live = new Map()
+self.onmessage = (e) => {
+  const m = e.data
+  if (m.kill !== undefined) { live.get(m.kill)?.kill(m.signal); return }
+  let p
+  try {
+    p = Bun.spawn(m.opts.cmd, m.opts)
+  } catch (err) {
+    postMessage({ id: m.id, error: { message: String(err?.message ?? err), code: err?.code } })
+    return
+  }
+  live.set(m.id, p)
+  postMessage({ id: m.id, pid: p.pid })
+  p.exited.then(() => {
+    live.delete(m.id)
+    const u = p.resourceUsage()
+    // Its two fields vx reads: the object itself does not cross threads.
+    const usage = u === undefined ? undefined : { cpuTime: { user: u.cpuTime.user, system: u.cpuTime.system, total: u.cpuTime.total }, maxRSS: u.maxRSS }
+    postMessage({ id: m.id, exitCode: p.exitCode, signalCode: p.signalCode, usage })
+  })
+}
+`
+
+interface Pending {
+  held: () => boolean
+  spawned: (pid: number) => void
+  failed: (err: Error) => void
+  exit: (m: {
+    exitCode: number | null
+    signalCode: NodeJS.Signals | null
+    usage?: ResourceUsage
+  }) => void
+}
+
+let worker: Worker | undefined
+let nextId = 0
+const pending = new Map<number, Pending>()
+let liveCount = 0
+
+function thread(): Worker {
+  if (worker !== undefined) return worker
+  const w = new Worker(URL.createObjectURL(new Blob([WORKER], { type: 'text/javascript' })))
+  w.onmessage = (e: MessageEvent) => {
+    const m = e.data
+    const p = pending.get(m.id)
+    if (p === undefined) return
+    if (m.error !== undefined) {
+      pending.delete(m.id)
+      const err = new Error(m.error.message) as NodeJS.ErrnoException
+      if (m.error.code !== undefined) err.code = m.error.code
+      if (p.held()) settleLive(-1)
+      p.failed(err)
+    } else if (m.pid !== undefined) p.spawned(m.pid)
+    else {
+      pending.delete(m.id)
+      if (p.held()) settleLive(-1)
+      p.exit(m)
+    }
+  }
+  // An idle thread keeps no run alive.
+  w.unref()
+  worker = w
+  return w
+}
+
+/** Hold the process open while a child spawned here runs, as a spawn on the main thread does. */
+function settleLive(delta: number): void {
+  liveCount += delta
+  if (liveCount > 0) worker?.ref()
+  else worker?.unref()
+}
+
+/** Spawn `opts` on the spawn thread; resolves once the child is running, rejects when the spawn threw. */
+export function spawnOff(opts: OffSpawn): Promise<OffChild> {
+  const w = thread()
+  const id = nextId++
+  let held = opts.held !== false
+  if (held) settleLive(1)
+  const { held: _, ...spawn } = opts
+  return new Promise((resolve, reject) => {
+    let exitCode: number | null = null
+    let signalCode: NodeJS.Signals | null = null
+    let usage: ResourceUsage | undefined
+    let onExit!: (code: number) => void
+    const exited = new Promise<number>((r) => (onExit = r))
+    pending.set(id, {
+      held: () => held,
+      failed: reject,
+      spawned: (pid) =>
+        resolve({
+          pid,
+          exited,
+          get exitCode() {
+            return exitCode
+          },
+          get signalCode() {
+            return signalCode
+          },
+          resourceUsage: () => usage,
+          kill: (signal) => w.postMessage({ kill: id, signal }),
+          hold: () => {
+            if (held || exitCode !== null || signalCode !== null) return
+            held = true
+            settleLive(1)
+          },
+        }),
+      exit: (m) => {
+        exitCode = m.exitCode
+        signalCode = m.signalCode
+        usage = m.usage
+        onExit(exitCode ?? 1)
+      },
+    })
+    w.postMessage({ id, opts: spawn })
+  })
+}

package/src/exec/task-proxy.ts

@@ -0,0 +1,93 @@
+// One task's own proxy: the runtime's proxy is the run's and judges every
+// connection by the union of all tasks' network lists, so a task reached a
+// host only another task of the run declared. Each networked task gets this
+// front on its own socket, which judges by the task's lists and hands what
+// it allows to the run's proxy as its parent (that proxy still applies the
+// union and its address guard). A task names itself to a proxy by a
+// username it writes, so only the socket it was given says which task it is.
+
+import { BlockList } from 'node:net'
+
+/** The deep modules of the runtime the front is built from: its own proxy code, not a copy. */
+async function loadProxyParts() {
+  // Literal specifiers: `bun build --compile` embeds only what it can see.
+  const [http, socks, mux, pattern, parent] = await Promise.all([
+    import('@anthropic-ai/sandbox-runtime/dist/sandbox/http-proxy.js'),
+    import('@anthropic-ai/sandbox-runtime/dist/sandbox/socks-proxy.js'),
+    import('@anthropic-ai/sandbox-runtime/dist/sandbox/mux-proxy.js'),
+    import('@anthropic-ai/sandbox-runtime/dist/sandbox/domain-pattern.js'),
+    import('@anthropic-ai/sandbox-runtime/dist/sandbox/parent-proxy.js'),
+  ])
+  return { http, socks, mux, pattern, parent }
+}
+
+export interface TaskProxy {
+  close(): Promise<void>
+}
+
+/**
+ * Listen at `endpoint` (a unix socket path, or 0 for a localhost port) for
+ * one task. Returns the bound port when `endpoint` is 0.
+ */
+export async function startTaskProxy(opts: {
+  endpoint: string | 0
+  allowed: readonly string[]
+  denied: readonly string[]
+  /** The run's proxy: its port and the session token both legs carry. */
+  runProxyPort: number
+  token: string
+  /** The task's attribution key (`srt.<encodedCommand>`'s suffix). */
+  encodedCommand: string
+  /** A refusal this front made, in the runtime's own record form. */
+  refused(line: string): void
+}): Promise<TaskProxy & { port: number | undefined }> {
+  const { http, socks, mux, pattern, parent } = await loadProxyParts()
+  const filter = (port: number, host: string): boolean => {
+    const deny = (reason: string) => {
+      opts.refused(`deny network-outbound ${host}:${port} (${reason})`)
+      return false
+    }
+    if (!parent.isValidHost(host)) return deny('malformed host')
+    const canonical: string = parent.canonicalizeHost(host) ?? host
+    if (opts.denied.some((d) => pattern.matchesDomainPatternWithPort(canonical, port, d)))
+      return deny('host is on the deny list')
+    if (opts.allowed.some((a) => pattern.matchesDomainPatternWithPort(canonical, port, a)))
+      return true
+    return deny('host is not on the allow list')
+  }
+  const user = encodeURIComponent(`srt.${opts.encodedCommand}`)
+  const up = new URL(
+    `http://${user}:${encodeURIComponent(opts.token)}@127.0.0.1:${opts.runProxyPort}`,
+  )
+  // Every allowed connection goes on to the run's proxy, which applies the
+  // run's lists and address guard again; only a loopback host, which the
+  // runtime never sends to a parent, is dialed from here, and only one the
+  // task named.
+  const parentProxy = {
+    httpUrl: up,
+    httpsUrl: up,
+    noProxy: { all: false, suffixes: [], cidr: new BlockList() },
+  }
+  const httpServer = http.createHttpProxyServer({
+    filter: (port: number, host: string) => filter(port, host),
+    parentProxy,
+    proxyAuthToken: opts.token,
+  })
+  const socksServer = socks.createSocksProxyServer({
+    filter: (port: number, host: string) => filter(port, host),
+    parentProxy,
+    proxyAuthToken: opts.token,
+  })
+  const front = mux.createMuxProxyServer({
+    httpServer,
+    handleSocksConnection: (s) => socksServer.handleConnection(s),
+  })
+  await front.listenHttpBackend()
+  await new Promise<void>((resolve, reject) => {
+    front.server.once('error', reject)
+    if (opts.endpoint === 0) front.server.listen(0, '127.0.0.1', () => resolve())
+    else front.server.listen(opts.endpoint, () => resolve())
+  })
+  front.unref()
+  return { port: front.getPort(), close: () => front.close() }
+}

package/src/exec/warm-shell.ts

@@ -0,0 +1,146 @@
+// A task's shell, started before the task is asked for. A slot that frees
+// on a cold run starts its next task at once, and sh's own exec was part of
+// that turn: 200 `sleep 0.02` took 4.4 ms each past their sleep spawned
+// fresh, 2.7 ms in a shell already waiting (2026-11-01). The spare holds
+// no task's directory or env: it waits on a pipe, and the task's script,
+// written when it is taken, moves it to the task's directory and exports
+// the task's env before the command runs, so each task still has a shell
+// of its own (its CPU and memory are the shell's) and vx keeps no process
+// beyond a run. Linux only, where a task's pipes are vx's own descriptors.
+
+import { closeSync, writeSync } from 'node:fs'
+import { taskShell } from '../util/index.js'
+import { flushGuard, listGroup } from './kill-tree.js'
+import { heldPipe, TaskPipes } from './pipes.js'
+import { type OffChild, spawnOff } from './spawn-off.js'
+
+/** A shell waiting for its task's script on descriptor 3. */
+export interface Spare {
+  readonly child: Promise<OffChild>
+  readonly pipes: TaskPipes
+  /** The write end of the script's pipe; closed once the script is in. */
+  readonly script: number
+}
+
+/**
+ * Spares kept waiting. Two: a cold run's slots free one at a time, and a
+ * burst (the run's first tasks) spawns fresh while the pool fills.
+ */
+const SPARES = 2
+
+const spares: Spare[] = []
+/** A spare that could not start (no libc pipes, a refused spawn): no more are tried. */
+let off = false
+
+// `exec 3<&-` first: dash reads the script through its own descriptor,
+// opened on /dev/fd/3 and closed on exec, so the task inherits no 3.
+const WAIT = '. /dev/fd/3'
+
+function start(): Spare | undefined {
+  const fds = heldPipe()
+  if (fds === undefined) return undefined
+  let sh: string
+  try {
+    sh = taskShell()
+  } catch {
+    // No shell on vx's PATH: the task's own spawn says so.
+    closeSync(fds[0]!)
+    closeSync(fds[1]!)
+    return undefined
+  }
+  const pipes = new TaskPipes()
+  // vx lists the spare's group itself, with the turn's other lines: the
+  // spare runs nothing before `runOnSpare` flushes them.
+  const child = spawnOff({
+    cmd: [sh, '-c', WAIT],
+    argv0: 'sh',
+    cwd: '/',
+    env: {},
+    detached: true,
+    held: false,
+    stdio: ['ignore', ...(pipes.stdio as [number, number]), fds[0]!],
+  }).then((c) => {
+    listGroup(c.pid)
+    return c
+  })
+  const settled = child.finally(() => {
+    pipes.spawned()
+    closeSync(fds[0]!)
+  })
+  settled.catch(() => {
+    off = true
+    pipes.close()
+    closeSync(fds[1]!)
+  })
+  return { child: settled, pipes, script: fds[1]! }
+}
+
+/** A spare for the next task, or undefined; starts another in its place. */
+export function takeSpare(): Spare | undefined {
+  const taken = spares.shift()
+  while (!off && spares.length < SPARES) {
+    const s = start()
+    if (s === undefined) {
+      off = true
+      break
+    }
+    spares.push(s)
+  }
+  return taken
+}
+
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/
+const quote = (v: string): string => `'${v.replaceAll("'", "'\\''")}'`
+
+/**
+ * The script a spare runs as the task: its directory (127 when it is gone,
+ * as a spawn into it fails; the OLDPWD `cd` sets is not the task's), its
+ * env, then `command`. Undefined when an env
+ * name is one sh cannot export: that task spawns fresh.
+ */
+export function spareScript(
+  cwd: string,
+  env: Readonly<Record<string, string | undefined>>,
+  command: string,
+): string | undefined {
+  // A script past what one pipe write lands whole would hold vx's thread.
+  if (command.length > SCRIPT_BYTES) return undefined
+  let out = `exec 3<&-\ncd -- ${quote(cwd)} 2>/dev/null || exit 127\nunset OLDPWD\n`
+  for (const k in env) {
+    const v = env[k]
+    // Undefined unsets the name: a spawn drops it.
+    if (v === undefined) continue
+    if (!NAME.test(k)) return undefined
+    out += `export ${k}=${quote(v)}\n`
+  }
+  out += `${command}\n`
+  return Buffer.byteLength(out) > SCRIPT_BYTES ? undefined : out
+}
+
+/** A pipe holds 64 KiB: a script under it is written without waiting on the shell's read. */
+const SCRIPT_BYTES = 60 * 1024
+
+/**
+ * Hand `spare` its script. False when the spare is gone (killed, or its
+ * spawn refused): the task then spawns fresh.
+ */
+export async function runOnSpare(spare: Spare, script: string): Promise<OffChild | undefined> {
+  let child: OffChild
+  try {
+    child = await spare.child
+  } catch {
+    return undefined
+  }
+  try {
+    // Its group listed before it runs a line of the task.
+    flushGuard()
+    writeSync(spare.script, script)
+  } catch {
+    child.kill('SIGKILL')
+    return undefined
+  } finally {
+    closeSync(spare.script)
+  }
+  child.hold()
+  return child
+}

package/src/graph/critical-path.ts

@@ -29,14 +29,26 @@ export function criticalPath(
       ? (p50s[Math.floor(p50s.length / 2)] ?? DEFAULT_DURATION_MS)
       : DEFAULT_DURATION_MS
 
-  const dependentsOf = new Map<string, string[]>()
-  for (const n of nodes) {
-    for (const upstreamId of n.deps) {
-      const list = dependentsOf.get(upstreamId)
-      if (list) list.push(n.id)
-      else dependentsOf.set(upstreamId, [n.id])
+  // Integer ids and flat arrays: Maps keyed by id strings and an array per
+  // node were 53 ms of a 9,603-task run's schedule stage (2026-11-01).
+  const count = nodes.length
+  const index = new Map<string, number>()
+  for (let i = 0; i < count; i++) index.set(nodes[i]!.id, i)
+  // Each node's dependents, as one flat list sliced by `first`.
+  const ups: number[] = []
+  const first = new Int32Array(count + 1)
+  for (let i = 0; i < count; i++) {
+    for (const up of nodes[i]!.deps) {
+      const u = index.get(up)
+      if (u === undefined) continue
+      first[u + 1]!++
+      ups.push(u, i)
     }
   }
+  for (let i = 0; i < count; i++) first[i + 1]! += first[i]!
+  const next = first.slice(0, count)
+  const dependents = new Int32Array(ups.length / 2)
+  for (let e = 0; e < ups.length; e += 2) dependents[next[ups[e]!]!++] = ups[e + 1]!
   // A group runs nothing, so it has no history; the median would charge it
   // a whole task and let a gate outrank the longest chain (PR #3286).
   const ownDuration = (n: TaskNode): number =>
@@ -47,33 +59,33 @@ export function criticalPath(
   // Reverse-topological pass: a node's value is final once every dependent's
   // is, so start from the sinks (no dependents) and release each upstream
   // when its last dependent has been scored.
-  const memo = new Map<string, number>()
-  const nodeById = new Map<string, TaskNode>(nodes.map((n) => [n.id, n]))
-  const pending = new Map<string, number>()
-  const queue: TaskNode[] = []
-  for (const n of nodes) {
-    const count = dependentsOf.get(n.id)?.length ?? 0
-    pending.set(n.id, count)
-    if (count === 0) queue.push(n)
+  const score = new Float64Array(count)
+  const scored = new Uint8Array(count)
+  const pending = new Int32Array(count)
+  const queue = new Int32Array(count)
+  let tail = 0
+  for (let i = 0; i < count; i++) {
+    pending[i] = first[i + 1]! - first[i]!
+    if (pending[i] === 0) queue[tail++] = i
   }
-  let head = 0
-  while (head < queue.length) {
-    const n = queue[head++]!
+  for (let head = 0; head < tail; head++) {
+    const i = queue[head]!
     let downstream = 0
-    for (const dep of dependentsOf.get(n.id) ?? []) {
-      const d = memo.get(dep) ?? 0
+    for (let e = first[i]!; e < first[i + 1]!; e++) {
+      const d = score[dependents[e]!]!
       if (d > downstream) downstream = d
     }
-    memo.set(n.id, ownDuration(n) + downstream)
-    for (const up of n.deps) {
-      const left = (pending.get(up) ?? 0) - 1
-      pending.set(up, left)
-      if (left === 0) {
-        const upNode = nodeById.get(up)
-        if (upNode) queue.push(upNode)
-      }
+    score[i] = ownDuration(nodes[i]!) + downstream
+    scored[i] = 1
+    for (const up of nodes[i]!.deps) {
+      const u = index.get(up)
+      if (u !== undefined && --pending[u]! === 0) queue[tail++] = u
     }
   }
-  for (const n of nodes) if (!memo.has(n.id)) memo.set(n.id, ownDuration(n))
+  const memo = new Map<string, number>()
+  for (let head = 0; head < tail; head++) memo.set(nodes[queue[head]!]!.id, score[queue[head]!]!)
+  // A node on a cycle is never released: its own duration.
+  for (let i = 0; i < count; i++)
+    if (scored[i] === 0) memo.set(nodes[i]!.id, ownDuration(nodes[i]!))
   return memo
 }

package/src/graph/definition.ts

@@ -15,18 +15,31 @@ const memo = new WeakMap<TaskNode, string | undefined>()
 export function taskDefinition(node: TaskNode): string | undefined {
   if (memo.has(node)) return memo.get(node)
   const exec = node.config.exec
+  const define = exec?.env?.define
   const def =
     exec?.command === undefined
       ? undefined
       : xxh3hex(
-          `${node.id}\0${exec.command}\0${JSON.stringify(
-            Object.entries(exec.env?.define ?? {}).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
-          )}`,
+          `${node.id}\0${exec.command}\0${
+            // `[]` is what the stringify gives for no values: most tasks
+            // have none, and stringifying it for each was ~9 ms of an
+            // 8,002-hit warm run.
+            define === undefined || isEmpty(define)
+              ? '[]'
+              : JSON.stringify(
+                  Object.entries(define).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)),
+                )
+          }`,
         )
   memo.set(node, def)
   return def
 }
 
+function isEmpty(o: object): boolean {
+  for (const _ in o) return false
+  return true
+}
+
 /** Each task's definition (`taskDefinition`) by id, groups left out: what a history reader matches rows to. */
 export function taskDefinitions(nodes: Iterable<TaskNode>): Map<string, string> {
   const out = new Map<string, string>()