dsh-ptc-plus 0.4.1 → 0.4.3

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,5 +1,15 @@
 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
+const TRAILING_SEPARATOR = /[\\/]$/
 
 const FILE_SYSTEM_PATH_ARGUMENTS = Object.freeze({
   access: [0], accessSync: [0], appendFile: [0], appendFileSync: [0],
@@ -34,7 +44,7 @@ const CHILD_PROCESS_PROJECTED_PROPERTIES = Object.freeze({
 function wrapBuiltinCallable(original, projectArguments, projectedProperties = []) {
   const wrapped = {
     invoke(...args) {
-      return Reflect.apply(original, this, projectArguments(args))
+      return privateReflect.apply(original, this, projectArguments(args))
     },
   }.invoke
   const descriptors = Object.getOwnPropertyDescriptors(original)
@@ -56,83 +66,100 @@ 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) {
+  const sessionChildOptions = options => (
+    options === null || typeof options !== 'object' || options.cwd !== undefined
+      ? options
+      : { ...options, cwd: sessionCwd }
+  )
+  const withDefaultOptions = (index) => {
+    const next = copyArray(args)
+    next[index] = sessionChildOptions(next[index]) ?? { cwd: sessionCwd }
+    return next
+  }
+  const insertDefaultOptions = (index) => {
+    const next = copyArray(args, 0, index)
+    appendArray(next, { cwd: sessionCwd })
+    return copyArray(args, index, args.length, next)
+  }
+  if (name === 'exec' || name === 'execSync') {
+    const next = copyArray(args)
+    if (typeof next[1] === 'function') return insertDefaultOptions(1)
+    else next[1] = sessionChildOptions(next[1]) ?? { cwd: sessionCwd }
+    return next
+  }
+  if (name === 'execFile' || name === 'execFileSync') {
+    if (args.length === 1 || typeof args[1] === 'function') {
+      return insertDefaultOptions(1)
+    }
+    if (typeof args[2] === 'function') {
+      if (args[1] !== undefined && !isArray(args[1])) return withDefaultOptions(1)
+      return insertDefaultOptions(2)
+    }
+    if (args[1] !== undefined && !isArray(args[1])) return withDefaultOptions(1)
+    return withDefaultOptions(2)
+  }
+  return args.length === 1 || (args[1] !== undefined && !isArray(args[1]))
+    ? withDefaultOptions(1)
+    : withDefaultOptions(2)
 }
 
 /** Install one session's cwd projection into Node builtins loaded by the worker. */
-export function installWorkerCwdVirtualization(sessionCwd, originalRequire) {
-  if (sessionCwd === undefined) return
+export function installWorkerCwdVirtualization(sessionCwd, originalRequire, markVolatile) {
+  if (sessionCwd === undefined) {
+    const nativeCwd = process.cwd
+    assignWorkerRealmProperty(WORKER_REALM_MUTATION.STABLE, 'process.cwd', process, 'cwd', () => {
+      markVolatile('process.cwd')
+      return privateReflect.apply(nativeCwd, process, [])
+    })
+    return
+  }
   const nativeResolve = resolve
-  const bufferPrefix = Buffer.from(sessionCwd + (/[\\/]$/.test(sessionCwd) ? '' : sep))
+  const bufferPrefix = Buffer.from(sessionCwd + (regexpTest(TRAILING_SEPARATOR, sessionCwd) ? '' : sep))
   const sessionPath = (value) => {
     if (typeof value === 'string') return isAbsolute(value) ? value : nativeResolve(sessionCwd, value)
-    if (Buffer.isBuffer(value)) {
-      const absolute = isAbsolute(String.fromCharCode(...value.subarray(0, 3)))
-      return absolute ? value : Buffer.concat([bufferPrefix, value])
+    if (bufferIsBuffer(value)) {
+      const absolute = isAbsolute(bufferToString(value, 'utf8', 0, 3))
+      return absolute ? value : bufferConcat([bufferPrefix, value])
     }
     return value
   }
   const sessionPathPrefix = (value) => {
     if (typeof value !== 'string' || isAbsolute(value) || parse(value).root !== '') return sessionPath(value)
-    return sessionCwd + (/[\\/]$/.test(sessionCwd) ? '' : sep) + value
+    return sessionCwd + (regexpTest(TRAILING_SEPARATOR, sessionCwd) ? '' : sep) + value
   }
   const projectPaths = (args, indices) => {
-    const next = [...args]
-    for (const index of indices) next[index] = sessionPath(next[index])
+    const next = copyArray(args)
+    for (let offset = 0; offset < indices.length; offset += 1) {
+      const index = indices[offset]
+      next[index] = sessionPath(next[index])
+    }
     return next
   }
   const projectPrefix = (args) => {
-    const next = [...args]
+    const next = copyArray(args)
     next[0] = sessionPathPrefix(next[0])
     return next
   }
-  const sessionChildOptions = options => (
-    options === null || typeof options !== 'object' || options.cwd !== undefined
-      ? options
-      : { ...options, cwd: sessionCwd }
-  )
-  const withDefaultOptions = (args, index) => {
-    const next = [...args]
-    next[index] = sessionChildOptions(next[index]) ?? { cwd: sessionCwd }
-    return next
-  }
-  const childProcessOptions = (name, args) => {
-    if (name === 'exec' || name === 'execSync') {
-      const next = [...args]
-      if (typeof next[1] === 'function') next.splice(1, 0, { cwd: sessionCwd })
-      else next[1] = sessionChildOptions(next[1]) ?? { cwd: sessionCwd }
-      return next
-    }
-    if (name === 'execFile' || name === 'execFileSync') {
-      if (args.length === 1 || typeof args[1] === 'function') {
-        const next = [...args]
-        next.splice(1, 0, { cwd: sessionCwd })
-        return next
-      }
-      if (typeof args[2] === 'function') {
-        if (args[1] !== undefined && !Array.isArray(args[1])) return withDefaultOptions(args, 1)
-        const next = [...args]
-        next.splice(2, 0, { cwd: sessionCwd })
-        return next
-      }
-      if (args[1] !== undefined && !Array.isArray(args[1])) return withDefaultOptions(args, 1)
-      return withDefaultOptions(args, 2)
-    }
-    return args.length === 1 || (args[1] !== undefined && !Array.isArray(args[1]))
-      ? withDefaultOptions(args, 1)
-      : withDefaultOptions(args, 2)
-  }
   const sessionGlobOptions = (args) => {
-    const next = [...args]
-    if (typeof next[1] === 'function') next.splice(1, 0, { cwd: sessionCwd })
-    else if (next[1] === undefined) next[1] = { cwd: sessionCwd }
+    if (typeof args[1] === 'function') {
+      const next = copyArray(args, 0, 1)
+      appendArray(next, { cwd: sessionCwd })
+      return copyArray(args, 1, args.length, next)
+    }
+    const next = copyArray(args)
+    if (next[1] === undefined) next[1] = { cwd: sessionCwd }
     else if (next[1] !== null && typeof next[1] === 'object' && next[1].cwd === undefined) {
       next[1] = { ...next[1], cwd: sessionCwd }
     }
     return next
   }
 
-  process.cwd = () => 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)) {
@@ -147,9 +174,10 @@ export function installWorkerCwdVirtualization(sessionCwd, originalRequire) {
     wrapBuiltin(fs, name, sessionGlobOptions)
     wrapBuiltin(fs.promises, name, sessionGlobOptions)
   }
-  wrapBuiltin(path, 'resolve', args => [sessionCwd, ...args])
+  wrapBuiltin(path, 'resolve', args => copyArray(args, 0, args.length, [sessionCwd]))
   const childProcess = originalRequire('node:child_process')
   for (const name of ['exec', 'execFile', 'execFileSync', 'execSync', 'fork', 'spawn', 'spawnSync']) {
-    wrapBuiltin(childProcess, name, args => childProcessOptions(name, args), CHILD_PROCESS_PROJECTED_PROPERTIES[name])
+    wrapBuiltin(childProcess, name,
+      args => projectChildProcessArguments(name, args, sessionCwd), CHILD_PROCESS_PROJECTED_PROPERTIES[name])
   }
 }

package/internal/worker-environment.js

@@ -23,6 +23,26 @@ export const HOST_ONLY_ENVIRONMENT_NAMES = new Set([
   'dsh_ptc_compiler_bytecode',
 ])
 
+/** Detect whether the Host executable needs Electron's Node startup mode. */
+export function isElectronHost(versions = process.versions) {
+  return typeof versions?.electron === 'string'
+}
+
+/** Overlay only the helper process environment needed to boot an Electron executable as Node. */
+export function helperProcessEnvironment(source, platform = process.platform, electronHost = isElectronHost()) {
+  if (!electronHost) return source
+  const environment = { ...(source ?? process.env) }
+  if (platform === 'win32') {
+    for (const name of Object.keys(environment)) {
+      if (name !== 'ELECTRON_RUN_AS_NODE' && name.toLowerCase() === 'electron_run_as_node') {
+        delete environment[name]
+      }
+    }
+  }
+  environment.ELECTRON_RUN_AS_NODE = '1'
+  return environment
+}
+
 /** Project the host environment once without losing Windows case variants. */
 export function normalizeWorkerEnvironment(source, platform = process.platform) {
   if (platform !== 'win32') {

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 }
+  }
+}

package/internal/worker-output-fence.js

@@ -0,0 +1,26 @@
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
+
+const FENCE_PREFIX = '\u001eDSH_PTC_OUTPUT_FENCE_V1:'
+const FENCE_SUFFIX = '\u001f'
+const TOKEN = /^[a-f0-9]{48}$/u
+const FENCE = /\u001eDSH_PTC_OUTPUT_FENCE_V1:(?:stdout|stderr):(?:start|end):[a-f0-9]{48}\u001f/gu
+const { regexpTest, replaceString, toString } = internal
+
+export const OUTPUT_FENCE_ALLOWANCE_BYTES = 512
+
+export function validOutputFenceToken(token) {
+  return typeof token === 'string' && regexpTest(TOKEN, token)
+}
+
+export function outputFenceMarker(token, channel, phase) {
+  if (!validOutputFenceToken(token)
+    || (channel !== 'stdout' && channel !== 'stderr')
+    || (phase !== 'start' && phase !== 'end')) {
+    throw new TypeError('invalid worker output fence')
+  }
+  return `${FENCE_PREFIX}${channel}:${phase}:${token}${FENCE_SUFFIX}`
+}
+
+export function stripOutputFenceMarkers(value) {
+  return replaceString(toString(value ?? ''), FENCE, '')
+}