dsh-ptc-plus 0.4.1 → 0.4.2

package/internal/binding-update-policy.js

@@ -1,6 +1,7 @@
 import { LIVE_MODULE_SEMANTICS } from './repl-rewrite-contract.js'
 import { LEGACY_LANGUAGE_SEMANTICS, STATEFUL_LANGUAGE_SEMANTICS,
   PROTECTED_LANGUAGE_SEMANTICS, normalizeLanguageSemantics } from './language-semantics.js'
+import { moduleTransformForLanguage, normalizeModuleTransform } from './module-transform-contract.js'
 
 /**
  * Translate the public compatibility settings into the execution policy used
@@ -15,8 +16,10 @@ export function executionPolicies(config, replayRecord = undefined) {
     const bindingPolicy = Object.freeze({ ...replayRecord.bindingPolicy })
     const rewritesEnabled = Object.freeze({ ...replayRecord.rewritePolicy })
     const moduleSemantics = Object.freeze({ ...replayRecord.moduleSemantics })
+    const languageSemantics = normalizeLanguageSemantics(replayRecord.languageSemantics ?? LEGACY_LANGUAGE_SEMANTICS)
     return Object.freeze({
-      languageSemantics: normalizeLanguageSemantics(replayRecord.languageSemantics ?? LEGACY_LANGUAGE_SEMANTICS),
+      languageSemantics,
+      moduleTransform: normalizeModuleTransform(replayRecord.moduleTransform, languageSemantics),
       bindingPolicy,
       rewritesEnabled,
       moduleSemantics,
@@ -25,6 +28,7 @@ export function executionPolicies(config, replayRecord = undefined) {
   if (config.bindingUpdates === 'stateful' && config.legacyBindingSettings !== true) {
     return Object.freeze({
       languageSemantics: STATEFUL_LANGUAGE_SEMANTICS,
+      moduleTransform: moduleTransformForLanguage(STATEFUL_LANGUAGE_SEMANTICS),
       bindingPolicy: Object.freeze({ variableRedeclarations: true, functionClassRedeclarations: true }),
       rewritesEnabled: Object.freeze({ autoRewriteImports: true, autoStripExports: true, autoSplitRedeclarations: true }),
       moduleSemantics: LIVE_MODULE_SEMANTICS,
@@ -33,6 +37,7 @@ export function executionPolicies(config, replayRecord = undefined) {
   if (config.bindingUpdates === 'protected' && config.legacyBindingSettings !== true) {
     return Object.freeze({
       languageSemantics: PROTECTED_LANGUAGE_SEMANTICS,
+      moduleTransform: moduleTransformForLanguage(PROTECTED_LANGUAGE_SEMANTICS),
       bindingPolicy: Object.freeze({ variableRedeclarations: false, functionClassRedeclarations: false }),
       // Module syntax is part of the language in protected mode too.  The
       // policy protects existing names; it does not remove valid syntax.
@@ -42,6 +47,7 @@ export function executionPolicies(config, replayRecord = undefined) {
   }
   return Object.freeze({
     languageSemantics: LEGACY_LANGUAGE_SEMANTICS,
+    moduleTransform: moduleTransformForLanguage(LEGACY_LANGUAGE_SEMANTICS),
     bindingPolicy: Object.freeze({
       variableRedeclarations: config.looseTopLevelRedeclarations === true,
       functionClassRedeclarations: config.looseTopLevelFunctionClassRedeclarations === true,

package/internal/cell-analysis.js

@@ -17,7 +17,7 @@ import {
   renderDurabilityReason,
   renderDurabilityReasons,
 } from './module-policy.js'
-import { applySourceEdits, mapSourcePosition, mapSourceSpan } from './source-position-map.js'
+import { applySourceEdits, mapSourcePosition, mapSourceSpan, sourceRangeHasOriginalText } from './source-position-map.js'
 import { SKIP_AST_CHILDREN, walkAst } from './ast-traversal.js'
 import { compileStatefulRoot } from './stateful-root-compiler.js'
 import { CELL_PARSER_PLUGINS, bindCompilerIntrinsics, lowerStatefulDecorators, lowerStatefulResources, lowerNativeLanguageSource, normalizeStatefulScopes } from './repl-scope-normalizer.js'
@@ -240,7 +240,9 @@ function staticModuleClassification(moduleLoads) {
 }
 
 /** Conservatively classify a cell before giving it non-journalable capability. */
-export function classifyDurability(code, knownBindings = new Set(), { sourceType = 'script', internalModules = new Set() } = {}) {
+export function classifyDurability(code, knownBindings = new Set(), {
+  sourceType = 'script', internalModules = new Set(), sourceMap = undefined, originalSource = undefined,
+} = {}) {
   let body
   let moduleLoads = []
   if (sourceType === 'module') {
@@ -297,11 +299,12 @@ export function classifyDurability(code, knownBindings = new Set(), { sourceType
     }
     return false
   }
-  walkAst(body, (node, parent, parentKey, { scopes, strict }) => {
+  walkAst(body, (node, parent, parentKey, { scopes, strict, thisIsGlobal }) => {
     let nestedScopes = scopes
     if (isFunction(node)) {
       strict ||= hasStrictDirective(node.body)
       nestedScopes = [...scopes, functionParameterBindings(node)]
+      if (node.type !== 'ArrowFunctionExpression') thisIsGlobal = false
     } else if (node.type === 'BlockStatement' && node !== body) {
       const names = directBlockBindings(node.body)
       if (isFunction(parent)) addFunctionVariables(node, names, strict)
@@ -326,6 +329,11 @@ export function classifyDurability(code, knownBindings = new Set(), { sourceType
     if (node.type === 'ImportExpression') {
       classifyModule(node.source)
     }
+    const sourceOwnedThis = sourceMap === undefined
+      || sourceRangeHasOriginalText(sourceMap, code, originalSource, node.start, node.end)
+    if (node.type === 'ThisExpression' && thisIsGlobal && sourceOwnedThis) {
+      addReason(Object.freeze({ kind: 'ambient', name: 'globalThis' }))
+    }
     if (node.type === 'CallExpression' && node.callee?.type === 'Identifier' && node.callee.name === 'require'
       && !isBound('require', nestedScopes)) {
       classifyModule(node.arguments[0])
@@ -367,8 +375,8 @@ export function classifyDurability(code, knownBindings = new Set(), { sourceType
         addReason(Object.freeze({ kind: 'ambient', name: 'Math' }))
       }
     }
-    return { scopes: nestedScopes, strict }
-  }, undefined, { scopes: [rootBindings], strict: rootStrict })
+    return { scopes: nestedScopes, strict, thisIsGlobal }
+  }, undefined, { scopes: [rootBindings], strict: rootStrict, thisIsGlobal: sourceType === 'script' })
   return {
     durability: reasons.size === 0 ? 'durable' : 'volatile',
     reasons: Object.freeze([...reasons.values()]),
@@ -473,12 +481,17 @@ export function prepareProgram(program, options = {}) {
     prepared = { ...prepared, deferredHelpers: normalized.deferredHelpers }
     intrinsicContext.expression = `this[${JSON.stringify(prepared.rootRuntimeName)}].intrinsics`
     const classificationSource = bindCompilerIntrinsics(lowerStatefulDecorators(
-      { ...prepared, code: prepared.classificationCode }, undefined, intrinsicContext), intrinsicContext).code
+      { ...prepared, code: prepared.classificationCode, sourceMap: prepared.classificationSourceMap },
+      undefined, intrinsicContext), intrinsicContext)
     prepared = bindCompilerIntrinsics(lowerStatefulDecorators(prepared, undefined, intrinsicContext), intrinsicContext)
     prepared = lowerStatefulResources(prepared, { intrinsicContext, nativeUsing: options.nativeUsing })
     const parsed = parseExecutableCell(prepared.code, { eraseTypes: true })
-    const classification = classifyDurability(parseExecutableCell(classificationSource, { eraseTypes: true }).code,
-      new Set([...(options.knownBindings ?? []), ...prepared.declared]))
+    const classificationCode = parseExecutableCell(classificationSource.code, { eraseTypes: true }).code
+    const classification = classifyDurability(classificationCode,
+      new Set([...(options.knownBindings ?? []), ...prepared.declared]), {
+        sourceMap: classificationSource.sourceMap,
+        originalSource: program,
+      })
     const reasons = [...staticModuleClassification(prepared.moduleLoads), ...classification.reasons]
     const lowered = rewriteCellReturns(parsed.code, prepared.sourceMap,
       new Set([...prepared.declared, ...(options.knownBindings ?? [])]))

package/internal/compiler-intrinsics.js

@@ -1,15 +1,12 @@
 import { stringifyCompilerData } from './compiler-data.js'
 import { compilerStorageSource } from './compiler-storage-source.js'
 import { compilerDescriptorSource } from './compiler-descriptors.js'
+import { runtimeIntrinsics } from './runtime-intrinsics.js'
 
 /** Compiler operations are captured before an owned realm executes user code. */
 const defaultRealmFunction = Function
 const realms = new WeakMap()
-const uncurry = Function.prototype.bind.bind(Function.prototype.call)
-const weakMapGet = uncurry(WeakMap.prototype.get)
-const weakMapSet = uncurry(WeakMap.prototype.set)
-const mapKeys = uncurry(Map.prototype.keys)
-const mapIteratorNext = uncurry(Object.getPrototypeOf(new Map().keys()).next)
+const { weakMapGet, weakMapSet } = runtimeIntrinsics
 
 export function captureCompilerIntrinsics(realmFunction = defaultRealmFunction) {
   let intrinsics = weakMapGet(realms, realmFunction)
@@ -21,7 +18,8 @@ export function captureCompilerIntrinsics(realmFunction = defaultRealmFunction)
     const object=properties.Object;
     const symbol=Symbol;
     return {Object:object,WeakMap,WeakSet,unscopables:symbol.unscopables,Reflect:{apply:nativeReflect.apply,
-      construct:nativeReflect.construct,ownKeys:nativeReflect.ownKeys,defineProperty:properties.reflectDefineProperty,
+      construct:nativeReflect.construct,deleteProperty:nativeReflect.deleteProperty,has:nativeReflect.has,
+      ownKeys:nativeReflect.ownKeys,defineProperty:properties.reflectDefineProperty,
       get decorate(){return nativeReflect.decorate}},TypeError,ReferenceError,SyntaxError,Error,Symbol,String,Number,
       Promise:{resolve:Promise.resolve.bind(Promise),reject:Promise.reject.bind(Promise)},
       SuppressedError:typeof SuppressedError==='function'?SuppressedError:undefined,
@@ -36,49 +34,17 @@ export const moduleCompilerIntrinsics = captureCompilerIntrinsics()
 /** Internal graph records use captured collection operations. Source-owned
  * objects and callbacks keep their original realm and observable methods. */
 export const moduleRuntimeIntrinsics = {
+  ...runtimeIntrinsics,
   Object: moduleCompilerIntrinsics.Object,
   Reflect: moduleCompilerIntrinsics.Reflect,
   Error: moduleCompilerIntrinsics.Error,
-  Map, Set, WeakMap, Proxy,
-  mapGet: uncurry(Map.prototype.get),
-  mapHas: uncurry(Map.prototype.has),
-  mapSet: uncurry(Map.prototype.set),
-  mapDelete: uncurry(Map.prototype.delete),
-  mapClear: uncurry(Map.prototype.clear),
-  mapSize: uncurry(Object.getOwnPropertyDescriptor(Map.prototype, 'size').get),
-  mapFirstKey: value => mapIteratorNext(mapKeys(value)).value,
-  mapForEach: uncurry(Map.prototype.forEach),
-  setHas: uncurry(Set.prototype.has),
-  setAdd: uncurry(Set.prototype.add),
-  setDelete: uncurry(Set.prototype.delete),
-  setClear: uncurry(Set.prototype.clear),
-  setForEach: uncurry(Set.prototype.forEach),
-  weakMapHas: uncurry(WeakMap.prototype.has),
-  weakMapGet, weakMapSet,
-  isArray: Array.isArray,
-  includes: uncurry(Array.prototype.includes),
-  join: uncurry(Array.prototype.join),
-  sliceString: uncurry(String.prototype.slice),
-  replaceAllString: uncurry(String.prototype.replaceAll),
-  includesString: uncurry(String.prototype.includes),
-  floor: Math.floor,
-  min: Math.min,
-  max: Math.max,
+  TypeError: moduleCompilerIntrinsics.TypeError,
   // Only private native Promises enter this boundary. Source promises and the
   // public result keep their prototypes; private reactions cannot select a
   // source constructor/species or dynamically dispatch through then/catch.
   observeOwnedPromise: moduleCompilerIntrinsics.observeOwnedPromise,
-  appendArray(target, value) {
-    moduleCompilerIntrinsics.Object.defineProperty(target, target.length,
-      { value, writable: true, enumerable: true, configurable: true })
-    return target
-  },
-  copyArray(source, start = 0, end = source.length, target = []) {
-    for (let index = start; index < end; index++) this.appendArray(target, source[index])
-    return target
-  },
-  sort: uncurry(Array.prototype.sort),
-  compare: uncurry(String.prototype.localeCompare),
-  startsWith: uncurry(String.prototype.startsWith),
+  promiseThen: moduleCompilerIntrinsics.promiseThen,
+  promiseResolve: moduleCompilerIntrinsics.Promise.resolve,
+  promiseReject: moduleCompilerIntrinsics.Promise.reject,
   stringify: stringifyCompilerData,
 }

package/internal/compiler-module-links.js

@@ -1,6 +1,9 @@
 import { fileURLToPath } from 'node:url'
 
 const encodeReference = encodeURIComponent
+const objectEntries = Object.entries
+const sortArray = Function.prototype.call.bind(Array.prototype.sort)
+const jsonStringify = JSON.stringify
 
 // These ambient inputs must remain outside source-owned CommonJS bindings.
 export const commonJsCompilerGlobals = new Set(['process'])
@@ -21,14 +24,14 @@ const ATTRIBUTED_LINK_KIND = 'static-attributed'
  * attribute-free links keep the reference they had before attributes were
  * distinguished. */
 export function staticModuleLinkReference(source, attributes) {
-  const entries = Object.entries(attributes ?? {})
+  const entries = objectEntries(attributes ?? {})
   if (entries.length === 0) return compilerModuleReference(STATIC_LINK_KIND, source)
-  entries.sort((left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0)
-  return compilerModuleReference(ATTRIBUTED_LINK_KIND, JSON.stringify([source, entries]))
+  sortArray(entries, (left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0)
+  return compilerModuleReference(ATTRIBUTED_LINK_KIND, jsonStringify([source, entries]))
 }
 
 /** Compiler helpers resolve from their own URL, independently of source-owned
  * wrapper bindings and the ESM translator's restricted CommonJS require. */
 export function commonJsCompilerImport(url) {
-  return `process.getBuiltinModule('module').createRequire(${JSON.stringify(url.href)})(${JSON.stringify(fileURLToPath(url))})`
+  return `process.getBuiltinModule('module').createRequire(${jsonStringify(url.href)})(${jsonStringify(fileURLToPath(url))})`
 }

package/internal/dynamic-environment-integration.js

@@ -34,15 +34,19 @@ export function adaptDynamicCell(code, sourceMap, options) {
   let setup
   if (options.module === true) {
     const runtimeUrl = new URL('./dynamic-environment-runtime.js', import.meta.url)
+    const interfaceOwner = allocate('dynamic_interface_owner')
+    const runtimeOptions = `{interfaceOwner:${interfaceOwner}${options.importOperation === undefined
+      ? '' : `,importModule:${options.importOperation}`}}`
     if (options.sourceType === 'module') {
       const factory = allocate('dynamic_factory')
-      setup = `\nimport {createDynamicEnvironmentRuntime as ${factory}} from ${JSON.stringify(runtimeUrl.href)};\n`
-      expression = `${factory}(${options.importOperation === undefined ? '' : `{importModule:${options.importOperation}}`}).installIntrinsics().environment({strict:true,getThis:()=>void 0})`
-      options = { ...options, internalBindings: new Set([...options.internalBindings ?? [], factory]) }
+      setup = `\nimport {createDynamicEnvironmentRuntime as ${factory}} from ${JSON.stringify(runtimeUrl.href)};\nfunction ${interfaceOwner}(){}\n`
+      expression = `${factory}(${runtimeOptions}).installIntrinsics().environment({strict:true,getThis:()=>void 0})`
+      options = { ...options, internalBindings: new Set([...options.internalBindings ?? [], factory, interfaceOwner]) }
     } else {
       const names = ['exports', 'module', 'require', '__filename', '__dirname', 'arguments']
       const bindings = names.map(name => `[${JSON.stringify(name)},{kind:"param",get:()=>${name}${name === 'arguments' && strict ? '' : `,set:v=>${name}=v`}}]`).join(',')
-      setup = `\nconst ${environmentName}=${commonJsCompilerImport(runtimeUrl)}.createDynamicEnvironmentRuntime(${options.importOperation === undefined ? '' : `{importModule:${options.importOperation}}`}).installIntrinsics().environment({strict:${strict},getThis:()=>this,getNewTarget:()=>new.target,allowNewTarget:true,nativeBindings:[${bindings}]});\n`
+      setup = `\nfunction ${interfaceOwner}(){}\nconst ${environmentName}=${commonJsCompilerImport(runtimeUrl)}.createDynamicEnvironmentRuntime(${runtimeOptions}).installIntrinsics().environment({strict:${strict},getThis:()=>this,getNewTarget:()=>new.target,allowNewTarget:true,nativeBindings:[${bindings}]});\n`
+      options = { ...options, internalBindings: new Set([...options.internalBindings ?? [], interfaceOwner]) }
     }
   } else setup = options.nativeRoot === true ? `\nconst ${environmentName}=${options.environmentGlobal};\n`
     : `\nconst ${environmentName}=${options.rootRuntime}.dynamic();\n`

package/internal/dynamic-environment-runtime.js

@@ -16,6 +16,17 @@ function captureReflection(reflect) {
   return captured
 }
 const defaultIntrinsics = { intrinsicEval: eval, realmFunction: Function, globalObject: globalThis, reflect: captureReflection(Reflect) }
+let programAmbientResolver
+
+/** Install the worker-owned resolver used by explicitly adapted program modules. */
+export function installProgramAmbientResolver(resolve) {
+  if (programAmbientResolver !== undefined) throw new Error('program ambient resolver is already installed')
+  if (typeof resolve !== 'function') throw new TypeError('program ambient resolver must be a function')
+  programAmbientResolver = resolve
+  return () => {
+    if (programAmbientResolver === resolve) programAmbientResolver = undefined
+  }
+}
 
 const isObject = value => value !== null && (typeof value === 'object' || typeof value === 'function')
 const isMap = types.isMap
@@ -45,7 +56,7 @@ const asBindings = value => {
 export function createDynamicEnvironmentRuntime({
   importModule = (source, options) => import(source, options),
   intrinsicEval = defaultIntrinsics.intrinsicEval, realmFunction = defaultIntrinsics.realmFunction, globalObject = defaultIntrinsics.globalObject,
-  errors, reflect = defaultIntrinsics.reflect, object, interfaceOwner,
+  errors, reflect = defaultIntrinsics.reflect, object, interfaceOwner, resolveAmbient = programAmbientResolver,
 } = {}) {
   const intrinsics = captureCompilerIntrinsics(realmFunction)
   const { unscopables, Object: intrinsicObject, array: internalArray } = intrinsics
@@ -143,7 +154,10 @@ export function createDynamicEnvironmentRuntime({
       return deleted
     },
   }, object, strict)
-  const ambientReference = (name, strict) => reference(name, {
+  const ambientReference = (name, strict) => {
+    const resolved = resolveAmbient?.(name)
+    if (resolved !== undefined) return reference(name, resolved, undefined, strict)
+    return reference(name, {
     get() {
       if (!reflect.has(globalObject, name)) throw new errors.ReferenceError(`${name} is not defined`)
       return reflect.get(globalObject, name, globalObject)
@@ -154,7 +168,8 @@ export function createDynamicEnvironmentRuntime({
     },
     typeof: () => reflect.has(globalObject, name) ? typeof reflect.get(globalObject, name, globalObject) : 'undefined',
     delete: () => reflect.deleteProperty(globalObject, name),
-  }, undefined, strict)
+    }, undefined, strict)
+  }
 
   function environment({ frames = [], varFrame = new internal.Map(), strict = false, origin, lexicalContext = {},
     getThis = () => globalObject, getNewTarget = () => undefined, allowNewTarget = false,
@@ -170,6 +185,12 @@ export function createDynamicEnvironmentRuntime({
       importModule,
       internalArray,
       expose: nativeCalls.exposedValue,
+      exposeProperty(receiver, key) {
+        if (receiver === null || receiver === undefined) {
+          throw new errors.TypeError(`Cannot read properties of ${receiver}`)
+        }
+        return nativeCalls.exposedMemberValue(receiver, reflect.get(object(receiver), key, receiver))
+      },
       prepareCall: nativeCalls.prepareCall,
       prepareInvocation: nativeCalls.prepareInvocation,
       releaseMemberReceiver: nativeCalls.releaseMemberReceiver,

package/internal/dynamic-native-calls.js

@@ -42,7 +42,10 @@ export function rewriteNativeCalls(tree, environment, { origin, skip, operations
       parent.node.computed = true
       parent.node.key = t.stringLiteral(path.node.name)
     }
-    path.replaceWith(t.inherits(helper('expose', [path.node]), path.node))
+    if (path.isMemberExpression() && !t.isSuper(path.node.object) && !t.isPrivateName(path.node.property)) {
+      const key = path.node.computed ? path.node.property : t.stringLiteral(path.node.property.name)
+      path.replaceWith(t.inherits(helper('exposeProperty', [path.node.object, key]), path.node))
+    } else path.replaceWith(t.inherits(helper('expose', [path.node]), path.node))
     path.skip()
   }
   const prepare = (callee, target, optional = false) => {

package/internal/dynamic-native-runtime.js

@@ -11,6 +11,7 @@ const exposedIntrinsics = new internal.WeakMap()
 const sources = createCallableSourceRegistry()
 const callableSources = new internal.WeakMap()
 const callableSourceTargets = new internal.WeakMap()
+const callableInterfaces = new internal.WeakMap()
 const sourceTarget = origin => typeof origin === 'string' ? origin : origin?.target
 const copyArguments = (source, start = 0, result = []) => internal.copyArray(source, start, source.length, result)
 const invocationScopes = new AsyncLocalStorage()
@@ -114,7 +115,19 @@ export function createNativeCallAdapter({ realmFunction, intrinsicEval, reflect,
     internal.weakMapSet(state.callableSources, compiled, source)
     return compiled
   }
-  const exposedValue = value => internal.mapGet(selected.exposed, value) ?? internal.weakMapGet(exposedIntrinsics, value) ?? value
+  const exposedValue = value => {
+    const exposed = internal.mapGet(selected.exposed, value) ?? internal.weakMapGet(exposedIntrinsics, value)
+    if (exposed !== undefined) return exposed
+    if (typeof value === 'function' && !internal.weakMapHas(callableInterfaces, value)) {
+      internal.weakMapSet(callableInterfaces, value, selected)
+    }
+    return value
+  }
+  const exposedMemberValue = (receiver, value) => {
+    const owner = typeof receiver === 'function' ? internal.weakMapGet(callableInterfaces, receiver) : undefined
+    const exposed = owner === undefined ? undefined : internal.mapGet(owner.exposed, value)
+    return exposed ?? exposedValue(value)
+  }
   const propagate = (error, origin) => {
     recordExceptionOrigin(error, sourceTarget(origin), { reset: true })
     for (let scope = currentScope(); scope !== undefined; scope = scope.parent) {
@@ -218,6 +231,7 @@ export function createNativeCallAdapter({ realmFunction, intrinsicEval, reflect,
   return {
     install,
     exposedValue,
+    exposedMemberValue,
     isEval: callee => callee === state.intrinsicEval || internal.mapHas(selected.exposed, state.intrinsicEval) && callee === internal.mapGet(selected.exposed, state.intrinsicEval),
     evaluate(compiled, environment) {
       // Bootstrap originals never leave this owner. Direct eval must use the

package/internal/failure-reporting.js

@@ -1,15 +1,19 @@
 import { diagnostic } from './diagnostic.js'
-import { AsyncLocalStorage } from 'node:async_hooks'
 import { createHash } from 'node:crypto'
-import { moduleRuntimeIntrinsics as internal } from './compiler-intrinsics.js'
+import { createPrivateAsyncLocalStorage } from './async-local-storage-intrinsics.js'
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
 
+const { Object, RegExp, isArray, numberIsSafeInteger, toNumber, toString,
+  splitString, startsWith, endsWith, sliceString, searchString, replaceString,
+  trimString, regexpExec, prependArray, join, bufferByteLength, bufferIsBuffer,
+  bufferSubarray, bufferToString } = internal
 export const MAX_ERROR_LOG_BYTES = 4 * 1024
 export const FAILURE_HINT_THRESHOLD = 3
 export const LONG_CELL_CODE_UNITS = 2_000
 const BINDING_FAILURE = Symbol('binding failure')
 const PROGRAM_FAILURES = new internal.WeakMap()
 const MAX_CAUSE_CODE_UNITS = 2048
-const exceptionOrigins = new AsyncLocalStorage()
+const exceptionOrigins = createPrivateAsyncLocalStorage()
 const runExceptionScope = exceptionOrigins.run.bind(exceptionOrigins)
 const currentExceptionScope = exceptionOrigins.getStore.bind(exceptionOrigins)
 
@@ -36,14 +40,14 @@ export function recordExceptionOrigin(error, origin, { reset = false, sourceFail
 }
 
 const SOURCE_LINE_BREAK = /\r\n|[\n\r\u2028\u2029]/
-const sourceLines = source => source.split(SOURCE_LINE_BREAK)
+const sourceLines = source => splitString(source, SOURCE_LINE_BREAK)
 
 /** A cell position is a 1-based line and column inside its source. The column
  * may address the position just after the last character of a line. */
 function boundedPosition(position, lines) {
   if (position === null || typeof position !== 'object'
-    || !Number.isSafeInteger(position.line) || position.line < 1
-    || !Number.isSafeInteger(position.column) || position.column < 1
+    || !numberIsSafeInteger(position.line) || position.line < 1
+    || !numberIsSafeInteger(position.column) || position.column < 1
     || position.line > lines.length || position.column > lines[position.line - 1].length + 1) return undefined
   return { line: position.line, column: position.column }
 }
@@ -55,14 +59,15 @@ export function cellPosition(position, source) {
 
 /** Only a fact belonging to the current original source can bypass its map. */
 export function exceptionOriginPosition(origins, source) {
-  if (!Array.isArray(origins)) return undefined
+  if (!isArray(origins)) return undefined
   const prefix = `eval:${createHash('sha256').update(source).digest('hex')}:`
   const lines = sourceLines(source)
-  for (const origin of origins) {
-    if (typeof origin !== 'string' || !origin.startsWith(prefix)) continue
-    const match = /^(\d+):(\d+)$/.exec(origin.slice(prefix.length))
+  for (let index = 0; index < origins.length; index += 1) {
+    const origin = origins[index]
+    if (typeof origin !== 'string' || !startsWith(origin, prefix)) continue
+    const match = regexpExec(/^(\d+):(\d+)$/, sliceString(origin, prefix.length))
     if (match === null) continue
-    const position = boundedPosition({ line: Number(match[1]), column: Number(match[2]) }, lines)
+    const position = boundedPosition({ line: toNumber(match[1]), column: toNumber(match[2]) }, lines)
     if (position !== undefined) return position
   }
   return undefined
@@ -124,7 +129,7 @@ export function messageOf(error, fallback = 'Unprintable error') {
   const message = safeProperty(error, 'message')
   if (typeof message === 'string') return message
   try {
-    return String(error)
+    return toString(error)
   } catch {
     return fallback
   }
@@ -139,20 +144,21 @@ export function processExitDescription(code, signal) {
 
 export function firstLine(value, fallback = undefined) {
   if (typeof value !== 'string') return fallback
-  const line = value.split(/[\r\n]/, 1)[0]
+  const line = splitString(value, /[\r\n]/, 1)[0]
   return line.length > 0 ? line : fallback
 }
 
 export function oneLineMessage(error) {
-  return firstLine(messageOf(error), 'Unknown error').replace(/\s+\(\d+:\d+\)$/, '')
+  return replaceString(firstLine(messageOf(error), 'Unknown error'), /\s+\(\d+:\d+\)$/, '')
 }
 
 /** Return DSH's reported missing-description property path when it is actionable. */
 export function missingDescriptionPath(error) {
-  const violations = messageOf(error).matchAll(/missing required property ["']([^"']+)["']/g)
-  for (const match of violations) {
+  const pattern = /missing required property ["']([^"']+)["']/g
+  const message = messageOf(error)
+  for (let match = regexpExec(pattern, message); match !== null; match = regexpExec(pattern, message)) {
     const path = match[1]
-    if (path === 'description' || path.endsWith('.description')) return path
+    if (path === 'description' || endsWith(path, '.description')) return path
   }
   return undefined
 }
@@ -167,18 +173,18 @@ export function limitLogs(logs) {
   let bytes = 0
   const tail = []
   for (let index = logs.length - 1; index >= 0; index -= 1) {
-    const size = Buffer.byteLength(logs[index], 'utf8') + 1
+    const size = bufferByteLength(logs[index], 'utf8') + 1
     if (bytes + size > MAX_ERROR_LOG_BYTES) break
     bytes += size
-    tail.unshift(logs[index])
+    prependArray(tail, logs[index])
   }
   return tail
 }
 
 /** A frame is only useful when its 1-based line and column are safe integers. */
 function structuralPosition(position) {
-  return Number.isSafeInteger(position.line) && position.line >= 1
-    && Number.isSafeInteger(position.column) && position.column >= 1 ? position : undefined
+  return numberIsSafeInteger(position.line) && position.line >= 1
+    && numberIsSafeInteger(position.column) && position.column >= 1 ? position : undefined
 }
 
 /** Extract the first frame for the active cell. The frame is reported in the
@@ -187,10 +193,10 @@ function structuralPosition(position) {
 export function errorPosition(error, filename, source) {
   const stack = safeProperty(error, 'stack')
   if (typeof stack !== 'string') return undefined
-  const escaped = filename.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-  const match = new RegExp(`${escaped}:(\\d+):(\\d+)`).exec(stack)
+  const escaped = replaceString(filename, /[.*+?^${}()|[\]\\]/g, '\\$&')
+  const match = regexpExec(new RegExp(`${escaped}:(\\d+):(\\d+)`), stack)
   if (match === null) return undefined
-  const position = { line: Number(match[1]), column: Number(match[2]) }
+  const position = { line: toNumber(match[1]), column: toNumber(match[2]) }
   return source === undefined ? structuralPosition(position) : cellPosition(position, source)
 }
 
@@ -206,12 +212,14 @@ export function errorDetails(error, filename, source) {
   const causeMessage = firstLine(safeProperty(candidate, 'message'))
   const causeCode = firstLine(safeProperty(candidate, 'code'))
   const stderr = safeProperty(error, 'stderr')
-  const stderrText = typeof stderr === 'string' ? stderr.slice(0, MAX_CAUSE_CODE_UNITS)
-    : Buffer.isBuffer(stderr) ? stderr.subarray(0, MAX_CAUSE_CODE_UNITS).toString('utf8') : ''
-  const boundedMessage = message.slice(0, MAX_CAUSE_CODE_UNITS)
-  const continuation = boundedMessage.search(/[\r\n]/)
-  const detail = [continuation < 0 ? '' : boundedMessage.slice(continuation + 1), stderrText]
-    .join(' ').slice(0, MAX_CAUSE_CODE_UNITS).replace(/\s+/g, ' ').trim()
+  const stderrText = typeof stderr === 'string' ? sliceString(stderr, 0, MAX_CAUSE_CODE_UNITS)
+    : bufferIsBuffer(stderr)
+      ? bufferToString(bufferSubarray(stderr, 0, MAX_CAUSE_CODE_UNITS), 'utf8') : ''
+  const boundedMessage = sliceString(message, 0, MAX_CAUSE_CODE_UNITS)
+  const continuation = searchString(boundedMessage, /[\r\n]/)
+  const detailParts = [continuation < 0 ? '' : sliceString(boundedMessage, continuation + 1), stderrText]
+  const detail = trimString(replaceString(
+    sliceString(join(detailParts, ' '), 0, MAX_CAUSE_CODE_UNITS), /\s+/g, ' '))
   const cause = causeMessage === undefined
     ? detail.length === 0 ? undefined : { message: detail }
     : {

package/internal/isolated-worker.js

@@ -3,6 +3,7 @@ import { EventEmitter } from 'node:events'
 import { resolve } from 'node:path'
 import { PassThrough } from 'node:stream'
 import { pathToFileURL } from 'node:url'
+import { helperProcessEnvironment, isElectronHost } from './worker-environment.js'
 
 /**
  * Fallback bound for a helper that answers the stop request and then keeps the
@@ -43,6 +44,7 @@ export class IsolatedWorker extends EventEmitter {
     this.stderr = new PassThrough()
     this.protocol = protocol
     this.exited = false
+    this.exitedPromise = new Promise(resolve => { this.resolveExited = resolve })
     this.exitCode = undefined
     this.exitSignal = undefined
     this.released = false
@@ -63,12 +65,15 @@ export class IsolatedWorker extends EventEmitter {
     }
     // child_process.fork mutates the env object it receives by copying
     // NODE_V8_COVERAGE into it. Snapshot the caller's projection first so the
-    // inner Worker receives exactly the projected user environment, while the
-    // helper process can still carry the host's coverage variable.
-    const workerEnvironment = env === undefined ? undefined : { ...env }
+    // inner Worker receives exactly the projected user environment. An Electron
+    // Host also needs a helper-only startup override; it must not reach user code.
+    const electronHost = isElectronHost()
+    const projectedEnvironment = env === undefined && electronHost ? process.env : env
+    const workerEnvironment = projectedEnvironment === undefined ? undefined : { ...projectedEnvironment }
+    const forkEnvironment = helperProcessEnvironment(projectedEnvironment, process.platform, electronHost)
     this.child = fork(helper, [], {
       stdio: ['ignore', 'pipe', 'pipe', 'ipc'],
-      env,
+      env: forkEnvironment,
       serialization: 'advanced',
       // The helper starts with the host's own startup arguments removed, matching
       // the isolation the in-host worker had with execArgv: [].
@@ -80,6 +85,7 @@ export class IsolatedWorker extends EventEmitter {
       this.exited = true
       this.exitCode = code
       this.exitSignal = signal
+      this.resolveExited()
       this.#rejectUtilizationRequests(new Error('kernel helper exited before answering utilization sampling'))
     })
     // A ChildProcess 'close' follows 'exit' once its stdio has really ended, which
@@ -264,7 +270,7 @@ export class IsolatedWorker extends EventEmitter {
     const started = Date.now()
     const killAt = started + ISOLATED_RELEASE_MS
     const confirmBy = started + ISOLATED_STOP_MS
-    const exited = new Promise(resolve => { this.child.once('exit', resolve) })
+    const exited = this.exitedPromise
     const onReleased = message => {
       if (message?.type === 'worker-message' && message.value?.type === 'shutdown-released') this.released = true
     }
@@ -278,18 +284,19 @@ export class IsolatedWorker extends EventEmitter {
         // The channel is closed; the kill path below owns the instance.
       }
       if (!await leftWithin(this, remaining(killAt))) {
+        let killFailure
         if (!this.exited) {
           try {
             await this.kill()
           } catch (error) {
-            // Reclamation failed: keep the failure observable on the transport so
-            // the owner can retain responsibility for this instance.
-            this.reclamationFailure = error
-            throw error
+            // On Windows a process that has already left can report a refused
+            // kill before Node delivers its exit event. The real exit observation
+            // decides whether this instance was reclaimed.
+            killFailure = error
           }
         }
         if (!this.exited && !await leftWithin(this, remaining(confirmBy))) {
-          const failure = new Error('kernel helper did not exit before the close deadline')
+          const failure = killFailure ?? new Error('kernel helper did not exit before the close deadline')
           this.reclamationFailure = failure
           throw failure
         }