dsh-ptc-plus 0.4.1 → 0.4.2

package/internal/user-binding-console-worker.js

@@ -1,5 +1,5 @@
-import { AsyncLocalStorage } from 'node:async_hooks'
 import { randomUUID } from 'node:crypto'
+import { createPrivateAsyncLocalStorage } from './async-local-storage-intrinsics.js'
 import { create as createDomain } from 'node:domain'
 import { createRequire, registerHooks } from 'node:module'
 import { resolve } from 'node:path'
@@ -8,7 +8,6 @@ import { PassThrough } from 'node:stream'
 import { inspect } from 'node:util'
 import { pathToFileURL } from 'node:url'
 import { parentPort, workerData } from 'node:worker_threads'
-import { runInContext } from 'node:vm'
 import { prepareConsoleProgram } from './compiler-service.js'
 import { createStatefulRootRuntime } from './stateful-root-runtime.js'
 import { managedModuleImport, managedRequire, readModuleImport } from './stateful-module-runtime.js'
@@ -18,21 +17,24 @@ import { moduleRuntimeIntrinsics } from './compiler-intrinsics.js'
 import { stringifyCompilerData } from './compiler-data.js'
 import { createCellCompletionObserver } from './cell-completion.js'
 import { WORKER_SHUTDOWN_ACKNOWLEDGEMENT, WORKER_SHUTDOWN_REQUEST } from './worker-shutdown.js'
+import { WORKER_REPL_OPTIONS, createWorkerControlPromise, createWorkerReplErrorHandler,
+  disableWorkerReplDomain,
+  captureWorkerReplGlobals, protectWorkerReplAsyncContext, restoreWorkerReplGlobals, runInWorkerReplRealm,
+  workerReplContext } from './worker-repl-realm.js'
 
 const { Object, Set, setHas, setAdd, setDelete, appendArray } = moduleRuntimeIntrinsics
+const Promise = globalThis.Promise
+const process = globalThis.process
+const hasProperty = globalThis.Reflect.has
+const ControlPromise = createWorkerControlPromise()
 
-const input = new PassThrough()
-const output = new PassThrough()
-output.resume()
-const evaluations = new AsyncLocalStorage()
-const server = repl.start({ input, output, terminal: false, prompt: '', useGlobal: false })
-const completionObserver = createCellCompletionObserver(runInContext('Function', server.context))
-server.context.console = console
-const errorDomain = server.eval.domain ?? createDomain()
-errorDomain.removeAllListeners('error')
-errorDomain.on('error', error => evaluations.getStore()?.finish(true, error))
+const evaluations = createPrivateAsyncLocalStorage()
+const context = globalThis
+const completionObserver = createCellCompletionObserver(runInWorkerReplRealm('Function'))
+context.console = console
+let retainedEvaluator
 const completionKey = `__ptc_console_${randomUUID().replaceAll('-', '')}`
-Object.defineProperty(server.context, completionKey, { value: value => {
+Object.defineProperty(context, completionKey, { value: value => {
   evaluations.getStore().completed = true
   return value
 } })
@@ -44,16 +46,16 @@ const adapterParents = new Set()
 const knownBindings = new Set()
 const roots = createStatefulRootRuntime({
   importModule: (source, options) => managedModuleImport(replParent, source, options, replModuleRealm),
-  errors: runInContext('({ ReferenceError, TypeError })', server.context),
-  dynamicIntrinsics: runInContext('({intrinsicEval:eval,realmFunction:Function,globalObject:globalThis,errors:{ReferenceError,TypeError,SyntaxError},reflect:Reflect,object:Object})', server.context),
-  readAmbient: name => runInContext(name, server.context),
-  typeofAmbient: name => runInContext(`typeof ${name}`, server.context),
+  errors: runInWorkerReplRealm('({ ReferenceError, TypeError })'),
+  dynamicIntrinsics: runInWorkerReplRealm('({intrinsicEval:eval,realmFunction:Function,globalObject:globalThis,errors:{ReferenceError,TypeError,SyntaxError},reflect:Reflect,object:Object})'),
+  readAmbient: name => runInWorkerReplRealm(name),
+  typeofAmbient: name => runInWorkerReplRealm(`typeof ${name}`),
   writeAmbient(name, value, strict) {
     const argument = name === '__ptc_value' ? '__ptc_other_value' : '__ptc_value'
-    runInContext(`${strict ? '"use strict";' : ''}(${argument}) => (${name} = ${argument})`, server.context)(value)
+    runInWorkerReplRealm(`${strict ? '"use strict";' : ''}(${argument}) => (${name} = ${argument})`)(value)
   },
-  deleteAmbient: name => runInContext(`delete ${name}`, server.context),
-  hasAmbient: name => Reflect.has(server.context, name),
+  deleteAmbient: name => runInWorkerReplRealm(`delete ${name}`),
+  hasAmbient: name => hasProperty(context, name),
   publish: name => setAdd(knownBindings, name),
 })
 class ConsoleReturn {
@@ -62,7 +64,8 @@ class ConsoleReturn {
 const moduleCompilation = createUserModuleCompilationHooks({
   transformForParent: parent => parent === replParent || parent === parentUrl ? USER_BINDING_TRANSFORM : undefined,
 })
-server.context.require = managedRequire(parentUrl, createRequire(parentUrl))
+const providedRequire = managedRequire(parentUrl, createRequire(parentUrl))
+Object.defineProperty(context, 'require', { configurable: true, value: providedRequire })
 const importCanary = 'data:text/javascript,export default 1'
 registerHooks({ resolve(specifier, context, nextResolve) {
   if (specifier === importCanary) replParent = context.parentURL
@@ -74,14 +77,34 @@ const describe = value => inspect(value, {
   colors: false, customInspect: false, getters: false, depth: 4,
   maxArrayLength: 40, maxStringLength: Math.min(workerData.maxOutputBytes, 8192), breakLength: 100,
 })
+process.on('uncaughtException', error => {
+  const state = evaluations.getStore()
+  if (state?.finish(true, error) === true || state?.settled === true) return
+  parentPort.postMessage({ fatal: true, error: describe(error) })
+})
 
-async function evaluate(source) {
+function evaluate(source) {
   const prepared = prepareConsoleProgram(source, { languageSemantics: 'stateful-v1', knownBindings })
   const helpers = [prepared.rootRuntimeName, prepared.returnSignal]
-  Object.defineProperty(server.context, prepared.rootRuntimeName, {
+  Object.defineProperty(context, prepared.rootRuntimeName, {
     configurable: true, value: roots.begin({ ...prepared.rootBindings, committed: () => {} }),
   })
-  Object.defineProperty(server.context, prepared.returnSignal, { configurable: true, value: ConsoleReturn })
+  Object.defineProperty(context, prepared.returnSignal, { configurable: true, value: ConsoleReturn })
+  if (prepared.moduleLoads.length === 0) {
+    const operation = evaluatePrepared(prepared.code, prepared.asyncCompletion)
+    return new ControlPromise((resolve, reject) => operation.then(
+      value => { removeHelpers(helpers); resolve(value) },
+      error => { removeHelpers(helpers); reject(error) },
+    ))
+  }
+  return evaluateWithModules(prepared, helpers)
+}
+
+function removeHelpers(helpers) {
+  for (let index = 0; index < helpers.length; index++) delete context[helpers[index]]
+}
+
+async function evaluateWithModules(prepared, helpers) {
   try {
     for (let index = 0; index < prepared.moduleLoads.length; index++) {
       const load = prepared.moduleLoads[index]
@@ -109,30 +132,48 @@ async function evaluate(source) {
       } finally { setDelete(adapterParents, adapter) }
       if (load.global !== undefined) {
         appendArray(helpers, load.global)
-        Object.defineProperty(server.context, load.global, { configurable: true, value: namespace })
+        Object.defineProperty(context, load.global, { configurable: true, value: namespace })
       }
     }
     return await evaluatePrepared(prepared.code, prepared.asyncCompletion)
   } finally {
-    for (let index = 0; index < helpers.length; index++) delete server.context[helpers[index]]
+    removeHelpers(helpers)
   }
 }
 
 function evaluatePrepared(javascript, asyncCompletion = false) {
-  return new Promise((resolve, reject) => {
+  releaseRetainedEvaluator()
+  const input = new PassThrough()
+  const output = new PassThrough()
+  output.resume()
+  const workerGlobalBaseline = captureWorkerReplGlobals(context)
+  const server = repl.start({ input, output, terminal: false, prompt: '', ...WORKER_REPL_OPTIONS,
+    handleError: createWorkerReplErrorHandler(evaluations, (state, error) => state.finish(true, error)) })
+  protectWorkerReplAsyncContext(server)
+  workerReplContext(server)
+  restoreWorkerReplGlobals(workerGlobalBaseline, context)
+  Object.defineProperty(context, 'require', { configurable: true, value: providedRequire })
+  const errorDomain = disableWorkerReplDomain(server.eval.domain ?? createDomain())
+  const evaluator = { server, input, output, errorDomain }
+  retainedEvaluator = evaluator
+  return new ControlPromise((resolve, reject) => {
     const complete = `this[${stringifyCompilerData(completionKey)}]`
     // Preserve expression results while distinguishing rejection with null/undefined.
     const code = `${javascript}\n;{let completed = ${complete}();}\n;`
     let settled = false
     const state = { completed: false, finish(failed, value) {
-      if (settled) return
+      if (settled) return false
       settled = true
+      state.settled = true
       if (failed && value instanceof ConsoleReturn) completionObserver.settle(value.value, resolve, reject)
       else if (failed) reject(value)
       else completionObserver.settle(value, resolve, reject)
+      return true
     } }
+    evaluator.state = state
+    errorDomain.on('error', error => state.finish(true, error))
     evaluations.run(state, () => errorDomain.run(() => {
-      server.eval(`${code}\n`, server.context, 'ptc-plus-console', (error, value) => {
+      server.eval(`${code}\n`, context, 'ptc-plus-console', (error, value) => {
         if (asyncCompletion && (error === null || error === undefined)) {
           completionObserver.observe(value, value => state.finish(false, value), error => state.finish(true, error))
           return
@@ -143,6 +184,16 @@ function evaluatePrepared(javascript, asyncCompletion = false) {
     }))
   })
 }
+
+function releaseRetainedEvaluator() {
+  const evaluator = retainedEvaluator
+  if (evaluator === undefined) return undefined
+  retainedEvaluator = undefined
+  evaluator.errorDomain.removeAllListeners('error')
+  evaluator.server.close()
+  evaluator.input.destroy()
+  evaluator.output.destroy()
+}
 try {
   replModuleRealm = await evaluatePrepared('({Promise,stringify:value=>`${value}`,importModule:(source,options)=>import(source,options)})')
   const prepared = compileStatefulModule(workerData.source)
@@ -154,30 +205,39 @@ try {
   for (let index = 0; index < names.length; index++) {
     const name = names[index]
     setAdd(knownBindings, name)
-    Object.defineProperty(server.context, name, { configurable: true, enumerable: true, get: () => namespace[name] })
+    Object.defineProperty(context, name, { configurable: true, enumerable: true, get: () => namespace[name] })
   }
-  parentPort.on('message', async (message) => {
+  parentPort.on('message', (message) => {
     if (message?.type === WORKER_SHUTDOWN_REQUEST) {
       // Release the realm, REPL and domain this console owns, then report the
       // release before the host gives up on the thread; see worker-shutdown.js.
-      server.close()
-      input.destroy()
-      output.destroy()
-      errorDomain.removeAllListeners('error')
+      releaseRetainedEvaluator()
       parentPort.postMessage({ type: WORKER_SHUTDOWN_ACKNOWLEDGEMENT })
       parentPort.close()
       return
     }
     const { id, code } = message
-    let result
+    const send = result => {
+      const flushed = new ControlPromise(resolve => process.stdout.write('', () => process.stderr.write('', resolve)))
+      moduleRuntimeIntrinsics.observeOwnedPromise(flushed, () => {
+        parentPort.postMessage(result)
+        releaseRetainedEvaluator()
+      /* c8 ignore next 3 -- flushed has no reject capability */
+      }, error => {
+        releaseRetainedEvaluator()
+        parentPort.postMessage({ id, error: describe(error) })
+      })
+    }
+    let operation
     try {
-      const value = await evaluate(code)
-      result = { id, output: describe(value) }
+      operation = evaluate(code)
     } catch (error) {
-      result = { id, error: describe(error) }
+      send({ id, error: describe(error) })
+      return
     }
-    await new Promise(resolve => process.stdout.write('', () => process.stderr.write('', resolve)))
-    parentPort.postMessage(result)
+    moduleRuntimeIntrinsics.observeOwnedPromise(operation,
+      value => send({ id, output: describe(value) }),
+      error => send({ id, error: describe(error) }))
   })
 } catch (error) {
   parentPort.postMessage({ fatal: true, error: describe(error) })

package/internal/user-bindings.js

@@ -62,11 +62,19 @@ function selectedDescriptors(source, symbols, transform) {
 
 
 function declarationFor(entry, descriptors) {
+  const typeNamespace = `__ptcBinding_${createHash('sha256').update(entry.id).digest('hex').slice(0, 12)}`
+  const typeNamespaceTokens = new Set(descriptors.map(item => item.typeNamespaceToken))
+  if (typeNamespaceTokens.size !== 1 || typeNamespaceTokens.has(undefined)) throw new TypeError('binding symbols do not share one compiler type namespace')
+  const [typeNamespaceToken] = typeNamespaceTokens
+  const render = text => text.replaceAll(typeNamespaceToken, typeNamespace)
+  const typeDeclarations = [...new Set(descriptors.flatMap(item => item.typeDeclarations ?? []))]
+  const typePrefix = typeDeclarations.length === 0 ? '' : `declare namespace ${typeNamespace} {\n${typeDeclarations
+    .map(item => render(item).split('\n').map(line => `  ${line}`).join('\n')).join('\n')}\n}\n`
   const comment = entry.purpose === '' ? '' : `/** ${entry.purpose.replaceAll('*/', '* /')} */\n`
   if (entry.scope === 'namespace') {
-    return `${comment}declare const ${entry.name}: {\n${descriptors.map(item => `  ${item.member};`).join('\n')}\n}`
+    return `${typePrefix}${comment}declare const ${entry.name}: {\n${descriptors.map(item => `  ${render(item.member)};`).join('\n')}\n}`
   }
-  return descriptors.map((item, index) => `${index === 0 ? comment : ''}declare ${item.declaration}`).join('\n')
+  return `${typePrefix}${descriptors.map((item, index) => `${index === 0 ? comment : ''}declare ${render(item.declaration)}`).join('\n')}`
 }
 
 export function normalizeUserBindingEntry(value, { transform = USER_BINDING_TRANSFORM } = {}) {