dsh-ptc-plus 0.3.2 → 0.4.2

package/internal/value-wire.js

@@ -1,28 +1,36 @@
 import { assertFields, isRecord } from './record-utils.js'
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
+import {
+  VALUE_CODEC,
+  DEFAULT_VALUE_LIMITS,
+  VALUE_ENVELOPE_FIELDS as ENVELOPE_FIELDS,
+  VALUE_OBJECT_FIELDS as OBJECT_NODE_FIELDS,
+  VALUE_ARRAY_FIELDS as ARRAY_NODE_FIELDS,
+  VALUE_UNDEFINED_FIELDS as UNDEFINED_FIELDS,
+  VALUE_NUMBER_FIELDS as NUMBER_FIELDS,
+  VALUE_BIGINT_FIELDS as BIGINT_FIELDS,
+  VALUE_REFERENCE_FIELDS as REFERENCE_FIELDS,
+} from './value-wire-schema.js'
 
-export const VALUE_CODEC = 'ptc-value-graph/v1'
-
-export const DEFAULT_VALUE_LIMITS = Object.freeze({
-  maxNodes: 100_000,
-  maxEdges: 1_000_000,
-  maxArrayLength: 1_000_000,
-  maxBigIntDigits: 100_000,
-  maxStringBytes: 64 * 1024 * 1024,
-})
-
-const ENVELOPE_FIELDS = new Set(['codec', 'root', 'nodes'])
-const OBJECT_NODE_FIELDS = new Set(['type', 'prototype', 'entries'])
-const ARRAY_NODE_FIELDS = new Set(['type', 'length', 'entries'])
-const UNDEFINED_FIELDS = new Set(['tag'])
-const NUMBER_FIELDS = new Set(['tag', 'value'])
-const BIGINT_FIELDS = new Set(['tag', 'value'])
-const REFERENCE_FIELDS = new Set(['tag', 'index'])
+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
 }
@@ -33,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
   }
@@ -52,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)
@@ -63,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. */
@@ -87,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' }
@@ -95,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 }
   }
 
@@ -116,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
@@ -142,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) {
@@ -151,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 }
   }
@@ -166,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}`)
@@ -184,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) {
@@ -216,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) : {}
@@ -239,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}`)
         }
@@ -255,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
@@ -270,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 }
 }
 
@@ -300,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'
@@ -338,17 +353,24 @@ function atomText(atom) {
 /** Deterministic bounded TS-like presentation. It is never a decode format. */
 export function renderValueWire(wire, options = {}) {
   const limits = limitsOf(options)
-  const normalized = normalizeValueWire(wire, limits)
-  const references = new Array(normalized.nodes.length).fill(0)
+  return renderCanonicalValue(decodeCanonicalValue(wire, limits).wire, limits)
+}
+
+function renderCanonicalValue(normalized, limits) {
+  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 = []
@@ -356,19 +378,19 @@ export function renderValueWire(wire, options = {}) {
   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)
@@ -377,38 +399,44 @@ export function renderValueWire(wire, options = {}) {
       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, '')
 }
 
 /**
@@ -416,6 +444,17 @@ export function renderValueWire(wire, options = {}) {
  * text. The untagged ranges overlap because a plain JSON root may itself be a string.
  */
 export function projectValueWire(wire, options = {}) {
-  const value = decodeValue(wire, options)
-  return isPlainJsonTree(value) ? value : renderValueWire(wire, options)
+  return prepareValueWire(wire, options).projectedValue
+}
+
+/** Validate once when canonical storage and outer presentation are both required. */
+export function prepareValueWire(wire, options = {}) {
+  const limits = limitsOf(options)
+  const canonical = decodeCanonicalValue(wire, limits)
+  return {
+    wire: canonical.wire,
+    projectedValue: isPlainJsonTree(canonical.value)
+      ? canonical.value
+      : renderCanonicalValue(canonical.wire, limits),
+  }
 }

package/internal/worker-client.js

@@ -1,65 +1,32 @@
 import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { isAbsolute, join } from 'node:path'
-import { Worker } from 'node:worker_threads'
-import { messageOf } from './failure-reporting.js'
+import { messageOf, processExitDescription } from './failure-reporting.js'
+import { IsolatedOwner } from './isolated-worker.js'
+import { normalizeWorkerEnvironment } from './worker-environment.js'
 
-const WINDOWS_ENVIRONMENT_NAMES = new Map([
-  ['appdata', 'APPDATA'],
-  ['comspec', 'ComSpec'],
-  ['home', 'HOME'],
-  ['homedrive', 'HOMEDRIVE'],
-  ['homepath', 'HOMEPATH'],
-  ['localappdata', 'LOCALAPPDATA'],
-  ['path', 'PATH'],
-  ['pathext', 'PATHEXT'],
-  ['programdata', 'ProgramData'],
-  ['programfiles', 'ProgramFiles'],
-  ['programfiles(x86)', 'ProgramFiles(x86)'],
-  ['systemdrive', 'SystemDrive'],
-  ['systemroot', 'SystemRoot'],
-  ['temp', 'TEMP'],
-  ['tmp', 'TMP'],
-  ['userprofile', 'USERPROFILE'],
-  ['windir', 'windir'],
-])
-const HOST_ONLY_ENVIRONMENT_NAMES = new Set(['node_test_context', 'node_v8_coverage'])
+export { normalizeWorkerEnvironment }
 
-/** Project the host environment once without losing Windows case variants. */
-export function normalizeWorkerEnvironment(source, platform = process.platform) {
-  if (platform !== 'win32') {
-    return Object.fromEntries(Object.entries(source).filter(([name, value]) => (
-      value !== undefined && !HOST_ONLY_ENVIRONMENT_NAMES.has(name.toLowerCase())
-    )))
-  }
-  const normalized = new Map()
-  for (const [name, value] of Object.entries(source)) {
-    if (value === undefined) continue
-    const key = name.toLowerCase()
-    if (HOST_ONLY_ENVIRONMENT_NAMES.has(key)) continue
-    const canonicalName = WINDOWS_ENVIRONMENT_NAMES.get(key) ?? name
-    const current = normalized.get(key)
-    if (current === undefined || name === canonicalName) {
-      normalized.set(key, [canonicalName, value])
-    }
-  }
-  return Object.fromEntries(normalized.values())
-}
+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 }) {
+  constructor({ workerUrl, cwd, onMessage, onFailure, compilerCache }) {
     this.workerUrl = workerUrl
     this.cwd = cwd
     this.onMessage = onMessage
     this.onFailure = onFailure
+    this.compilerCache = compilerCache
     this.worker = undefined
     this.workerLimit = undefined
     this.workerReady = undefined
     this.port = undefined
     this.scratchReady = undefined
     this.stderrTails = new WeakMap()
-    this.terminations = new Set()
+    // One owner keeps every started kernel transport, including startup failures
+    // and closes that were refused, until its real exit is observed.
+    this.owner = new IsolatedOwner()
+    this.hostIds = new WeakMap()
     this.disposed = false
   }
 
@@ -101,19 +68,20 @@ export class WorkerClient {
     const environment = normalizeWorkerEnvironment(process.env)
     let worker
     try {
-      worker = new Worker(this.workerUrl, {
+      const started = this.owner.start({
+        helper: KERNEL_HELPER,
+        entry: this.workerUrl,
+        workerData: { cwd: this.cwd, compilerCache: this.compilerCache?.() },
+        resourceLimits: { maxOldGenerationSizeMb: this.workerLimit },
         env: {
           ...environment,
           TEMP: scratchDirectory,
           TMP: scratchDirectory,
           TMPDIR: scratchDirectory,
         },
-        execArgv: [],
-        workerData: this.cwd === undefined ? {} : { cwd: this.cwd },
-        resourceLimits: { maxOldGenerationSizeMb: this.workerLimit },
-        stdout: true,
-        stderr: true,
       })
+      worker = started.transport
+      this.hostIds.set(worker, started.id)
     } catch (error) {
       this.workerLimit = undefined
       throw error
@@ -129,15 +97,23 @@ export class WorkerClient {
     })
     this.stderrTails.set(worker, stderrTail)
     worker.on('error', error => this.fail(worker, `worker error: ${messageOf(error)}`))
-    worker.on('exit', code => this.fail(worker, `worker exited with code ${code}`))
+    worker.on('exit', (code, signal) => {
+      this.fail(worker, `worker exited with ${processExitDescription(code, signal)}`)
+    })
     this.worker = worker
     this.workerReady = new Promise((resolve, reject) => {
-      const onError = error => reject(error)
-      const onExit = (code) => {
+      const onError = error => {
         const detail = this.stderrDetail(worker)
+        reject(detail === undefined
+          ? error
+          : new Error(`${messageOf(error)}; last stderr: ${detail}`, { cause: error }))
+      }
+      const onExit = (code, signal) => {
+        const detail = this.stderrDetail(worker)
+        const exit = processExitDescription(code, signal)
         reject(new Error(detail === undefined
-          ? `worker exited with code ${code} before opening its private channel`
-          : `worker exited with code ${code} before opening its private channel; last stderr: ${detail}`))
+          ? `worker exited with ${exit} before opening its private channel`
+          : `worker exited with ${exit} before opening its private channel; last stderr: ${detail}`))
       }
       worker.once('error', onError)
       worker.once('exit', onExit)
@@ -146,12 +122,16 @@ export class WorkerClient {
         worker.removeListener('exit', onExit)
         if (message?.type === 'startup-error' && typeof message.error === 'string') {
           reject(new Error(message.error))
-          void this.reset(worker)
+          // The owner keeps a refused reclamation, so this must not surface as an
+          // unhandled rejection after the caller already handled the startup error.
+          void this.reset(worker).catch(() => {})
           return
         }
         if (message?.type !== 'ready' || typeof message.port?.postMessage !== 'function') {
           reject(new Error('kernel worker returned an invalid private channel'))
-          void this.reset(worker)
+          // The owner keeps a refused reclamation, so this must not surface as an
+          // unhandled rejection after the caller already handled the startup error.
+          void this.reset(worker).catch(() => {})
           return
         }
         this.port = message.port
@@ -185,27 +165,37 @@ export class WorkerClient {
   }
 
   async reset(worker) {
+    const port = this.worker === worker ? this.port : undefined
     if (this.worker === worker) {
       this.worker = undefined
       this.workerLimit = undefined
       this.workerReady = undefined
-      this.port?.close()
       this.port = undefined
     }
-    const termination = worker.terminate()
-    this.terminations.add(termination)
-    try {
-      await termination
-    } finally {
-      this.terminations.delete(termination)
-    }
+    await this.owner.stop(this.hostIds.get(worker))
+    this.hostIds.delete(worker)
+    port?.close()
   }
 
   async dispose() {
     this.disposed = true
     const worker = this.worker
-    if (worker !== undefined) await this.reset(worker)
-    await Promise.all([...this.terminations])
+    const port = this.port
+    this.worker = undefined
+    this.workerLimit = undefined
+    this.workerReady = undefined
+    this.port = undefined
+    if (worker !== undefined) this.hostIds.delete(worker)
+    const failures = []
+    try {
+      port?.close()
+    } catch (error) {
+      failures.push(error)
+    }
+    failures.push(...await this.owner.dispose())
+    if (failures.length > 0) {
+      throw new AggregateError(failures, 'ptc-plus kernel worker disposal failed')
+    }
     if (this.scratchReady !== undefined) {
       try {
         const scratchDirectory = await this.scratchReady