@tanstack/ai-sandbox 0.1.0

package/src/sandbox.ts

@@ -0,0 +1,259 @@
+/**
+ * `defineSandbox()` returns a LAZY controller — it never creates a sandbox at
+ * definition time. `withSandbox()` (and advanced users) call `ensure()` to
+ * resume-or-create, following: provider.resume → provider.restoreSnapshot →
+ * create + bootstrap. The controller folds provider/workspace/policy/lifecycle
+ * into a stable instance key and coordinates through the (optional) lock +
+ * sandbox stores.
+ */
+import { bootstrapWorkspace } from './bootstrap'
+import { resolveAllSecrets } from './secrets'
+import { computeSandboxKey } from './key'
+import { InMemoryLockStore, InMemorySandboxStore } from './store'
+import type { SandboxFileEvent } from '@tanstack/ai'
+import type { SandboxHandle, SandboxProvider } from './contracts'
+import type { SandboxKeyInput } from './key'
+import type { LockStore, SandboxStore } from './store'
+import type { SandboxPolicy } from './policy'
+import type { WorkspaceDefinition } from './workspace'
+
+/**
+ * Sandbox-scoped hooks declared on `defineSandbox`. File hooks fire for every
+ * create/change/delete during a chat run; lifecycle hooks fire server-side.
+ */
+export interface SandboxHooks {
+  onFile?: (e: SandboxFileEvent) => void | Promise<void>
+  onFileCreate?: (e: SandboxFileEvent) => void | Promise<void>
+  onFileChange?: (e: SandboxFileEvent) => void | Promise<void>
+  onFileDelete?: (e: SandboxFileEvent) => void | Promise<void>
+  onReady?: (handle: SandboxHandle) => void | Promise<void>
+  onError?: (err: unknown) => void | Promise<void>
+  onDestroy?: () => void | Promise<void>
+}
+
+export type ReuseStrategy = 'thread' | 'none'
+export type SnapshotStrategy = 'after-setup' | 'after-run' | 'none'
+
+export interface SandboxLifecycle {
+  /** `'thread'` resumes one sandbox per thread; `'none'` is fresh per run. */
+  reuse?: ReuseStrategy
+  /** When to snapshot (provider-permitting). */
+  snapshot?: SnapshotStrategy
+  /** Hint for how long a provider should keep the sandbox warm between runs. */
+  keepAlive?: string
+  /** Destroy the sandbox after the run completes. */
+  destroyOnComplete?: boolean
+  /**
+   * Maximum age of a sandbox record before it is discarded and re-created
+   * instead of resumed. Accepts `'<n>h'` (hours) or `'<n>m'` (minutes),
+   * e.g. `'2h'` or `'30m'`.
+   */
+  snapshotMaxAge?: string
+}
+
+export interface SandboxConfig {
+  id: string
+  provider: SandboxProvider
+  workspace?: WorkspaceDefinition
+  policy?: SandboxPolicy
+  lifecycle?: SandboxLifecycle
+  /** Sandbox-scoped file/lifecycle hooks. */
+  hooks?: SandboxHooks
+  /** Watch the workspace for file events (default true). Set false to disable. */
+  fileEvents?: boolean
+}
+
+/** Context passed to `ensure()` by `withSandbox` (or advanced callers). */
+export interface SandboxEnsureContext {
+  threadId: string
+  runId: string
+  /** Persistence seam; falls back to an in-memory store when absent. */
+  store?: SandboxStore
+  /** Lock seam; falls back to an in-memory lock when absent. */
+  locks?: LockStore
+  tenant?: { userId?: string; orgId?: string }
+  signal?: AbortSignal
+}
+
+export interface SandboxDefinition {
+  readonly id: string
+  readonly provider: SandboxProvider
+  readonly workspace?: WorkspaceDefinition
+  readonly policy?: SandboxPolicy
+  readonly lifecycle?: SandboxLifecycle
+  /** Sandbox-scoped file/lifecycle hooks. */
+  readonly hooks?: SandboxHooks
+  /** Watch the workspace for file events (default true). Set false to disable. */
+  readonly fileEvents?: boolean
+  /** Compound instance key for a given run context. */
+  key: (ctx: SandboxEnsureContext) => string
+  /** Resume-or-create the sandbox for this thread/run. */
+  ensure: (ctx: SandboxEnsureContext) => Promise<SandboxHandle>
+  /** Tear down the sandbox recorded for this key. */
+  destroy: (ctx: SandboxEnsureContext) => Promise<void>
+}
+
+/**
+ * Parse a human-readable duration string into milliseconds.
+ * Supports `'<n>h'` (hours) and `'<n>m'` (minutes).
+ * Returns `undefined` when the input is undefined or the format is unrecognised.
+ */
+function parseMaxAgeMs(value: string | undefined): number | undefined {
+  if (value === undefined) return undefined
+  const hourMatch = /^(\d+)h$/.exec(value)
+  if (hourMatch) return Number(hourMatch[1]) * 60 * 60 * 1000
+  const minuteMatch = /^(\d+)m$/.exec(value)
+  if (minuteMatch) return Number(minuteMatch[1]) * 60 * 1000
+  return undefined
+}
+
+// Process-lifetime fallbacks shared across all definitions so concurrent
+// ensures for the same key serialize even without an injected store/lock.
+const fallbackStore = new InMemorySandboxStore()
+const fallbackLocks = new InMemoryLockStore()
+
+export function defineSandbox(config: SandboxConfig): SandboxDefinition {
+  const keyInputFor = (ctx: SandboxEnsureContext): SandboxKeyInput => ({
+    threadId:
+      config.lifecycle?.reuse === 'none'
+        ? `${ctx.threadId}:${ctx.runId}`
+        : ctx.threadId,
+    sandboxId: config.id,
+    providerName: config.provider.name,
+    workspace: config.workspace,
+    tenant: ctx.tenant,
+  })
+
+  const ensure = async (ctx: SandboxEnsureContext): Promise<SandboxHandle> => {
+    const store = ctx.store ?? fallbackStore
+    const locks = ctx.locks ?? fallbackLocks
+    const key = computeSandboxKey(keyInputFor(ctx))
+    const caps = config.provider.capabilities()
+
+    return locks.withLock(`sandbox:${key}`, async () => {
+      const effectiveSnapshot: SnapshotStrategy =
+        config.lifecycle?.snapshot ?? (caps.snapshots ? 'after-setup' : 'none')
+      const maxAgeMs = parseMaxAgeMs(config.lifecycle?.snapshotMaxAge)
+
+      const existing = await store.get(key)
+      if (existing) {
+        // Check whether the record has exceeded snapshotMaxAge; if so,
+        // discard and fall through to a fresh create.
+        const tooOld =
+          maxAgeMs !== undefined && Date.now() - existing.updatedAt > maxAgeMs
+
+        if (!tooOld) {
+          // 1) Try to reconnect to the still-running sandbox.
+          const resumed = await config.provider.resume({
+            id: existing.providerSandboxId,
+            signal: ctx.signal,
+          })
+          if (resumed) {
+            await store.upsert({
+              ...existing,
+              latestRunId: ctx.runId,
+              updatedAt: Date.now(),
+            })
+            return resumed
+          }
+          // 2) Else restore from the latest snapshot, if supported.
+          if (
+            existing.latestSnapshotId &&
+            caps.snapshots &&
+            config.provider.restoreSnapshot
+          ) {
+            const restored = await config.provider.restoreSnapshot({
+              snapshotId: existing.latestSnapshotId,
+              workspace: config.workspace,
+              policy: config.policy,
+              env:
+                config.workspace?.secrets !== undefined
+                  ? resolveAllSecrets(config.workspace.secrets)
+                  : undefined,
+              signal: ctx.signal,
+            })
+            await store.upsert({
+              ...existing,
+              providerSandboxId: restored.id,
+              latestRunId: ctx.runId,
+              updatedAt: Date.now(),
+            })
+            return restored
+          }
+        }
+        // 3) Else fall through and re-create under the same identity
+        //    (capability-aware degradation for ephemeral-disk providers, or
+        //    snapshotMaxAge TTL exceeded).
+      }
+
+      const created = await config.provider.create({
+        workspace: config.workspace,
+        policy: config.policy,
+        env:
+          config.workspace?.secrets !== undefined
+            ? resolveAllSecrets(config.workspace.secrets)
+            : undefined,
+        signal: ctx.signal,
+      })
+
+      if (config.workspace) {
+        try {
+          await bootstrapWorkspace(created, config.workspace, {
+            signal: ctx.signal,
+          })
+        } catch (error) {
+          // Bootstrap failed after the sandbox was created but before it was
+          // recorded — destroy the orphan so a failed/retried run doesn't leak
+          // a (billed) sandbox, then surface the original error.
+          await created.destroy().catch(() => {})
+          throw error
+        }
+      }
+
+      let latestSnapshotId: string | undefined
+      if (
+        effectiveSnapshot === 'after-setup' &&
+        caps.snapshots &&
+        created.snapshot
+      ) {
+        latestSnapshotId = (await created.snapshot('after-setup')).id
+      }
+
+      await store.upsert({
+        key,
+        provider: config.provider.name,
+        providerSandboxId: created.id,
+        latestSnapshotId,
+        threadId: ctx.threadId,
+        latestRunId: ctx.runId,
+        updatedAt: Date.now(),
+      })
+      return created
+    })
+  }
+
+  const destroy = async (ctx: SandboxEnsureContext): Promise<void> => {
+    const store = ctx.store ?? fallbackStore
+    const key = computeSandboxKey(keyInputFor(ctx))
+    const existing = await store.get(key)
+    if (!existing) return
+    await config.provider.destroy({
+      id: existing.providerSandboxId,
+      signal: ctx.signal,
+    })
+    await store.delete(key)
+  }
+
+  return {
+    id: config.id,
+    provider: config.provider,
+    workspace: config.workspace,
+    policy: config.policy,
+    lifecycle: config.lifecycle,
+    hooks: config.hooks,
+    fileEvents: config.fileEvents,
+    key: (ctx) => computeSandboxKey(keyInputFor(ctx)),
+    ensure,
+    destroy,
+  }
+}

package/src/secrets.ts

@@ -0,0 +1,101 @@
+/**
+ * Type-safe secret references for sandbox workspace definitions.
+ *
+ * Values are stored in a Map under a non-enumerable symbol key on the returned
+ * object so that `Object.keys(secrets)` only yields the ref names, never the
+ * registry or the underlying plaintext values.
+ */
+
+/** A reference to a named secret — carries only the name, never the value. */
+export type SecretRef = { readonly __secretName: string }
+
+/**
+ * A map of named SecretRef properties. The underlying value registry is stored
+ * under a non-enumerable symbol so iterating the object never exposes it.
+ */
+export type Secrets<TKeys extends string = string> = {
+  readonly [P in TKeys]: SecretRef
+}
+
+/** Internal symbol used to store the value registry on a Secrets object. */
+const REGISTRY = Symbol('secrets.registry')
+
+/** Create a typed secrets object from a plain record of name→value pairs. */
+export function createSecrets<T extends Record<string, string>>(
+  values: T,
+): Secrets<keyof T & string> {
+  const registry = new Map<string, string>(Object.entries(values))
+  const obj = {} as Record<string, SecretRef>
+
+  for (const name of Object.keys(values)) {
+    obj[name] = Object.freeze({ __secretName: name })
+  }
+
+  Object.defineProperty(obj, REGISTRY, {
+    value: registry,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  })
+
+  return obj as Secrets<keyof T & string>
+}
+
+/** Marker type for a bearer-token value derived from a SecretRef. */
+export type BearerRef = { readonly __bearerRef: SecretRef }
+
+/** Create a bearer-token marker that resolves to `Bearer <value>` at runtime. */
+export function bearer(ref: SecretRef): BearerRef {
+  return Object.freeze({ __bearerRef: ref })
+}
+
+/** Return true when `x` is a SecretRef. */
+export function isSecretRef(x: unknown): x is SecretRef {
+  return (
+    typeof x === 'object' &&
+    x !== null &&
+    typeof (x as Record<string, unknown>)['__secretName'] === 'string'
+  )
+}
+
+/** Resolve a SecretRef to its plaintext value using the secrets object. */
+export function resolveSecret(secrets: Secrets, ref: SecretRef): string {
+  const registry = Reflect.get(secrets, REGISTRY) as
+    | Map<string, string>
+    | undefined
+  if (registry === undefined) {
+    throw new Error(
+      'resolveSecret: secrets object was not created by createSecrets',
+    )
+  }
+  const value = registry.get(ref.__secretName)
+  if (value === undefined) {
+    throw new Error(`resolveSecret: unknown secret "${ref.__secretName}"`)
+  }
+  return value
+}
+
+/** Resolve a BearerRef to a `Bearer <value>` string. */
+export function resolveBearer(secrets: Secrets, ref: BearerRef): string {
+  return `Bearer ${resolveSecret(secrets, ref.__bearerRef)}`
+}
+
+/**
+ * Resolve all secrets in a Secrets object to a plain `Record<string, string>`
+ * suitable for injecting into a process environment.
+ */
+export function resolveAllSecrets(secrets: Secrets): Record<string, string> {
+  const registry = Reflect.get(secrets, REGISTRY) as
+    | Map<string, string>
+    | undefined
+  if (registry === undefined) {
+    throw new Error(
+      'resolveAllSecrets: secrets object was not created by createSecrets',
+    )
+  }
+  const result: Record<string, string> = {}
+  for (const [key, value] of registry.entries()) {
+    result[key] = value
+  }
+  return result
+}

package/src/setup-plan.ts

@@ -0,0 +1,25 @@
+export type SetupGroup =
+  | { kind: 'serial'; command: string }
+  | { kind: 'parallel'; commands: Array<string> }
+
+export interface SetupBuilder {
+  serial: (command: string) => void
+  parallel: (commands: Array<string>) => void
+}
+
+export type SetupInput = Array<string> | ((builder: SetupBuilder) => void)
+
+export function buildSetupPlan(
+  input: SetupInput | undefined,
+): Array<SetupGroup> {
+  if (input === undefined) return []
+  if (Array.isArray(input)) {
+    return input.map((command) => ({ kind: 'serial', command }))
+  }
+  const groups: Array<SetupGroup> = []
+  input({
+    serial: (command) => groups.push({ kind: 'serial', command }),
+    parallel: (commands) => groups.push({ kind: 'parallel', commands }),
+  })
+  return groups
+}

package/src/shell.ts

@@ -0,0 +1,288 @@
+/**
+ * Internal persistent bootstrap shell.
+ *
+ * Spawns a single `sh` process via {@link SandboxHandle.process.spawn} and
+ * drives it over stdin/stdout with a sentinel-echo protocol. Commands run
+ * sequentially inside the same shell so `cd`, exported variables, etc. persist
+ * across calls — exactly the exec model the bootstrap setup plan needs.
+ *
+ * Providers WITHOUT a writable host→process stdin (`capabilities.writableStdin
+ * === false`, e.g. Cloudflare / Daytona / Vercel) can't be driven over stdin, so
+ * {@link createBootstrapShell} transparently falls back to an exec-backed shell
+ * ({@link createExecBootstrapShell}) that threads `cwd`/env across `exec` calls
+ * to reproduce the same persistent-shell semantics.
+ *
+ * This module is internal-only and must NOT be re-exported from
+ * `packages/ai-sandbox/src/index.ts`.
+ */
+import type { SandboxHandle } from './contracts'
+
+/**
+ * Parse the output of `export -p` (or `declare -x`) into a plain env map.
+ * Shared by the stdin shell's `forkState` and the exec-backed shell.
+ */
+function parseExports(output: string): Record<string, string> {
+  const env: Record<string, string> = {}
+  for (const line of output.split('\n')) {
+    const trimmed = line.trim()
+    // Match `declare -x KEY=...` or `export KEY=...` forms.
+    const match =
+      /^(?:declare\s+-x\s+|export\s+)([A-Za-z_][A-Za-z0-9_]*)(?:="((?:[^"\\]|\\.)*)")?$/.exec(
+        trimmed,
+      )
+    if (match === null) continue
+    const key = match[1]
+    if (key === undefined) continue
+    // Value may be absent for exported-but-unset vars; skip those.
+    const raw = match[2]
+    if (raw === undefined) continue
+    // Unescape backslash-escaped chars inside double quotes.
+    env[key] = raw.replace(/\\(.)/g, '$1')
+  }
+  return env
+}
+
+/** The surface the bootstrap engine uses. */
+export interface BootstrapShell {
+  /** Run a shell command and capture its stdout + exit code. */
+  run: (command: string) => Promise<{ exitCode: number; stdout: string }>
+  /**
+   * Snapshot the shell's current working directory and exported environment.
+   * Used to fork parallel exec calls that inherit the serial shell's state.
+   */
+  forkState: () => Promise<{ cwd: string; env: Record<string, string> }>
+  /** End the shell session (closes stdin, kills the process). */
+  dispose: () => Promise<void>
+}
+
+/** Options for {@link createBootstrapShell}. */
+export interface BootstrapShellOptions {
+  /** Working directory to start the shell in (passed as ProcessOptions.cwd). */
+  cwd?: string
+}
+
+/**
+ * Spawn one `sh` process and return a {@link BootstrapShell} that drives it
+ * via the sentinel-echo protocol.
+ *
+ * Protocol: for each `run(cmd)` call, we write
+ *   `<cmd>; printf "\n__BSSH_<N>__ $?\n"` to stdin, then read stdout lines
+ * until we see a line matching `__BSSH_<N>__ <exitCode>`. Everything before
+ * that line is the command's stdout; the trailing integer is the exit code.
+ * The counter `N` is a module-level monotonic integer — no Date.now / random.
+ */
+export async function createBootstrapShell(
+  handle: SandboxHandle,
+  opts: BootstrapShellOptions = {},
+): Promise<BootstrapShell> {
+  // Providers without a writable host→process stdin can't run the sentinel-echo
+  // protocol below (it feeds commands over stdin), so use the exec-backed shell.
+  if (!handle.capabilities.writableStdin) {
+    return createExecBootstrapShell(handle, opts)
+  }
+  const proc = await handle.process.spawn('sh', { cwd: opts.cwd })
+
+  /*
+   * We need to read stdout lines across multiple run() calls while keeping
+   * the iterator open. Buffer chunks into lines manually.
+   */
+  const lineBuffer: Array<string> = []
+  let pending: Array<(line: string) => void> = []
+  let streamDone = false
+
+  /** Feed the stdout async-iterable into the shared line queue. */
+  async function drainStdout(): Promise<void> {
+    let partial = ''
+    for await (const chunk of proc.stdout) {
+      partial += chunk
+      const parts = partial.split('\n')
+      // All but the last element are complete lines.
+      for (let i = 0; i < parts.length - 1; i++) {
+        const line = parts[i] as string
+        const resolver = pending.shift()
+        if (resolver !== undefined) {
+          resolver(line)
+        } else {
+          lineBuffer.push(line)
+        }
+      }
+      partial = parts[parts.length - 1] as string
+    }
+    // Flush any trailing partial line.
+    if (partial.length > 0) {
+      const line = partial
+      const resolver = pending.shift()
+      if (resolver !== undefined) {
+        resolver(line)
+      } else {
+        lineBuffer.push(line)
+      }
+    }
+    streamDone = true
+    // Resolve any remaining waiters with an empty sentinel so they unblock.
+    for (const resolver of pending) {
+      resolver('')
+    }
+    pending = []
+  }
+
+  // Start draining immediately; do NOT await — runs concurrently.
+  const drainPromise = drainStdout()
+
+  /** Read the next line from the shared queue. */
+  function nextLine(): Promise<string> {
+    const buffered = lineBuffer.shift()
+    if (buffered !== undefined) {
+      return Promise.resolve(buffered)
+    }
+    if (streamDone) {
+      return Promise.resolve('')
+    }
+    return new Promise<string>((resolve) => {
+      pending.push(resolve)
+    })
+  }
+
+  let counter = 0
+
+  async function run(
+    command: string,
+  ): Promise<{ exitCode: number; stdout: string }> {
+    const id = counter
+    counter += 1
+    const sentinel = `__BSSH_${id}__`
+
+    // Write the command followed by a sentinel printf to stdin. Merge the
+    // command's stderr into stdout (`{ … ; } 2>&1`) so a failing setup step's
+    // error text is captured and can be surfaced — otherwise only the exit code
+    // is visible. `$?` after the group is still the command's own exit code.
+    await proc.stdin.write(
+      `{ ${command} ; } 2>&1; printf "\\n${sentinel} $?\\n"\n`,
+    )
+
+    const outputLines: Array<string> = []
+
+    // Read lines until we find the sentinel.
+    for (;;) {
+      const line = await nextLine()
+      if (line.startsWith(`${sentinel} `)) {
+        const codeStr = line.slice(sentinel.length + 1).trim()
+        const exitCode = parseInt(codeStr, 10)
+        return {
+          exitCode: Number.isFinite(exitCode) ? exitCode : 1,
+          stdout: outputLines.join('\n'),
+        }
+      }
+      outputLines.push(line)
+    }
+  }
+
+  async function forkState(): Promise<{
+    cwd: string
+    env: Record<string, string>
+  }> {
+    const pwdResult = await run('pwd')
+    const cwd = pwdResult.stdout.trim()
+
+    const exportResult = await run('export -p')
+    return { cwd, env: parseExports(exportResult.stdout) }
+  }
+
+  async function dispose(): Promise<void> {
+    await proc.stdin.end()
+    await proc.kill()
+    // Drain the stdout iterator to completion so there are no dangling promises.
+    await drainPromise
+  }
+
+  return { run, forkState, dispose }
+}
+
+/**
+ * Exec-backed {@link BootstrapShell} for providers WITHOUT a writable stdin.
+ *
+ * There is no persistent process to feed commands into, so persistence of `cd`
+ * and exported variables is reproduced by threading state across discrete
+ * {@link SandboxHandle.process.exec} calls: each `run()` executes the command in
+ * the tracked cwd+env, then captures the resulting `pwd` and `export -p` (via
+ * marker lines) so the NEXT command inherits any directory change or exports.
+ */
+export function createExecBootstrapShell(
+  handle: SandboxHandle,
+  opts: BootstrapShellOptions = {},
+): BootstrapShell {
+  let cwd = opts.cwd ?? '/'
+  let env: Record<string, string> = {}
+  let counter = 0
+
+  async function run(
+    command: string,
+  ): Promise<{ exitCode: number; stdout: string }> {
+    const id = counter
+    counter += 1
+    const sentinel = `__BSSH_${id}__`
+
+    // Run the command, then emit its exit code, cwd and exported env behind
+    // marker lines so we can recover state even when the command itself fails
+    // (no `set -e`). Capturing `$?` immediately after the command keeps the
+    // reported exit code the command's own, not the trailing introspection's.
+    const script = [
+      command,
+      `__bssh_rc=$?`,
+      `printf '\\n%s %s\\n' '${sentinel}' "$__bssh_rc"`,
+      `printf '%s\\n' '${sentinel}_CWD'`,
+      `pwd`,
+      `printf '%s\\n' '${sentinel}_ENV'`,
+      `export -p`,
+    ].join('\n')
+
+    const res = await handle.process.exec(script, { cwd, env })
+
+    const cmdOut: Array<string> = []
+    const cwdLines: Array<string> = []
+    const envLines: Array<string> = []
+    let exitCode = res.exitCode
+    let phase: 'cmd' | 'await-cwd' | 'cwd' | 'env' = 'cmd'
+
+    for (const line of res.stdout.split('\n')) {
+      if (phase === 'cmd') {
+        if (line.startsWith(`${sentinel} `)) {
+          const parsed = parseInt(line.slice(sentinel.length + 1).trim(), 10)
+          exitCode = Number.isFinite(parsed) ? parsed : res.exitCode
+          phase = 'await-cwd'
+          continue
+        }
+        cmdOut.push(line)
+      } else if (phase === 'await-cwd') {
+        if (line === `${sentinel}_CWD`) phase = 'cwd'
+      } else if (phase === 'cwd') {
+        if (line === `${sentinel}_ENV`) phase = 'env'
+        else cwdLines.push(line)
+      } else {
+        envLines.push(line)
+      }
+    }
+
+    // `pwd` prints a single line; the last non-empty one is the new cwd.
+    const newCwd = cwdLines
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .pop()
+    if (newCwd) cwd = newCwd
+    const newEnv = parseExports(envLines.join('\n'))
+    if (Object.keys(newEnv).length > 0) env = newEnv
+
+    return { exitCode, stdout: cmdOut.join('\n') }
+  }
+
+  function forkState(): Promise<{ cwd: string; env: Record<string, string> }> {
+    return Promise.resolve({ cwd, env: { ...env } })
+  }
+
+  function dispose(): Promise<void> {
+    // Nothing to tear down — there is no persistent process.
+    return Promise.resolve()
+  }
+
+  return { run, forkState, dispose }
+}