dsh-ptc-plus 0.4.1 → 0.4.2

package/internal/value-wire.js

@@ -1,4 +1,5 @@
 import { assertFields, isRecord } from './record-utils.js'
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
 import {
   VALUE_CODEC,
   DEFAULT_VALUE_LIMITS,
@@ -12,12 +13,24 @@ import {
 } from './value-wire-schema.js'
 
 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,
+  appendArray, popArray, join } = internal
 const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+const intrinsicFunctionToString = Function.prototype.toString
+const reflectApply = Reflect.apply
+const bufferByteLength = internal.bufferByteLength
+const jsonStringify = JSON.stringify
 
 function limitsOf(options = {}) {
   const limits = { ...DEFAULT_VALUE_LIMITS, ...options }
-  for (const [name, value] of Object.entries(limits)) {
-    if (!Number.isSafeInteger(value) || value < 1) throw new TypeError(`invalid PTC value limit ${name}`)
+  const entries = Object.entries(limits)
+  for (let index = 0; index < entries.length; index += 1) {
+    const name = entries[index][0]
+    const value = entries[index][1]
+    if (!numberIsSafeInteger(value) || value < 1) throw new TypeError(`invalid PTC value limit ${name}`)
   }
   return limits
 }
@@ -28,7 +41,7 @@ function hasIntrinsicConstructor(prototype, name) {
   try {
     return constructor.name === name
       && constructor.prototype === prototype
-      && Function.prototype.toString.call(constructor) === `function ${name}() { [native code] }`
+      && reflectApply(intrinsicFunctionToString, constructor, []) === `function ${name}() { [native code] }`
   } catch {
     return false
   }
@@ -47,7 +60,7 @@ function plainObjectPrototype(value) {
 
 function hasPlainArrayPrototype(value) {
   const prototype = Object.getPrototypeOf(value)
-  if (!Array.isArray(prototype) || !hasIntrinsicConstructor(prototype, 'Array')) return false
+  if (!isArray(prototype) || !hasIntrinsicConstructor(prototype, 'Array')) return false
   const objectPrototype = Object.getPrototypeOf(prototype)
   return objectPrototype !== null && typeof objectPrototype === 'object'
     && isIntrinsicObjectPrototype(objectPrototype)
@@ -58,7 +71,7 @@ function invalid(path, detail) {
 }
 
 function stringBytes(value) {
-  return Buffer.byteLength(value, 'utf8')
+  return bufferByteLength(value, 'utf8')
 }
 
 /** Encode one supported JavaScript graph into the project-owned JSON-safe wire. */
@@ -82,7 +95,7 @@ export function encodeValue(value, options = {}) {
       return current
     }
     if (typeof current === 'number') {
-      if (Number.isNaN(current)) return { tag: 'number', value: 'nan' }
+      if (numberIsNaN(current)) return { tag: 'number', value: 'nan' }
       if (current === Infinity) return { tag: 'number', value: 'infinity' }
       if (current === -Infinity) return { tag: 'number', value: '-infinity' }
       if (Object.is(current, -0)) return { tag: 'number', value: '-0' }
@@ -90,20 +103,20 @@ export function encodeValue(value, options = {}) {
     }
     if (current === undefined) return { tag: 'undefined' }
     if (typeof current === 'bigint') {
-      const text = String(current)
+      const text = toString(current)
       const digits = text[0] === '-' ? text.length - 1 : text.length
       if (digits > limits.maxBigIntDigits) invalid(path, `BigInt exceeds ${limits.maxBigIntDigits} digits`)
       accountText(text, path)
       return { tag: 'bigint', value: text }
     }
     if (typeof current !== 'object') invalid(path, typeof current)
-    const prior = seen.get(current)
+    const prior = weakMapGet(seen, current)
     if (prior !== undefined) return { tag: 'reference', index: prior }
     if (nodes.length >= limits.maxNodes) invalid(path, `node budget exceeds ${limits.maxNodes}`)
     const index = nodes.length
-    seen.set(current, index)
-    nodes.push(undefined)
-    pending.push({ value: current, index, path })
+    weakMapSet(seen, current, index)
+    appendArray(nodes, undefined)
+    appendArray(pending, { value: current, index, path })
     return { tag: 'reference', index }
   }
 
@@ -111,24 +124,26 @@ export function encodeValue(value, options = {}) {
   for (let cursor = 0; cursor < pending.length; cursor += 1) {
     const item = pending[cursor]
     const current = item.value
-    if (Array.isArray(current)) {
+    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}`)
       const entries = []
-      for (const key of Reflect.ownKeys(current)) {
+      const keys = Reflect.ownKeys(current)
+      for (let keyIndex = 0; keyIndex < keys.length; keyIndex += 1) {
+        const key = keys[keyIndex]
         if (key === 'length') continue
-        if (typeof key !== 'string' || !/^(0|[1-9][0-9]*)$/.test(key)) {
+        if (typeof key !== 'string' || !regexpTest(/^(0|[1-9][0-9]*)$/, key)) {
           invalid(item.path, 'array has a symbol or non-index property')
         }
-        const index = Number(key)
-        if (!Number.isSafeInteger(index) || index >= current.length) invalid(`${item.path}[${key}]`, 'invalid array index')
+        const index = toNumber(key)
+        if (!numberIsSafeInteger(index) || index >= current.length) invalid(`${item.path}[${key}]`, 'invalid array index')
         const descriptor = Object.getOwnPropertyDescriptor(current, key)
         if (descriptor === undefined || !Object.hasOwn(descriptor, 'value') || descriptor.enumerable !== true) {
           invalid(`${item.path}[${key}]`, 'array index must be an enumerable data property')
         }
         edgeCount += 1
         if (edgeCount > limits.maxEdges) invalid(item.path, `edge budget exceeds ${limits.maxEdges}`)
-        entries.push([index, atom(descriptor.value, `${item.path}[${key}]`)])
+        appendArray(entries, [index, atom(descriptor.value, `${item.path}[${key}]`)])
       }
       nodes[item.index] = { type: 'array', length: current.length, entries }
       continue
@@ -137,7 +152,9 @@ export function encodeValue(value, options = {}) {
     const prototype = plainObjectPrototype(current)
     if (prototype === undefined) invalid(item.path, 'non-plain object')
     const entries = []
-    for (const key of Reflect.ownKeys(current)) {
+    const keys = Reflect.ownKeys(current)
+    for (let keyIndex = 0; keyIndex < keys.length; keyIndex += 1) {
+      const key = keys[keyIndex]
       if (typeof key !== 'string') invalid(item.path, 'object has a symbol key')
       const descriptor = Object.getOwnPropertyDescriptor(current, key)
       if (descriptor === undefined || !Object.hasOwn(descriptor, 'value') || descriptor.enumerable !== true) {
@@ -146,7 +163,7 @@ export function encodeValue(value, options = {}) {
       accountText(key, `${item.path}.${key}`)
       edgeCount += 1
       if (edgeCount > limits.maxEdges) invalid(item.path, `edge budget exceeds ${limits.maxEdges}`)
-      entries.push([key, atom(descriptor.value, `${item.path}.${key}`)])
+      appendArray(entries, [key, atom(descriptor.value, `${item.path}.${key}`)])
     }
     nodes[item.index] = { type: 'object', prototype, entries }
   }
@@ -161,7 +178,7 @@ function decodeAtom(atom, nodes, limits, budget, path) {
     return atom
   }
   if (typeof atom === 'number') {
-    if (!Number.isFinite(atom) || Object.is(atom, -0)) throw new TypeError(`invalid PTC value number at ${path}`)
+    if (!numberIsFinite(atom) || Object.is(atom, -0)) throw new TypeError(`invalid PTC value number at ${path}`)
     return atom
   }
   if (!isRecord(atom) || typeof atom.tag !== 'string') throw new TypeError(`invalid PTC value atom at ${path}`)
@@ -179,31 +196,31 @@ function decodeAtom(atom, nodes, limits, budget, path) {
   }
   if (atom.tag === 'bigint') {
     assertFields(atom, BIGINT_FIELDS, 'PTC BigInt atom')
-    if (typeof atom.value !== 'string' || !/^(0|-[1-9][0-9]*|[1-9][0-9]*)$/.test(atom.value)) {
+    if (typeof atom.value !== 'string' || !regexpTest(/^(0|-[1-9][0-9]*|[1-9][0-9]*)$/, atom.value)) {
       throw new TypeError('invalid PTC BigInt')
     }
     const digits = atom.value[0] === '-' ? atom.value.length - 1 : atom.value.length
     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 BigInt(atom.value)
+    return toBigInt(atom.value)
   }
   if (atom.tag === 'reference') {
     assertFields(atom, REFERENCE_FIELDS, 'PTC reference atom')
-    if (!Number.isSafeInteger(atom.index) || atom.index < 0 || atom.index >= nodes.length) {
+    if (!numberIsSafeInteger(atom.index) || atom.index < 0 || atom.index >= nodes.length) {
       throw new TypeError('dangling PTC value reference')
     }
-    budget.reachable.add(atom.index)
+    setAdd(budget.reachable, atom.index)
     return nodes[atom.index]
   }
-  throw new TypeError(`unknown PTC value atom tag ${JSON.stringify(atom.tag)}`)
+  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)
   assertFields(wire, ENVELOPE_FIELDS, 'PTC value envelope')
-  if (wire.codec !== VALUE_CODEC || !Array.isArray(wire.nodes)) throw new TypeError('invalid PTC value codec')
+  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)
   for (let index = 0; index < wire.nodes.length; index += 1) {
@@ -211,14 +228,14 @@ function decodeCanonicalValue(wire, options = {}) {
     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 (!Number.isSafeInteger(node.length) || node.length < 0 || node.length > limits.maxArrayLength) {
+      if (!numberIsSafeInteger(node.length) || node.length < 0 || node.length > limits.maxArrayLength) {
         throw new TypeError(`invalid PTC array length at node ${index}`)
       }
-      if (!Array.isArray(node.entries)) throw new TypeError(`invalid PTC array entries at node ${index}`)
+      if (!isArray(node.entries)) throw new TypeError(`invalid PTC array entries at node ${index}`)
       targets[index] = new Array(node.length)
     } else if (node.type === 'object') {
       assertFields(node, OBJECT_NODE_FIELDS, `PTC object node ${index}`)
-      if (!['object', 'null'].includes(node.prototype) || !Array.isArray(node.entries)) {
+      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) : {}
@@ -234,8 +251,9 @@ function decodeCanonicalValue(wire, options = {}) {
     const target = targets[nodeIndex]
     if (node.type === 'array') {
       let previous = -1
-      for (const entry of node.entries) {
-        if (!Array.isArray(entry) || entry.length !== 2 || !Number.isSafeInteger(entry[0])
+      for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
+        const entry = node.entries[entryIndex]
+        if (!isArray(entry) || entry.length !== 2 || !numberIsSafeInteger(entry[0])
           || entry[0] <= previous || entry[0] < 0 || entry[0] >= node.length) {
           throw new TypeError(`invalid PTC array entry at node ${nodeIndex}`)
         }
@@ -250,11 +268,12 @@ function decodeCanonicalValue(wire, options = {}) {
       continue
     }
     const keys = new Set()
-    for (const entry of node.entries) {
-      if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== 'string' || keys.has(entry[0])) {
+    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}`)
       }
-      keys.add(entry[0])
+      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
@@ -265,10 +284,10 @@ function decodeCanonicalValue(wire, options = {}) {
       })
     }
   }
-  if (budget.reachable.size !== wire.nodes.length) throw new TypeError('PTC value envelope contains unreachable nodes')
+  if (setSize(budget.reachable) !== wire.nodes.length) throw new TypeError('PTC value envelope contains unreachable nodes')
   const canonical = encodeValue(root, limits)
-  const serialization = JSON.stringify(canonical)
-  if (serialization !== JSON.stringify(wire)) throw new TypeError('non-canonical PTC value envelope')
+  const serialization = jsonStringify(canonical)
+  if (serialization !== jsonStringify(wire)) throw new TypeError('non-canonical PTC value envelope')
   return { value: root, wire: canonical, serialization }
 }
 
@@ -295,31 +314,32 @@ export function isPlainJsonTree(value) {
   const pending = [value]
   const seen = new WeakSet()
   while (pending.length > 0) {
-    const current = pending.pop()
+    const current = popArray(pending)
     if (current === null || typeof current === 'string' || typeof current === 'boolean') continue
-    if (typeof current === 'number' && Number.isFinite(current) && !Object.is(current, -0)) continue
+    if (typeof current === 'number' && numberIsFinite(current) && !Object.is(current, -0)) continue
     if (typeof current !== 'object') return false
-    if (seen.has(current)) return false
-    seen.add(current)
-    if (Array.isArray(current)) {
+    if (weakSetHas(seen, current)) return false
+    weakSetAdd(seen, current)
+    if (isArray(current)) {
       for (let index = 0; index < current.length; index += 1) {
         if (!Object.hasOwn(current, index)) return false
-        pending.push(current[index])
+        appendArray(pending, current[index])
       }
     } else {
-      for (const key of Object.keys(current)) pending.push(current[key])
+      const keys = Object.keys(current)
+      for (let index = 0; index < keys.length; index += 1) appendArray(pending, current[keys[index]])
     }
   }
   return true
 }
 
 function renderKey(key) {
-  return IDENTIFIER.test(key) ? key : JSON.stringify(key)
+  return regexpTest(IDENTIFIER, key) ? key : jsonStringify(key)
 }
 
 function atomText(atom) {
-  if (atom === null || typeof atom === 'boolean' || typeof atom === 'number') return String(atom)
-  if (typeof atom === 'string') return JSON.stringify(atom)
+  if (atom === null || typeof atom === 'boolean' || typeof atom === 'number') return toString(atom)
+  if (typeof atom === 'string') return jsonStringify(atom)
   if (atom.tag === 'undefined') return 'undefined'
   if (atom.tag === 'number') {
     return atom.value === 'nan' ? 'NaN'
@@ -337,16 +357,20 @@ export function renderValueWire(wire, options = {}) {
 }
 
 function renderCanonicalValue(normalized, limits) {
-  const references = new Array(normalized.nodes.length).fill(0)
+  const references = new Array(normalized.nodes.length)
+  for (let index = 0; index < references.length; index += 1) references[index] = 0
   const count = (atom) => {
     if (isRecord(atom) && atom.tag === 'reference') references[atom.index] += 1
   }
   count(normalized.root)
-  for (const node of normalized.nodes) for (const entry of node.entries) count(entry[1])
+  for (let nodeIndex = 0; nodeIndex < normalized.nodes.length; nodeIndex += 1) {
+    const entries = normalized.nodes[nodeIndex].entries
+    for (let entryIndex = 0; entryIndex < entries.length; entryIndex += 1) count(entries[entryIndex][1])
+  }
   const labels = new Map()
   let nextLabel = 0
   for (let index = 0; index < references.length; index += 1) {
-    if (references[index] > 1) labels.set(index, ++nextLabel)
+    if (references[index] > 1) mapSet(labels, index, ++nextLabel)
   }
 
   const chunks = []
@@ -354,19 +378,19 @@ function renderCanonicalValue(normalized, limits) {
   const append = (text) => {
     bytes += stringBytes(text)
     if (bytes > limits.maxStringBytes) throw new TypeError(`rendered PTC value exceeds ${limits.maxStringBytes} bytes`)
-    chunks.push(text)
+    appendArray(chunks, text)
   }
   const emitted = new Set()
   const active = new Set()
   const tasks = [{ kind: 'atom', atom: normalized.root }]
   while (tasks.length > 0) {
-    const task = tasks.pop()
+    const task = popArray(tasks)
     if (task.kind === 'text') {
       append(task.text)
       continue
     }
     if (task.kind === 'leave') {
-      active.delete(task.index)
+      setDelete(active, task.index)
       continue
     }
     const primitive = atomText(task.atom)
@@ -375,38 +399,44 @@ function renderCanonicalValue(normalized, limits) {
       continue
     }
     const index = task.atom.index
-    const label = labels.get(index)
-    if (emitted.has(index)) {
-      append(active.has(index) ? `[Circular *${label}]` : `[Reference *${label}]`)
+    const label = mapGet(labels, index)
+    if (setHas(emitted, index)) {
+      append(setHas(active, index) ? `[Circular *${label}]` : `[Reference *${label}]`)
       continue
     }
-    emitted.add(index)
-    active.add(index)
+    setAdd(emitted, index)
+    setAdd(active, index)
     if (label !== undefined) append(`<ref *${label}> `)
     const node = normalized.nodes[index]
-    tasks.push({ kind: 'leave', index })
+    appendArray(tasks, { kind: 'leave', index })
     if (node.type === 'array') {
       append('[')
-      tasks.push({ kind: 'text', text: ']' })
-      const entries = new Map(node.entries)
-      if (node.length > 0 && !entries.has(node.length - 1)) tasks.push({ kind: 'text', text: ',' })
+      appendArray(tasks, { kind: 'text', text: ']' })
+      const entries = new Map()
+      for (let entryIndex = 0; entryIndex < node.entries.length; entryIndex += 1) {
+        const entry = node.entries[entryIndex]
+        mapSet(entries, entry[0], entry[1])
+      }
+      if (node.length > 0 && !mapHas(entries, node.length - 1)) appendArray(tasks, { kind: 'text', text: ',' })
       for (let item = node.length - 1; item >= 0; item -= 1) {
-        if (item < node.length - 1) tasks.push({ kind: 'text', text: ', ' })
-        const value = entries.get(item)
-        if (value !== undefined) tasks.push({ kind: 'atom', atom: value })
+        if (item < node.length - 1) appendArray(tasks, { kind: 'text', text: ', ' })
+        const value = mapGet(entries, item)
+        if (value !== undefined) appendArray(tasks, { kind: 'atom', atom: value })
       }
       continue
     }
     append('{')
-    tasks.push({ kind: 'text', text: '}' })
+    appendArray(tasks, { kind: 'text', text: '}' })
     for (let entryIndex = node.entries.length - 1; entryIndex >= 0; entryIndex -= 1) {
-      const [key, value] = node.entries[entryIndex]
-      if (entryIndex < node.entries.length - 1) tasks.push({ kind: 'text', text: ', ' })
-      tasks.push({ kind: 'atom', atom: value })
-      tasks.push({ kind: 'text', text: `${renderKey(key)}: ` })
+      const entry = node.entries[entryIndex]
+      const key = entry[0]
+      const value = entry[1]
+      if (entryIndex < node.entries.length - 1) appendArray(tasks, { kind: 'text', text: ', ' })
+      appendArray(tasks, { kind: 'atom', atom: value })
+      appendArray(tasks, { kind: 'text', text: `${renderKey(key)}: ` })
     }
   }
-  return chunks.join('')
+  return join(chunks, '')
 }
 
 /**

package/internal/worker-cwd-virtualization.js

@@ -1,5 +1,10 @@
 import { isAbsolute, parse, resolve, sep } from 'node:path'
 import { promisify } from 'node:util'
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.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 +39,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)
@@ -59,80 +64,101 @@ function wrapBuiltin(owner, name, projectArguments, projectedProperties) {
   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
+    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
+  Object.defineProperty(process, 'cwd', {
+    configurable: false,
+    enumerable: true,
+    writable: false,
+    value: () => sessionCwd,
+  })
   const fs = originalRequire('node:fs')
   const path = originalRequire('node:path')
   for (const [name, indices] of Object.entries(FILE_SYSTEM_PATH_ARGUMENTS)) {
@@ -147,9 +173,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') {