dsh-ptc-plus 0.4.2 → 0.4.8

package/internal/repl-scope-normalizer.js

@@ -23,7 +23,7 @@ import { supportsNativeUsing, transformTypeScriptSource } from './typescript-tra
 import { createDynamicScopeAnalysis, varInitializerTarget } from './dynamic-scope-analysis.js'
 import { visitSource } from './compiler-source-regions.js'
 import { analyzeSourceDeclarations, resolveSourceBinding, COMMONJS_PARAMETERS } from './compiler-scope-facts.js'
-import { callableMarkerPosition } from './callable-source-facts.js'
+import { callableMarkerPosition, restoreMappedCallableSourceMarks } from './callable-source-facts.js'
 import { createSourcePieces } from './compiler-source-pieces.js'
 import { indexSourceRegions, validateRegionSource, sourceFeatures } from './compiler-region-output.js'
 
@@ -424,7 +424,7 @@ export function lowerStatefulDecorators(result, target, intrinsicContext) {
 
 /** Erase type-only declarations and lower runtime TypeScript values before
  * logical ownership and module export/link plans consume the source. */
-export function normalizeTypeScriptValues(code, sourceMap, target) {
+export function normalizeTypeScriptValues(code, sourceMap, target, callableSources) {
   const tree=parse(code,{...parserOptionsForTarget(target),errorRecovery:true})
   let parameterProperties = false
   let tokens
@@ -521,20 +521,15 @@ export function normalizeTypeScriptValues(code, sourceMap, target) {
       if(enumEdits.length>0) source=applySourceEdits(source,identitySourceMap(source.length),enumEdits).code
       const transformed=transformTypeScriptSource(source,{module:target!=='commonjs',sourceMap:true,
         transform:{tsEnumIsMutable:true,noEmptyExport:true}})
-      const nativeMap=new SourceMap(JSON.parse(transformed.map))
-      const starts=[0]
-      for(let index=0;index<source.length;index++) if(source[index]==='\n') starts.push(index+1)
-      const mappings=[]
-      let line=1,column=1
-      for(let index=0;index<transformed.code.length;index++) {
-        const origin=nativeMap.findOrigin(line,column)
-        const start=Math.min(source.length,Math.max(0,(starts[origin.lineNumber-1]??0)+(origin.columnNumber??1)-1))
-        mappings.push({generatedStart:index,generatedEnd:index+1,originalStart:path.node.start+start,
-          originalEnd:Math.min(owner.end,path.node.start+start+1)})
-        if(transformed.code[index]==='\n'){line++;column=1}else column++
-      }
-      const exported=owner!==path.node&&transformed.code.trim()!==''?`\nexport {${path.node.id.name}};`:''
-      edits.push({start:owner.start,end:owner.end,text:transformed.code+exported,mappings})
+      let mapped=mappedSourceTransform(source,identitySourceMap(source.length),transformed)
+      mapped=restoreMappedCallableSourceMarks(mapped,source,transformed,callableSources,parserOptionsForTarget(target))
+      const mappings=[...mapped.sourceMap].map(mapping=>({
+        ...mapping,
+        originalStart:path.node.start+mapping.originalStart,
+        originalEnd:Math.min(owner.end,path.node.start+mapping.originalEnd),
+      }))
+      const exported=owner!==path.node&&mapped.code.trim()!==''?`\nexport {${path.node.id.name}};`:''
+      edits.push({start:owner.start,end:owner.end,text:mapped.code+exported,mappings})
       path.skip()
     },
   })
@@ -1130,23 +1125,46 @@ export function preserveStatementBoundaries(code, sourceMap = identitySourceMap(
  * The root compiler owns Program bindings and calls this pass after lowering
  * those declarations. protected-v1 keeps native local binding policy.
  */
+const normalizationFailureInputs = new WeakMap()
+
+function retainNormalizationFailureInput(error, input) {
+  if ((typeof error === 'object' && error !== null) || typeof error === 'function') {
+    if (!normalizationFailureInputs.has(error)) normalizationFailureInputs.set(error, input)
+  }
+}
+
+/** Latest mapped normalization stage established before an error was thrown. */
+export function normalizationFailureInput(error) {
+  return (typeof error === 'object' && error !== null) || typeof error === 'function'
+    ? normalizationFailureInputs.get(error) : undefined
+}
+
 export function normalizeStatefulScopes(code, sourceMap = identitySourceMap(code.length), options = {}) {
-  const { outputPlan, ...metadata } = normalizeStatefulScopeInput(code, sourceMap, options)
-  let result = metadata
-  if (outputPlan) {
-    // Release declaration ASTs and scope ancestry before materializing the
-    // expanded output. This phase retains only numeric pieces and source facts.
-    const { pieces, root, code, sourceMap, regionFacts } = outputPlan
-    options.onPhase?.('mapping')
-    const output = pieces.emit(root)
-    result = { ...metadata, ...applySourceEdits(code, sourceMap,
-      [{ start: 0, end: code.length, ...output }]),
-    sourceRegions: { ...regionFacts, regions: output.regions } }
+  let diagnosticInput = { code, sourceMap }
+  try {
+    const { outputPlan, ...metadata } = normalizeStatefulScopeInput(code, sourceMap, options)
+    let result = metadata
+    if (outputPlan) {
+      // Release declaration ASTs and scope ancestry before materializing the
+      // expanded output. This phase retains only numeric pieces and source facts.
+      const { pieces, root, code, sourceMap, regionFacts } = outputPlan
+      diagnosticInput = { code, sourceMap }
+      options.onPhase?.('mapping')
+      const output = pieces.emit(root)
+      result = { ...metadata, ...applySourceEdits(code, sourceMap,
+        [{ start: 0, end: code.length, ...output }]),
+      sourceRegions: { ...regionFacts, regions: output.regions } }
+    }
+    diagnosticInput = result
+    options.onPhase?.('validation')
+    if (options.target === 'module' || options.target === 'commonjs') validateRegionSource(result, parserOptionsForTarget(options.target))
+    result = options.deferDecorators ? result : lowerStatefulDecorators(result, options.target, options.intrinsicContext)
+    diagnosticInput = result
+    return options.deferResources ? result : lowerStatefulResources(result, options)
+  } catch (error) {
+    retainNormalizationFailureInput(error, diagnosticInput)
+    throw error
   }
-  options.onPhase?.('validation')
-  if (options.target === 'module' || options.target === 'commonjs') validateRegionSource(result, parserOptionsForTarget(options.target))
-  result = options.deferDecorators ? result : lowerStatefulDecorators(result, options.target, options.intrinsicContext)
-  return options.deferResources ? result : lowerStatefulResources(result, options)
 }
 
 /** Resource lifetime is lowered only after declaration owners have consumed
@@ -1227,15 +1245,33 @@ export function hasModuleResources(code) {
     node.type === 'VariableDeclaration' && (node.kind === 'using' || node.kind === 'await using'))
 }
 
-function normalizeStatefulScopeInput(code, sourceMap, { mode = 'stateful-v1', target, moduleImport, intrinsicContext, onPhase,
-  nativeJavaScript = false, nativeUsing = supportsNativeUsing() } = {}) {
+function normalizeStatefulScopeInput(code, sourceMap, options) {
+  let diagnosticInput = { code, sourceMap }
+  try {
+    return normalizeStatefulScopeInputUnchecked(code, sourceMap, options, input => { diagnosticInput = input })
+  } catch (error) {
+    retainNormalizationFailureInput(error, diagnosticInput)
+    throw error
+  }
+}
+
+function normalizeStatefulScopeInputUnchecked(code, sourceMap, { mode = 'stateful-v1', target, moduleImport, intrinsicContext, onPhase,
+  callableSources, nativeJavaScript = false, nativeUsing = supportsNativeUsing() } = {}, updateDiagnosticInput) {
   if (mode !== 'stateful-v1' && mode !== 'protected-v1') throw new TypeError('ptc-plus: unsupported scope semantics')
   onPhase?.('typescript')
-  const typescript = nativeJavaScript ? { code, sourceMap }
-    : lowerLegacyParameterDecorators(normalizeTypeScriptValues(code,sourceMap,target),target,intrinsicContext)
+  let typescript
+  if (nativeJavaScript) {
+    typescript = { code, sourceMap }
+  } else {
+    const normalizedTypescript = normalizeTypeScriptValues(code,sourceMap,target,callableSources)
+    updateDiagnosticInput(normalizedTypescript)
+    typescript = lowerLegacyParameterDecorators(normalizedTypescript,target,intrinsicContext)
+  }
+  updateDiagnosticInput(typescript)
   const separated = preserveStatementBoundaries(typescript.code, typescript.sourceMap, parserOptionsForTarget(target))
   code=separated.code
   sourceMap=separated.sourceMap
+  updateDiagnosticInput(separated)
   const finish = result => {
     result = { ...result, deferredHelpers: typescript.deferredHelpers,
       internalBindings: new Set([...typescript.internalBindings ?? [], ...result.internalBindings ?? []]) }
@@ -1269,6 +1305,7 @@ function normalizeStatefulScopeInput(code, sourceMap, { mode = 'stateful-v1', ta
   const annex = introduceAnnexBVars(code, sourceMap, target, onPhase)
   code = annex.code
   sourceMap = annex.sourceMap
+  updateDiagnosticInput(annex)
   onPhase?.('facts')
   const facts = analyzeLogicalScopes(code, { target, compact: true, compactNames: target === 'module' || target === 'commonjs', onPhase })
   onPhase?.('planning')

package/internal/repl-value-observer.js

@@ -1,116 +1,212 @@
 import { types } from 'node:util'
-import { isContext, runInContext, runInThisContext } from 'node:vm'
-import { parse } from 'acorn'
+import { readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { createContext, isContext, runInContext, runInThisContext } from 'node:vm'
 import { randomUUID } from 'node:crypto'
-import { walkAst, SKIP_AST_CHILDREN } from './ast-traversal.js'
-import { bindingNodes } from './binding-pattern-traversal.js'
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
+import { deleteWorkerRealmProperty, WORKER_REALM_MUTATION } from './worker-realm-surfaces.js'
 
 const MAX_ENTRIES = 128
 const MAX_TEXT = 512
 const MAX_PROPERTIES = 5
-const ownDescriptor = Object.getOwnPropertyDescriptor
-const isArray = Array.isArray
 const isProxy = types.isProxy
-const stringify = JSON.stringify
 const now = Date.now
-const bigintText = BigInt.prototype.toString
 const BIGINT_LIMIT = 10n ** 128n
+const IDENTIFIER = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u
+const AST_METADATA_KEYS = new internal.Set(['start', 'end', 'loc', 'range'])
+const {
+  Set: PrivateSet,
+  appendArray,
+  bigintToString,
+  isArray,
+  jsonStringify,
+  min,
+  objectCreate,
+  objectGetOwnPropertyDescriptor: ownDescriptor,
+  objectHasOwn,
+  objectIs,
+  objectKeys,
+  regexpTest,
+  replaceAllString,
+  setAdd,
+  setHas,
+  sliceString,
+  toString,
+} = internal
 const unreadable = () => ({ status: 'unreadable', text: '', truncated: false })
 const runInRealm = (source, context, options) => isContext(context)
   ? runInContext(source, context, options)
   : runInThisContext(source, options)
 
+function createPrivateParser() {
+  const require = createRequire(import.meta.url)
+  const exports = objectCreate(null)
+  const module = objectCreate(null)
+  module.exports = exports
+  const context = createContext({ exports, module })
+  runInContext(readFileSync(require.resolve('acorn'), 'utf8'), context,
+    { filename: require.resolve('acorn') })
+  return module.exports.parse
+}
+
+const parse = createPrivateParser()
+
+function parseProgram(program) {
+  const options = objectCreate(null)
+  options.ecmaVersion = 'latest'
+  options.allowAwaitOutsideFunction = true
+  return parse(program, options)
+}
+
+function containsAwait(node) {
+  if (node === null || typeof node !== 'object') return false
+  if (node.type === 'FunctionDeclaration' || node.type === 'FunctionExpression'
+    || node.type === 'ArrowFunctionExpression') return false
+  if (node.type === 'AwaitExpression' || node.await === true) return true
+  const keys = objectKeys(node)
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index]
+    if (setHas(AST_METADATA_KEYS, key)) continue
+    const value = node[key]
+    if (isArray(value)) {
+      for (let child = 0; child < value.length; child += 1) {
+        if (containsAwait(value[child])) return true
+      }
+    } else if (containsAwait(value)) return true
+  }
+  return false
+}
+
+function recordBindingNames(pattern, names) {
+  if (pattern === null || typeof pattern !== 'object') return
+  if (pattern.type === 'Identifier') {
+    setAdd(names, pattern.name)
+    return
+  }
+  if (pattern.type === 'RestElement') return recordBindingNames(pattern.argument, names)
+  if (pattern.type === 'AssignmentPattern') return recordBindingNames(pattern.left, names)
+  if (pattern.type === 'ArrayPattern') {
+    for (let index = 0; index < pattern.elements.length; index += 1) {
+      recordBindingNames(pattern.elements[index], names)
+    }
+    return
+  }
+  if (pattern.type === 'ObjectPattern') {
+    for (let index = 0; index < pattern.properties.length; index += 1) {
+      const property = pattern.properties[index]
+      recordBindingNames(property.type === 'RestElement' ? property.argument : property.value, names)
+    }
+  }
+}
+
 function primitiveText(value) {
-  if (typeof value === 'string') return stringify(value.slice(0, MAX_TEXT))
+  if (typeof value === 'string') return jsonStringify(sliceString(value, 0, MAX_TEXT))
   if (typeof value === 'bigint') return value > -BIGINT_LIMIT && value < BIGINT_LIMIT
-    ? `${bigintText.call(value)}n` : '[bigint: more than 128 digits]'
+    ? `${bigintToString(value)}n` : '[bigint: more than 128 digits]'
   if (typeof value === 'symbol' || typeof value === 'function') return `[${typeof value}: unreadable]`
   if (value === null) return 'null'
   if (typeof value === 'object') return isProxy(value) ? '[proxy: unreadable]' : '[object]'
-  return Object.is(value, -0) ? '-0' : String(value)
+  return objectIs(value, -0) ? '-0' : toString(value)
 }
 
 /** Inspect own descriptors only, rejecting proxies before any reflective operation. */
 export function previewBindingValue(value) {
-  if (['function', 'symbol'].includes(typeof value)) return unreadable()
+  if (typeof value === 'function' || typeof value === 'symbol') return unreadable()
   if (value === null || typeof value !== 'object') {
     const text = primitiveText(value)
-    return { status: 'readable', text: text.slice(0, MAX_TEXT), truncated: text.length > MAX_TEXT
+    return { status: 'readable', text: sliceString(text, 0, MAX_TEXT), truncated: text.length > MAX_TEXT
       || (typeof value === 'bigint' && (value <= -BIGINT_LIMIT || value >= BIGINT_LIMIT)) }
   }
   // Only arrays provide a finite slot range without enumerating the whole object.
   if (isProxy(value) || !isArray(value)) return unreadable()
-  const keys = Array.from({ length: Math.min(ownDescriptor(value, 'length').value, MAX_PROPERTIES) }, (_value, index) => String(index))
-  const properties = keys.map(key => {
+  const keys = []
+  const length = min(ownDescriptor(value, 'length').value, MAX_PROPERTIES)
+  for (let index = 0; index < length; index += 1) appendArray(keys, toString(index))
+  const properties = []
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index]
     const descriptor = ownDescriptor(value, key)
     const text = descriptor === undefined ? '[empty]'
-      : Object.hasOwn(descriptor, 'value') ? primitiveText(descriptor.value) : '[accessor: unreadable]'
-    return `${stringify(key)}: ${text}`
-  })
-  const text = `array { ${properties.join(', ')} }`
+      : objectHasOwn(descriptor, 'value') ? primitiveText(descriptor.value) : '[accessor: unreadable]'
+    appendArray(properties, `${jsonStringify(key)}: ${text}`)
+  }
+  let text = 'array { '
+  for (let index = 0; index < properties.length; index += 1) {
+    if (index > 0) text += ', '
+    text += properties[index]
+  }
+  text += ' }'
   // Uninspected own properties remain unknown even when all indexed slots fit.
-  return { status: 'readable', text: text.slice(0, MAX_TEXT), truncated: true }
+  return { status: 'readable', text: sliceString(text, 0, MAX_TEXT), truncated: true }
 }
 
 /** Probe the actual evaluator without consulting a Node version or any session value. */
 export async function supportsAwaitLexicals(context, evaluate) {
-  const prefix = `__ptc_observation_${randomUUID().replaceAll('-', '')}`
+  const prefix = `__ptc_observation_${replaceAllString(randomUUID(), '-', '')}`
   const names = [`${prefix}_let`, `${prefix}_const`]
   try {
     await evaluate(`let ${names[0]} = await Promise.resolve(41); const ${names[1]} = 42;`)
-    return names.every((name, index) => ownDescriptor(context, name) === undefined
-      && runInRealm(name, context, { timeout: 25 }) === index + 41)
+    for (let index = 0; index < names.length; index += 1) {
+      if (ownDescriptor(context, names[index]) !== undefined
+        || runInRealm(names[index], context, { timeout: 25 }) !== index + 41) return false
+    }
+    return true
   } catch {
     return false
   } finally {
     // Lexical probe names are private and never enter the binding inventory.
-    for (const name of names) delete context[name]
+    for (let index = 0; index < names.length; index += 1) {
+      deleteWorkerRealmProperty(
+        WORKER_REALM_MUTATION.RESTORE,
+        'await lexical probe',
+        context,
+        names[index],
+      )
+    }
   }
 }
 
 /** Successful programs prove storage; await lexical reads additionally require a runtime probe. */
 export function createReplValueObserver(context, { awaitLexicals = false } = {}) {
-  const lexicals = new Set()
-  const globals = new Set()
+  const lexicals = new PrivateSet()
+  const globals = new PrivateSet()
   return {
     record(program) {
       try {
-        const tree = parse(program, { ecmaVersion: 'latest', allowAwaitOutsideFunction: true })
-        let awaits = false
-        walkAst(tree, node => {
-          if (['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'].includes(node.type)) return SKIP_AST_CHILDREN
-          if (node.type === 'AwaitExpression' || node.await === true) awaits = true
-        })
-        if (awaits && !awaitLexicals) return
-        for (const statement of tree.body) {
+        const tree = parseProgram(program)
+        if (containsAwait(tree) && !awaitLexicals) return
+        for (let statementIndex = 0; statementIndex < tree.body.length; statementIndex += 1) {
+          const statement = tree.body[statementIndex]
           if (statement.type !== 'VariableDeclaration') continue
-          for (const declaration of statement.declarations) {
-            for (const binding of bindingNodes(declaration.id)) {
-              (statement.kind === 'var' ? globals : lexicals).add(binding.name)
-            }
+          const names = statement.kind === 'var' ? globals : lexicals
+          for (let index = 0; index < statement.declarations.length; index += 1) {
+            recordBindingNames(statement.declarations[index].id, names)
           }
         }
       } catch {}
     },
     observe(names) {
       const at = now()
-      const entries = names.slice(0, MAX_ENTRIES).map(name => {
+      const entries = []
+      const length = min(names.length, MAX_ENTRIES)
+      for (let index = 0; index < length; index += 1) {
+        const name = names[index]
         let preview = unreadable()
         try {
-          if (lexicals.has(name)) {
+          if (setHas(lexicals, name)) {
             // Lexical storage shadows global properties, even while uninitialized.
-            if (/^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u.test(name) && now() - at < 100) {
+            if (regexpTest(IDENTIFIER, name) && now() - at < 100) {
               preview = previewBindingValue(runInRealm(name, context, { timeout: 25, displayErrors: false }))
             }
-          } else if (globals.has(name)) {
+          } else if (setHas(globals, name)) {
             const descriptor = ownDescriptor(context, name)
-            if (descriptor !== undefined && Object.hasOwn(descriptor, 'value')) {
+            if (descriptor !== undefined && objectHasOwn(descriptor, 'value')) {
               preview = previewBindingValue(descriptor.value)
             }
           }
         } catch {}
-        return { name, ...preview }
-      })
+        appendArray(entries, { name, ...preview })
+      }
       return { at, entries }
     },
   }

package/internal/runtime-config.js

@@ -43,8 +43,36 @@ function assertField(field, value) {
  * @param config - raw config object.
  * @returns a resolved config object.
  */
+/**
+ * A volatile schema field validates to a live `{ get }` handle. A field that
+ * has no schema default arrives as a handle with an undefined live value and
+ * keeps the runtime default.
+ */
+function liveConfigValue(value, fallback) {
+  if (value !== null && typeof value === 'object'
+    && typeof value.get === 'function' && Object.keys(value).length === 1) {
+    const live = value.get()
+    return live === undefined ? fallback : live
+  }
+  return value
+}
+
 export function resolveConfig(config = {}) {
+  const provided = new Set()
+  for (const field of CONFIG_FIELDS) {
+    if (!Object.hasOwn(config, field.key)) continue
+    const value = config[field.key]
+    if (value !== null && typeof value === 'object'
+      && typeof value.get === 'function' && Object.keys(value).length === 1) {
+      if (value.get() !== undefined) provided.add(field.key)
+    } else {
+      provided.add(field.key)
+    }
+  }
   const resolved = { ...CONFIG_DEFAULTS, ...config }
+  for (const field of CONFIG_FIELDS) {
+    resolved[field.key] = liveConfigValue(resolved[field.key], CONFIG_DEFAULTS[field.key])
+  }
   for (const field of CONFIG_FIELDS) assertField(field, resolved[field.key])
   // Migrate complete old policies; mixed choices retain their explicit
   // compatibility state until the user selects the unified language.
@@ -52,8 +80,8 @@ export function resolveConfig(config = {}) {
     'looseTopLevelRedeclarations', 'looseTopLevelFunctionClassRedeclarations',
     'autoRewriteImports', 'autoStripExports', 'autoSplitRedeclarations',
   ]
-  if (!Object.hasOwn(config, 'bindingUpdates')
-    && legacyKeys.some(key => Object.hasOwn(config, key))) {
+  if (!provided.has('bindingUpdates')
+    && legacyKeys.some(key => provided.has(key))) {
     if (legacyKeys.every(key => resolved[key] === true)) {
       resolved.bindingUpdates = 'stateful'
     } else if (legacyKeys.slice(0, 2).every(key => resolved[key] === false)
@@ -65,6 +93,38 @@ export function resolveConfig(config = {}) {
   return resolved
 }
 
+/** Whether a validated config carries live volatile field handles. */
+export function hasVolatileFields(config) {
+  if (config === null || typeof config !== 'object') return false
+  return Object.values(config).some(value => value !== null && typeof value === 'object'
+    && typeof value.get === 'function' && Object.keys(value).length === 1)
+}
+
+/**
+ * Follow the host's volatile-only commit into the running fiber.
+ *
+ * The loader updates the retained handles in place and emits
+ * `loader/volatile-update` on the owning fiber; listeners on a child scope are
+ * filtered out, so the listener belongs to the plugin's own context and is
+ * released with the runtime scope it serves.
+ *
+ * @param host - the plugin's own context, owning the loader event listener.
+ * @param scope - the runtime scope whose disposal removes the listener.
+ * @param config - the validated config carrying the volatile handles.
+ * @param listener - receives the newly resolved plain configuration.
+ * @returns whether a volatile listener was installed.
+ */
+export function watchVolatileConfig(host, scope, config, listener) {
+  if (!hasVolatileFields(config) || typeof host?.on !== 'function') return false
+  const update = () => listener(resolveConfig(config))
+  if (typeof scope?.effect === 'function') {
+    scope.effect(() => host.on('loader/volatile-update', update), 'ptc-plus volatile settings lifecycle')
+  } else {
+    host.on('loader/volatile-update', update)
+  }
+  return true
+}
+
 /**
  * Validate one wall-clock ceiling against the platform timer limit.
  * @param value - the configured maximum wall time in milliseconds.

package/internal/runtime-intrinsics.js

@@ -27,6 +27,7 @@ export const runtimeIntrinsics = {
     defineProperty: compilerDescriptors.reflectDefineProperty,
     has: Reflect.has,
     ownKeys: Reflect.ownKeys,
+    set: Reflect.set,
   },
   Error, TypeError, Array, Map, Set, WeakMap, WeakSet, RegExp, Proxy,
   objectCreate: Object.create,
@@ -46,6 +47,8 @@ export const runtimeIntrinsics = {
   toBigInt: BigInt,
   toNumber: Number,
   toString: String,
+  bigintToString: uncurry(BigInt.prototype.toString),
+  jsonStringify: JSON.stringify,
   mapGet: uncurry(Map.prototype.get),
   mapHas: uncurry(Map.prototype.has),
   mapSet: uncurry(Map.prototype.set),

package/internal/runtime-messages.js

@@ -1,5 +1,7 @@
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 
+import { isPtcMessageSource, PTC_MESSAGE_SOURCE_KIND } from './message-sources.js'
+
 export const PTC_DELIVERY_CONTEXT = 'tools:ptc-plus-message-delivery'
 export const PTC_BINDING_CATALOG = 'tools:ptc-plus-user-binding-defaults'
 export const PTC_STATE_NAMES = Object.freeze([
@@ -54,7 +56,7 @@ function stateText(sections, prefix = STATE_PREFIX) {
 /** Recognize only bounded, formed PTC records, never authoring tasks or Skills. */
 export function readRuntimeMessage(message) {
   const source = message?.source
-  if (source?.kind !== 'plugin' || source.plugin !== 'ptc-plus'
+  if (!isPtcMessageSource(source)
     || !Array.isArray(message.content) || message.content.length !== 1
     || message.content[0]?.type !== 'text') return undefined
   const text = message.content[0].text
@@ -87,7 +89,7 @@ export function runtimeBindingCatalogMessage(context) {
     throw new Error('invalid PTC binding catalog')
   }
   return createUserMessage({
-    source: { kind: 'plugin', plugin: 'ptc-plus', form: 'catalog' },
+    source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'catalog' },
     content: [{ type: 'text', text: `${CATALOG_PREFIX}\n\n${context?.text ?? EMPTY_CATALOG}` }],
   })
 }
@@ -96,14 +98,14 @@ export function runtimeStateMessage(value) {
   const sections = stateSections(value)
   if (sections === undefined) throw new Error('invalid PTC runtime state sections')
   return createUserMessage({
-    source: { kind: 'plugin', plugin: 'ptc-plus', form: 'snapshot', sections },
+    source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'snapshot', sections },
     content: [{ type: 'text', text: stateText(sections) }],
   })
 }
 
 export function runtimeNoticeMessage(tip) {
   const message = createUserMessage({
-    source: { kind: 'plugin', plugin: 'ptc-plus', form: 'notice', summary: tip.name },
+    source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'notice', summary: tip.name },
     content: [{ type: 'text', text: tip.text }],
   })
   if (readRuntimeMessage(message) === undefined) throw new Error('invalid PTC recovery notice')

package/internal/session-cell-executor.js

@@ -1,3 +1,5 @@
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
 import {
   decodeValue,
   encodeValue,
@@ -415,6 +417,8 @@ export class SessionCellExecutor {
     const priorBindingCatalog = userBindingPlan.catalog
     const catalog = priorBindingCatalog.inputs()
     const { bindingPolicy, rewritesEnabled, moduleSemantics, languageSemantics, moduleTransform } = executionPolicies(config, replayRecord)
+    const moduleDirectory = kernel.cwd ?? process.cwd()
+    const moduleFilename = resolve(moduleDirectory, 'repl')
     const prepareCell = program => prepareProgram(program, {
       knownBindings: catalog.knownBindings,
       bindingPolicy,
@@ -430,6 +434,11 @@ export class SessionCellExecutor {
       dynamicOrigins: catalog.dynamicOrigins,
       establishedRoots: catalog.establishedRoots,
       moduleSemantics,
+      importMeta: {
+        url: pathToFileURL(moduleFilename).href,
+        filename: moduleFilename,
+        dirname: moduleDirectory,
+      },
     })
     let prepared
     try {
@@ -712,9 +721,10 @@ export class SessionCellExecutor {
       volatile: this.handleVolatile,
       call: this.handleCall,
       'output-limit': this.handleOutputLimit,
+      'worker-output-error': this.handleWorkerOutputError,
       done: this.handleDone,
     }[message.type]
-    handler?.call(this, message)
+    return handler?.call(this, message)
   }
 
   handleVolatile(message) {
@@ -742,6 +752,19 @@ export class SessionCellExecutor {
     }, true)
   }
 
+  handleWorkerOutputError(message) {
+    const active = this.kernel.active
+    if (active?.id !== message.id) return false
+    const detail = typeof message.message === 'string'
+      ? message.message
+      : 'the kernel returned an invalid output-attribution event'
+    active.resolve({
+      logs: [],
+      error: { kind: 'worker-exit', message: `worker output attribution failed: ${detail}` },
+    }, true)
+    return true
+  }
+
   handleDone(message) {
     const kernel = this.kernel
     if (kernel.active?.id !== message.id) return