dsh-ptc-plus 0.4.2 → 0.4.3

package/internal/value-wire.js

@@ -16,7 +16,7 @@ export { VALUE_CODEC, DEFAULT_VALUE_LIMITS } from './value-wire-schema.js'
 const { Object, Reflect, Array, Map, Set, WeakMap, WeakSet, TypeError,
   isArray, numberIsFinite, numberIsNaN, numberIsSafeInteger, toBigInt,
   toNumber, toString, regexpTest, mapGet, mapHas, mapSet, setHas, setAdd,
-  setDelete, setSize, weakMapGet, weakMapSet, weakSetHas, weakSetAdd,
+  setDelete, weakMapGet, weakMapSet, weakSetHas, weakSetAdd,
   appendArray, popArray, join } = internal
 const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/
 const intrinsicFunctionToString = Function.prototype.toString
@@ -81,6 +81,7 @@ export function encodeValue(value, options = {}) {
   const pending = []
   const nodes = []
   let edgeCount = 0
+  let arraySlotCount = 0
   let textBytes = 0
 
   const accountText = (text, path) => {
@@ -127,6 +128,10 @@ export function encodeValue(value, options = {}) {
     if (isArray(current)) {
       if (!hasPlainArrayPrototype(current)) invalid(item.path, 'non-plain array')
       if (current.length > limits.maxArrayLength) invalid(item.path, `array length exceeds ${limits.maxArrayLength}`)
+      arraySlotCount += current.length
+      if (arraySlotCount > limits.maxArrayLength) {
+        invalid(item.path, `array slot budget exceeds ${limits.maxArrayLength}`)
+      }
       const entries = []
       const keys = Reflect.ownKeys(current)
       for (let keyIndex = 0; keyIndex < keys.length; keyIndex += 1) {
@@ -170,7 +175,7 @@ export function encodeValue(value, options = {}) {
   return { codec: VALUE_CODEC, root, nodes }
 }
 
-function decodeAtom(atom, nodes, limits, budget, path) {
+function validateAtom(atom, nodeCount, limits, budget, path) {
   if (atom === null || typeof atom === 'boolean') return atom
   if (typeof atom === 'string') {
     budget.textBytes += stringBytes(atom)
@@ -184,14 +189,14 @@ function decodeAtom(atom, nodes, limits, budget, path) {
   if (!isRecord(atom) || typeof atom.tag !== 'string') throw new TypeError(`invalid PTC value atom at ${path}`)
   if (atom.tag === 'undefined') {
     assertFields(atom, UNDEFINED_FIELDS, 'PTC undefined atom')
-    return undefined
+    return { tag: 'undefined' }
   }
   if (atom.tag === 'number') {
     assertFields(atom, NUMBER_FIELDS, 'PTC number atom')
-    if (atom.value === 'nan') return NaN
-    if (atom.value === 'infinity') return Infinity
-    if (atom.value === '-infinity') return -Infinity
-    if (atom.value === '-0') return -0
+    if (atom.value === 'nan' || atom.value === 'infinity'
+      || atom.value === '-infinity' || atom.value === '-0') {
+      return { tag: 'number', value: atom.value }
+    }
     throw new TypeError('invalid PTC special number')
   }
   if (atom.tag === 'bigint') {
@@ -203,52 +208,66 @@ function decodeAtom(atom, nodes, limits, budget, path) {
     if (digits > limits.maxBigIntDigits) throw new TypeError('PTC BigInt digit budget exceeded')
     budget.textBytes += stringBytes(atom.value)
     if (budget.textBytes > limits.maxStringBytes) throw new TypeError('PTC value string budget exceeded')
-    return toBigInt(atom.value)
+    return { tag: 'bigint', value: atom.value }
   }
   if (atom.tag === 'reference') {
     assertFields(atom, REFERENCE_FIELDS, 'PTC reference atom')
-    if (!numberIsSafeInteger(atom.index) || atom.index < 0 || atom.index >= nodes.length) {
+    if (!numberIsSafeInteger(atom.index) || atom.index < 0 || atom.index >= nodeCount) {
       throw new TypeError('dangling PTC value reference')
     }
-    setAdd(budget.reachable, atom.index)
-    return nodes[atom.index]
+    if (atom.index >= budget.nextReference) {
+      if (atom.index !== budget.nextReference) throw new TypeError('non-canonical PTC value envelope')
+      budget.nextReference += 1
+    }
+    return { tag: 'reference', index: atom.index }
   }
   throw new TypeError(`unknown PTC value atom tag ${jsonStringify(atom.tag)}`)
 }
 
-/** Validate, hydrate, and own one canonical PTC value envelope without recursive stack growth. */
-function decodeCanonicalValue(wire, options = {}) {
-  const limits = limitsOf(options)
+function canonicalArrayIndex(key) {
+  if (!regexpTest(/^(0|[1-9][0-9]*)$/, key)) return undefined
+  const index = toNumber(key)
+  return numberIsSafeInteger(index) && index < 0xffffffff && toString(index) === key ? index : undefined
+}
+
+const MAX_ARRAY_LENGTH = 0xffffffff
+
+/** Validate and detach the complete envelope before allocating hydrated arrays. */
+function validateCanonicalWire(wire, limits) {
   assertFields(wire, ENVELOPE_FIELDS, 'PTC value envelope')
   if (wire.codec !== VALUE_CODEC || !isArray(wire.nodes)) throw new TypeError('invalid PTC value codec')
   if (wire.nodes.length > limits.maxNodes) throw new TypeError('PTC value node budget exceeded')
-  const targets = new Array(wire.nodes.length)
+  const nodes = new Array(wire.nodes.length)
+  let arraySlots = 0
   for (let index = 0; index < wire.nodes.length; index += 1) {
     const node = wire.nodes[index]
     if (!isRecord(node)) throw new TypeError(`invalid PTC value node ${index}`)
     if (node.type === 'array') {
       assertFields(node, ARRAY_NODE_FIELDS, `PTC array node ${index}`)
-      if (!numberIsSafeInteger(node.length) || node.length < 0 || node.length > limits.maxArrayLength) {
+      if (!numberIsSafeInteger(node.length) || node.length < 0
+        || node.length > MAX_ARRAY_LENGTH || node.length > limits.maxArrayLength) {
         throw new TypeError(`invalid PTC array length at node ${index}`)
       }
       if (!isArray(node.entries)) throw new TypeError(`invalid PTC array entries at node ${index}`)
-      targets[index] = new Array(node.length)
+      arraySlots += node.length
+      if (arraySlots > limits.maxArrayLength) throw new TypeError('PTC value array slot budget exceeded')
+      nodes[index] = { type: 'array', length: node.length, entries: node.entries }
     } else if (node.type === 'object') {
       assertFields(node, OBJECT_NODE_FIELDS, `PTC object node ${index}`)
       if ((node.prototype !== 'object' && node.prototype !== 'null') || !isArray(node.entries)) {
         throw new TypeError(`invalid PTC object node ${index}`)
       }
-      targets[index] = node.prototype === 'null' ? Object.create(null) : {}
+      nodes[index] = { type: 'object', prototype: node.prototype, entries: node.entries }
     } else {
       throw new TypeError(`unknown PTC value node type at ${index}`)
     }
   }
 
-  const budget = { edges: 0, textBytes: 0, reachable: new Set() }
-  const root = decodeAtom(wire.root, targets, limits, budget, '$')
-  for (let nodeIndex = 0; nodeIndex < wire.nodes.length; nodeIndex += 1) {
-    const node = wire.nodes[nodeIndex]
-    const target = targets[nodeIndex]
+  const budget = { edges: 0, textBytes: 0, nextReference: 0 }
+  const root = validateAtom(wire.root, nodes.length, limits, budget, '$')
+  for (let nodeIndex = 0; nodeIndex < budget.nextReference; nodeIndex += 1) {
+    const node = nodes[nodeIndex]
+    const entries = []
     if (node.type === 'array') {
       let previous = -1
       for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
@@ -260,34 +279,80 @@ function decodeCanonicalValue(wire, options = {}) {
         previous = entry[0]
         budget.edges += 1
         if (budget.edges > limits.maxEdges) throw new TypeError('PTC value edge budget exceeded')
-        Object.defineProperty(target, entry[0], {
-          value: decodeAtom(entry[1], targets, limits, budget, `$nodes[${nodeIndex}][${entry[0]}]`),
-          enumerable: true, configurable: true, writable: true,
-        })
+        appendArray(entries, [entry[0], validateAtom(entry[1], nodes.length, limits, budget,
+          `$nodes[${nodeIndex}][${entry[0]}]`)])
       }
+      nodes[nodeIndex] = { type: 'array', length: node.length, entries }
       continue
     }
     const keys = new Set()
+    let previousIndex = -1
+    let ordinaryKeySeen = false
     for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
       const entry = node.entries[entryIndex]
       if (!isArray(entry) || entry.length !== 2 || typeof entry[0] !== 'string' || setHas(keys, entry[0])) {
         throw new TypeError(`invalid PTC object entry at node ${nodeIndex}`)
       }
+      const index = canonicalArrayIndex(entry[0])
+      if (index === undefined) ordinaryKeySeen = true
+      else if (ordinaryKeySeen || index <= previousIndex) {
+        throw new TypeError('non-canonical PTC value envelope')
+      } else previousIndex = index
       setAdd(keys, entry[0])
       budget.textBytes += stringBytes(entry[0])
       if (budget.textBytes > limits.maxStringBytes) throw new TypeError('PTC value string budget exceeded')
       budget.edges += 1
       if (budget.edges > limits.maxEdges) throw new TypeError('PTC value edge budget exceeded')
+      appendArray(entries, [entry[0], validateAtom(entry[1], nodes.length, limits, budget,
+        `$nodes[${nodeIndex}].${entry[0]}`)])
+    }
+    nodes[nodeIndex] = { type: 'object', prototype: node.prototype, entries }
+  }
+  if (budget.nextReference !== nodes.length) throw new TypeError('PTC value envelope contains unreachable nodes')
+  const normalized = { codec: VALUE_CODEC, root, nodes }
+  const serialization = jsonStringify(normalized)
+  if (serialization !== jsonStringify(wire)) throw new TypeError('non-canonical PTC value envelope')
+  return { wire: normalized, serialization }
+}
+
+function hydrateAtom(atom, nodes) {
+  if (atom === null || typeof atom === 'boolean' || typeof atom === 'string' || typeof atom === 'number') return atom
+  if (atom.tag === 'undefined') return undefined
+  if (atom.tag === 'number') {
+    if (atom.value === 'nan') return NaN
+    if (atom.value === 'infinity') return Infinity
+    if (atom.value === '-infinity') return -Infinity
+    return -0
+  }
+  if (atom.tag === 'bigint') return toBigInt(atom.value)
+  return nodes[atom.index]
+}
+
+/** Validate, hydrate, and own one canonical PTC value envelope without recursive stack growth. */
+function decodeCanonicalValue(wire, options = {}) {
+  const limits = limitsOf(options)
+  const validated = validateCanonicalWire(wire, limits)
+  const targets = new Array(validated.wire.nodes.length)
+  for (let index = 0; index < validated.wire.nodes.length; index += 1) {
+    const node = validated.wire.nodes[index]
+    targets[index] = node.type === 'array' ? new Array(node.length)
+      : node.prototype === 'null' ? Object.create(null) : {}
+  }
+  const root = hydrateAtom(validated.wire.root, targets)
+  for (let nodeIndex = 0; nodeIndex < validated.wire.nodes.length; nodeIndex += 1) {
+    const node = validated.wire.nodes[nodeIndex]
+    const target = targets[nodeIndex]
+    for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
+      const entry = node.entries[entryIndex]
       Object.defineProperty(target, entry[0], {
-        value: decodeAtom(entry[1], targets, limits, budget, `$nodes[${nodeIndex}].${entry[0]}`),
+        value: hydrateAtom(entry[1], targets),
         enumerable: true, configurable: true, writable: true,
       })
     }
   }
-  if (setSize(budget.reachable) !== wire.nodes.length) throw new TypeError('PTC value envelope contains unreachable nodes')
   const canonical = encodeValue(root, limits)
   const serialization = jsonStringify(canonical)
-  if (serialization !== jsonStringify(wire)) throw new TypeError('non-canonical PTC value envelope')
+  if (serialization !== validated.serialization) throw new TypeError('non-canonical PTC value envelope')
   return { value: root, wire: canonical, serialization }
 }
 

package/internal/worker-client.js

@@ -1,9 +1,12 @@
 import { mkdtemp, rm } from 'node:fs/promises'
+import { randomBytes } from 'node:crypto'
 import { tmpdir } from 'node:os'
 import { isAbsolute, join } from 'node:path'
 import { messageOf, processExitDescription } from './failure-reporting.js'
 import { IsolatedOwner } from './isolated-worker.js'
 import { normalizeWorkerEnvironment } from './worker-environment.js'
+import { WorkerOutputCapture } from './worker-output-capture.js'
+import { stripOutputFenceMarkers } from './worker-output-fence.js'
 
 export { normalizeWorkerEnvironment }
 
@@ -11,16 +14,21 @@ const KERNEL_HELPER = new URL('./kernel-child.js', import.meta.url)
 
 /** Owns one session kernel's worker process, private port, and scratch directory. */
 export class WorkerClient {
-  constructor({ workerUrl, cwd, onMessage, onFailure, compilerCache }) {
+  constructor({ workerUrl, cwd, onMessage, onFailure, onUnmatchedOutputFailure, compilerCache }) {
     this.workerUrl = workerUrl
     this.cwd = cwd
     this.onMessage = onMessage
     this.onFailure = onFailure
+    this.onUnmatchedOutputFailure = onUnmatchedOutputFailure ?? (() => false)
     this.compilerCache = compilerCache
     this.worker = undefined
     this.workerLimit = undefined
     this.workerReady = undefined
     this.port = undefined
+    this.outputCapture = undefined
+    this.outputCompletionPending = undefined
+    this.deferredOutputMessages = []
+    this.pendingOutputFailure = undefined
     this.scratchReady = undefined
     this.stderrTails = new WeakMap()
     // One owner keeps every started kernel transport, including startup failures
@@ -32,13 +40,18 @@ export class WorkerClient {
 
   /** Last non-empty stderr line of a failed worker, capped for diagnostics. */
   stderrDetail(worker) {
-    const tail = this.stderrTails.get(worker)?.join('').trim()
+    const tail = stripOutputFenceMarkers(this.stderrTails.get(worker)?.join('')).trim()
     if (tail === undefined || tail.length === 0) return undefined
     const lastLine = tail.split(/\r?\n/).map(line => line.trim()).filter(line => line.length > 0).slice(-1)[0]
     return lastLine === undefined ? undefined : lastLine.slice(0, 300)
   }
 
   async ensure(maxOldGenerationSizeMb) {
+    if (this.pendingOutputFailure !== undefined) {
+      const message = this.pendingOutputFailure
+      this.pendingOutputFailure = undefined
+      throw new Error(`worker output attribution failed: ${message}`)
+    }
     if (this.workerLimit !== undefined && this.workerLimit !== maxOldGenerationSizeMb) {
       throw new Error('ptc-plus: session worker memory limit differs from the submitted cell configuration')
     }
@@ -86,15 +99,21 @@ export class WorkerClient {
       this.workerLimit = undefined
       throw error
     }
-    worker.stdout.resume()
-    worker.stderr.resume()
+    const outputCapture = new WorkerOutputCapture()
+    this.outputCapture = outputCapture
     const stderrTail = []
+    worker.stdout.on?.('data', chunk => {
+      this.handleCapturedOutput(worker, outputCapture.push('stdout', chunk))
+    })
     worker.stderr.on?.('data', (chunk) => {
       const text = typeof chunk === 'string' ? chunk : String(chunk ?? '')
       stderrTail.push(text)
       const bounded = Buffer.from(stderrTail.join('')).subarray(-2048).toString('utf8')
       stderrTail.splice(0, stderrTail.length, bounded)
+      this.handleCapturedOutput(worker, outputCapture.push('stderr', chunk))
     })
+    worker.stdout.resume()
+    worker.stderr.resume()
     this.stderrTails.set(worker, stderrTail)
     worker.on('error', error => this.fail(worker, `worker error: ${messageOf(error)}`))
     worker.on('exit', (code, signal) => {
@@ -135,9 +154,7 @@ export class WorkerClient {
           return
         }
         this.port = message.port
-        this.port.on('message', (value) => {
-          if (worker === this.worker) this.onMessage(value)
-        })
+        this.port.on('message', value => this.handleWorkerMessage(worker, outputCapture, value))
         resolve(worker)
       })
     })
@@ -145,7 +162,17 @@ export class WorkerClient {
   }
 
   post(message) {
-    this.port.postMessage(message)
+    if (message?.type !== 'run') {
+      this.port.postMessage(message)
+      return
+    }
+    const outputFence = randomBytes(24).toString('hex')
+    const failure = this.outputCapture?.begin(message.id, message.maxOutputBytes, outputFence)
+    if (failure !== undefined) {
+      this.handleCapturedOutput(this.worker, failure)
+      return
+    }
+    this.port.postMessage({ ...message, outputFence })
   }
 
   /** Best-effort reply for a request whose lease may outlive a worker reset. */
@@ -153,11 +180,68 @@ export class WorkerClient {
     this.port?.postMessage(message)
   }
 
+  handleWorkerMessage(worker, outputCapture, value) {
+    if (worker !== this.worker) return
+    const outputProtocol = value?.type === 'output-start'
+      || value?.type === 'late-output'
+      || value?.type === 'done'
+    if (this.outputCompletionPending !== undefined && !outputProtocol) {
+      this.deferredOutputMessages.push(value)
+      return
+    }
+    const captured = value?.type === 'output-start'
+      ? outputCapture.start(value)
+      : value?.type === 'late-output'
+        ? outputCapture.lateOutput()
+        : value?.type === 'done'
+          ? outputCapture.complete(value)
+          : value
+    if (value?.type === 'done' && captured === undefined) {
+      this.outputCompletionPending = value.id
+      return
+    }
+    this.handleCapturedOutput(worker, captured)
+  }
+
+  handleCapturedOutput(worker, message) {
+    if (message === undefined || worker !== this.worker) return
+    if (message.type === 'worker-output-started') {
+      this.port?.postMessage({
+        type: 'output-start-ack',
+        id: message.id,
+        outputFence: message.outputFence,
+      })
+      return
+    }
+    const releasesDeferred = message.type === 'done' && message.id === this.outputCompletionPending
+    const discardsDeferred = message.id === this.outputCompletionPending
+      && (message.type === 'worker-output-error' || message.type === 'output-limit')
+    if (releasesDeferred || discardsDeferred) this.outputCompletionPending = undefined
+    const consumed = this.onMessage(message) === true
+    if (message.type === 'worker-output-error' && worker === this.worker) {
+      const failureConsumed = consumed || this.onUnmatchedOutputFailure(
+        `worker output attribution failed: ${message.message}`,
+      ) === true
+      if (!failureConsumed) this.pendingOutputFailure = message.message
+      void this.reset(worker).catch(error => this.onFailure(`worker output reset failed: ${messageOf(error)}`))
+      return
+    }
+    if (releasesDeferred) {
+      const deferred = this.deferredOutputMessages
+      this.deferredOutputMessages = []
+      for (const value of deferred) this.onMessage(value)
+    } else if (discardsDeferred) this.deferredOutputMessages = []
+  }
+
   fail(worker, message) {
     if (worker !== this.worker) return
     this.worker = undefined
     this.workerLimit = undefined
     this.workerReady = undefined
+    this.outputCapture = undefined
+    this.outputCompletionPending = undefined
+    this.deferredOutputMessages = []
+    this.pendingOutputFailure = undefined
     this.port?.close()
     this.port = undefined
     const detail = this.stderrDetail(worker)
@@ -170,6 +254,9 @@ export class WorkerClient {
       this.worker = undefined
       this.workerLimit = undefined
       this.workerReady = undefined
+      this.outputCapture = undefined
+      this.outputCompletionPending = undefined
+      this.deferredOutputMessages = []
       this.port = undefined
     }
     await this.owner.stop(this.hostIds.get(worker))
@@ -184,6 +271,10 @@ export class WorkerClient {
     this.worker = undefined
     this.workerLimit = undefined
     this.workerReady = undefined
+    this.outputCapture = undefined
+    this.outputCompletionPending = undefined
+    this.deferredOutputMessages = []
+    this.pendingOutputFailure = undefined
     this.port = undefined
     if (worker !== undefined) this.hostIds.delete(worker)
     const failures = []

package/internal/worker-cwd-virtualization.js

@@ -1,6 +1,11 @@
 import { isAbsolute, parse, resolve, sep } from 'node:path'
 import { promisify } from 'node:util'
 import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
+import {
+  WORKER_REALM_MUTATION,
+  assignWorkerRealmProperty,
+  installProjectedProcessCwd,
+} from './worker-realm-surfaces.js'
 
 const { Reflect: privateReflect, appendArray, bufferConcat, bufferIsBuffer, bufferToString,
   copyArray, isArray, regexpTest } = internal
@@ -61,7 +66,8 @@ function wrapBuiltinCallable(original, projectArguments, projectedProperties = [
 function wrapBuiltin(owner, name, projectArguments, projectedProperties) {
   const original = owner?.[name]
   if (typeof original !== 'function') return
-  owner[name] = wrapBuiltinCallable(original, projectArguments, projectedProperties)
+  assignWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'cwd-projected Node builtins',
+    owner, name, wrapBuiltinCallable(original, projectArguments, projectedProperties))
 }
 
 export function projectChildProcessArguments(name, args, sessionCwd) {
@@ -106,10 +112,10 @@ export function projectChildProcessArguments(name, args, sessionCwd) {
 export function installWorkerCwdVirtualization(sessionCwd, originalRequire, markVolatile) {
   if (sessionCwd === undefined) {
     const nativeCwd = process.cwd
-    process.cwd = () => {
+    assignWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'process.cwd', process, 'cwd', () => {
       markVolatile('process.cwd')
       return privateReflect.apply(nativeCwd, process, [])
-    }
+    })
     return
   }
   const nativeResolve = resolve
@@ -153,12 +159,7 @@ export function installWorkerCwdVirtualization(sessionCwd, originalRequire, mark
     return next
   }
 
-  Object.defineProperty(process, 'cwd', {
-    configurable: false,
-    enumerable: true,
-    writable: false,
-    value: () => sessionCwd,
-  })
+  installProjectedProcessCwd(process, sessionCwd)
   const fs = originalRequire('node:fs')
   const path = originalRequire('node:path')
   for (const [name, indices] of Object.entries(FILE_SYSTEM_PATH_ARGUMENTS)) {

package/internal/worker-output-capture.js

@@ -0,0 +1,187 @@
+import {
+  OUTPUT_FENCE_ALLOWANCE_BYTES,
+  outputFenceMarker,
+  validOutputFenceToken,
+} from './worker-output-fence.js'
+
+function bytes(value) {
+  return Buffer.isBuffer(value) ? Buffer.from(value) : Buffer.from(String(value ?? ''))
+}
+
+function nonEmptyText(value) {
+  return value.length === 0 ? [] : [value.toString('utf8')]
+}
+
+/** Correlate helper stdout/stderr with one kernel completion using dual fences. */
+export class WorkerOutputCapture {
+  constructor() {
+    this.armed = false
+    this.round = undefined
+    this.settledId = undefined
+  }
+
+  begin(id, maxOutputBytes, outputFence) {
+    this.armed = true
+    if (this.round !== undefined) {
+      return { type: 'worker-output-error', id, message: 'worker output rounds overlapped' }
+    }
+    if (!validOutputFenceToken(outputFence)) {
+      return { type: 'worker-output-error', id, message: 'host created an invalid worker output fence' }
+    }
+    this.round = {
+      id,
+      maxOutputBytes,
+      outputFence,
+      stdout: [],
+      stderr: [],
+      bytes: 0,
+      started: false,
+      startMessage: false,
+      completion: undefined,
+    }
+    return undefined
+  }
+
+  push(channel, chunk) {
+    if (!this.armed) return undefined
+    if (this.round === undefined) {
+      this.armed = false
+      return {
+        type: 'worker-output-error',
+        id: this.settledId,
+        message: 'a settled cell produced descriptor output after its output fence; the worker was reset to stop unattributed output',
+      }
+    }
+    const value = bytes(chunk)
+    this.round[channel].push(value)
+    this.round.bytes += value.length
+    if (this.round.bytes > this.round.maxOutputBytes + OUTPUT_FENCE_ALLOWANCE_BYTES) {
+      const id = this.round.id
+      this.round = undefined
+      return { type: 'output-limit', id, logs: [] }
+    }
+    return this.round.started ? this.#finish() : this.#start()
+  }
+
+  start(message) {
+    if (this.round === undefined || message?.id !== this.round.id) {
+      const id = this.round?.id ?? message?.id
+      this.round = undefined
+      return { type: 'worker-output-error', id, message: 'kernel output start has no matching output round' }
+    }
+    if (message.outputFence !== this.round.outputFence) {
+      const id = this.round.id
+      this.round = undefined
+      return { type: 'worker-output-error', id, message: 'kernel output start has a mismatched output fence' }
+    }
+    if (this.round.startMessage) {
+      const id = this.round.id
+      this.round = undefined
+      return { type: 'worker-output-error', id, message: 'kernel repeated an output start' }
+    }
+    this.round.startMessage = true
+    return this.#start()
+  }
+
+  complete(message) {
+    if (this.round === undefined || message?.id !== this.round.id) {
+      const id = this.round?.id ?? message?.id
+      this.round = undefined
+      return { type: 'worker-output-error', id, message: 'kernel completion has no matching output round' }
+    }
+    if (!this.round.started || message.outputFence !== this.round.outputFence) {
+      const id = this.round.id
+      this.round = undefined
+      return { type: 'worker-output-error', id, message: 'kernel completion has a mismatched output fence' }
+    }
+    if (this.round.completion !== undefined) {
+      const id = this.round.id
+      this.round = undefined
+      return { type: 'worker-output-error', id, message: 'kernel repeated a completion' }
+    }
+    this.round.completion = message
+    return this.#finish()
+  }
+
+  lateOutput() {
+    if (this.round !== undefined) {
+      const id = this.round.id
+      this.round = undefined
+      return {
+        type: 'worker-output-error',
+        id,
+        message: 'a settled cell produced background output during this cell; the worker was reset to prevent cross-cell attribution',
+      }
+    }
+    if (this.armed) {
+      this.armed = false
+      return {
+        type: 'worker-output-error',
+        id: this.settledId,
+        message: 'a settled cell produced background output after its output fence; the worker was reset to prevent cross-cell attribution',
+      }
+    }
+    return undefined
+  }
+
+  #start() {
+    const round = this.round
+    if (round?.startMessage !== true) return undefined
+    const stdout = Buffer.concat(round.stdout)
+    const stderr = Buffer.concat(round.stderr)
+    const stdoutFence = Buffer.from(outputFenceMarker(round.outputFence, 'stdout', 'start'))
+    const stderrFence = Buffer.from(outputFenceMarker(round.outputFence, 'stderr', 'start'))
+    const stdoutAt = stdout.indexOf(stdoutFence)
+    const stderrAt = stderr.indexOf(stderrFence)
+    if (stdoutAt < 0 || stderrAt < 0) return undefined
+    const stdoutAfter = stdout.subarray(stdoutAt + stdoutFence.length)
+    const stderrAfter = stderr.subarray(stderrAt + stderrFence.length)
+    if (stdoutAt > 0 || stderrAt > 0 || stdoutAfter.length > 0 || stderrAfter.length > 0) {
+      const id = round.id
+      this.round = undefined
+      return {
+        type: 'worker-output-error',
+        id,
+        message: 'a settled cell produced descriptor output before the next cell started; the worker was reset to prevent cross-cell attribution',
+      }
+    }
+    round.stdout = []
+    round.stderr = []
+    round.bytes = 0
+    round.started = true
+    return { type: 'worker-output-started', id: round.id, outputFence: round.outputFence }
+  }
+
+  #finish() {
+    const round = this.round
+    if (round?.completion === undefined) return undefined
+    const stdout = Buffer.concat(round.stdout)
+    const stderr = Buffer.concat(round.stderr)
+    const stdoutFence = Buffer.from(outputFenceMarker(round.outputFence, 'stdout', 'end'))
+    const stderrFence = Buffer.from(outputFenceMarker(round.outputFence, 'stderr', 'end'))
+    const stdoutAt = stdout.indexOf(stdoutFence)
+    const stderrAt = stderr.indexOf(stderrFence)
+    if (stdoutAt < 0 || stderrAt < 0) return undefined
+    const stdoutAfter = stdout.subarray(stdoutAt + stdoutFence.length)
+    const stderrAfter = stderr.subarray(stderrAt + stderrFence.length)
+    if (stdoutAfter.length > 0 || stderrAfter.length > 0) {
+      this.round = undefined
+      this.armed = false
+      return {
+        type: 'worker-output-error',
+        id: round.id,
+        message: 'a settled cell produced descriptor output after its output fence; the worker was reset to prevent cross-cell attribution',
+      }
+    }
+    const descriptorLogs = [
+      ...nonEmptyText(stdout.subarray(0, stdoutAt)),
+      ...nonEmptyText(stderr.subarray(0, stderrAt)),
+    ]
+    const rawBytes = descriptorLogs.reduce((total, value) => total + Buffer.byteLength(JSON.stringify(value)), 0)
+    this.round = undefined
+    this.settledId = round.id
+    if (rawBytes > round.maxOutputBytes) return { type: 'output-limit', id: round.id, logs: [] }
+    const logs = Array.isArray(round.completion.logs) ? [...round.completion.logs, ...descriptorLogs] : descriptorLogs
+    return { ...round.completion, logs }
+  }
+}