dsh-ptc-plus 0.4.1 → 0.4.3

package/internal/message-sources.js

@@ -0,0 +1,14 @@
+/** Producer identity shared by Host messages and Client history projections. */
+export const PTC_MESSAGE_SOURCE_KIND = 'plugin:ptc-plus'
+
+/** Read the current producer identity and its historical pre-migration wrapper. */
+export function isPtcMessageSource(source) {
+  return source?.kind === PTC_MESSAGE_SOURCE_KIND
+    || (source?.kind === 'plugin' && source.plugin === 'ptc-plus')
+}
+
+/** DSH owns aggregate runtime-context messages independently of PTC messages. */
+export function isHostRuntimeContextSource(source) {
+  return source?.kind === 'runtime-context'
+    || (source?.kind === 'plugin' && source.plugin === '@deepseek-ai/dsh-system-prompt')
+}

package/internal/module-compilation.js

@@ -14,7 +14,7 @@ export { commonJsExportEvidence, linkCommonJsEvidenceSource } from './commonjs-s
 import { COMMONJS_PARAMETERS } from './compiler-scope-facts.js'
 import {
   LEGACY_USER_BINDING_TRANSFORM, USER_BINDING_TRANSFORM, PROTECTED_MODULE_TRANSFORM,
-  supportedUserBindingTransform, transformTypeScriptSource,
+  isStatefulUserBindingTransform, supportedUserBindingTransform, transformTypeScriptSource,
 } from './typescript-transform.js'
 
 const topLevelRegion = region => region.kind === 'program' || region.top === true
@@ -162,7 +162,7 @@ function commonJsBodyRange(source) {
 
 /** Module activations share lexical updates while retaining the native linker. */
 export function compileStatefulModule(source, {
-  transform = USER_BINDING_TRANSFORM, target = 'module', url, nativeUsing,
+  transform = USER_BINDING_TRANSFORM, target = 'module', url, nativeUsing, programBindings = false,
 } = {}) {
   if (transform !== PROTECTED_MODULE_TRANSFORM && !supportedUserBindingTransform(transform)) {
     throw new TypeError('user binding snapshot cannot prove its historical TypeScript transform')
@@ -187,18 +187,19 @@ export function compileStatefulModule(source, {
     callableSources = marked.callableSources
     nativeJavaScript = marked.nativeJavaScript
     mapped = marked
-    if (!nativeJavaScript) mapped = normalizeTypeScriptValues(mapped.code, mapped.sourceMap, target)
-    if (target !== 'commonjs' && (transform === USER_BINDING_TRANSFORM
+    if (!nativeJavaScript) mapped = normalizeTypeScriptValues(mapped.code, mapped.sourceMap, target, callableSources)
+    if (target !== 'commonjs' && (isStatefulUserBindingTransform(transform)
       || transform === PROTECTED_MODULE_TRANSFORM && hasModuleResources(mapped.code))) {
       mapped = normalizeModuleExports(mapped.code, mapped.sourceMap)
     }
   }
   const commonJsSource = target === 'commonjs'
     ? commonJsExportEvidence(mapped.code, { legacy: transform === LEGACY_USER_BINDING_TRANSFORM }) : undefined
-  const links = transform === USER_BINDING_TRANSFORM && target === 'module'
+  const links = isStatefulUserBindingTransform(transform) && target === 'module'
     ? moduleLinkPlan(mapped.code) : undefined
   let normalized = transform === LEGACY_USER_BINDING_TRANSFORM ? mapped
     : normalizeStatefulScopes(mapped.code, mapped.sourceMap, { target, moduleImport: links?.reader, nativeJavaScript, nativeUsing,
+      callableSources,
       mode: transform === PROTECTED_MODULE_TRANSFORM ? 'protected-v1' : 'stateful-v1' })
   // Protected entries retain native declaration policy; adapters still need
   // bounded source regions after TypeScript and decorator lowering.
@@ -222,6 +223,7 @@ export function compileStatefulModule(source, {
     sourceRegions: normalized.sourceRegions,
     callableCollector: createRegionCallableCollector(callableSources),
     module: true, compactOutput: true, importOperation: normalized.importOperation, sourceType, originalSource: source,
+    logicalRoots: programBindings,
     bindings: normalized.dynamicBindings, privateBindings: normalized.privateBindings,
     internalBindings: normalized.internalBindings, parserPlugins: CELL_PARSER_PLUGINS,
   }) }

package/internal/module-transform-contract.js

@@ -1,12 +1,42 @@
 export const LEGACY_USER_BINDING_TRANSFORM = 'amaro@1.1.11'
-export const USER_BINDING_TRANSFORM = 'stateful-module-v1+amaro@1.1.11'
+export const PREVIOUS_USER_BINDING_TRANSFORM = 'stateful-module-v1+amaro@1.1.11'
+export const USER_BINDING_TRANSFORM = 'stateful-module-v2+amaro@1.1.11'
 export const PROTECTED_MODULE_TRANSFORM = 'protected-module-v1+amaro@1.1.11'
+export const MODULE_TRANSFORMS = new Set([
+  LEGACY_USER_BINDING_TRANSFORM,
+  PREVIOUS_USER_BINDING_TRANSFORM,
+  USER_BINDING_TRANSFORM,
+  PROTECTED_MODULE_TRANSFORM,
+])
+
+export function isStatefulUserBindingTransform(transform) {
+  return transform === USER_BINDING_TRANSFORM || transform === PREVIOUS_USER_BINDING_TRANSFORM
+}
 
 export function moduleTransformForLanguage(languageSemantics) {
   return languageSemantics === 'stateful-v1' ? USER_BINDING_TRANSFORM
     : languageSemantics === 'protected-v1' ? PROTECTED_MODULE_TRANSFORM : LEGACY_USER_BINDING_TRANSFORM
 }
 
+export function historicalModuleTransformForLanguage(languageSemantics) {
+  return languageSemantics === 'stateful-v1' ? PREVIOUS_USER_BINDING_TRANSFORM
+    : languageSemantics === 'protected-v1' ? PROTECTED_MODULE_TRANSFORM : LEGACY_USER_BINDING_TRANSFORM
+}
+
+export function moduleTransformMatchesLanguage(transform, languageSemantics) {
+  return languageSemantics === 'stateful-v1' ? isStatefulUserBindingTransform(transform)
+    : languageSemantics === 'protected-v1' ? transform === PROTECTED_MODULE_TRANSFORM
+      : languageSemantics === 'legacy-v1' ? transform === LEGACY_USER_BINDING_TRANSFORM : false
+}
+
+export function normalizeModuleTransform(transform, languageSemantics) {
+  if (!MODULE_TRANSFORMS.has(transform)) throw new TypeError('invalid dsh-ptc-plus journal module transform')
+  if (!moduleTransformMatchesLanguage(transform, languageSemantics)) {
+    throw new TypeError('dsh-ptc-plus journal module transform does not match its language semantics')
+  }
+  return transform
+}
+
 export function supportedUserBindingTransform(transform) {
-  return transform === USER_BINDING_TRANSFORM || transform === LEGACY_USER_BINDING_TRANSFORM
+  return isStatefulUserBindingTransform(transform) || transform === LEGACY_USER_BINDING_TRANSFORM
 }

package/internal/record-utils.js

@@ -1,14 +1,22 @@
 /** Shared structural guards for closed PTC metadata boundaries. */
 
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
+
+const { TypeError, isArray, reflectOwnKeys, objectGetOwnPropertyDescriptor,
+  objectHasOwn, objectPropertyIsEnumerable, objectFreeze, trimString, toString,
+  Set, setHas, setAdd, setSize, appendArray, popArray } = internal
+
 export function isRecord(value) {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
+  return value !== null && typeof value === 'object' && !isArray(value)
 }
 
 export function assertOwnFields(value, allowed, label) {
-  for (const key of Reflect.ownKeys(value)) {
-    if (typeof key !== 'string' || !allowed.has(key)
-      || !Object.prototype.propertyIsEnumerable.call(value, key)) {
-      throw new TypeError(`invalid ${label} field ${String(key)}`)
+  const keys = reflectOwnKeys(value)
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index]
+    if (typeof key !== 'string' || !setHas(allowed, key)
+      || !objectPropertyIsEnumerable(value, key)) {
+      throw new TypeError(`invalid ${label} field ${toString(key)}`)
     }
   }
 }
@@ -16,7 +24,7 @@ export function assertOwnFields(value, allowed, label) {
 export function assertFields(value, allowed, label) {
   if (!isRecord(value)) throw new TypeError(`invalid ${label}`)
   assertOwnFields(value, allowed, label)
-  if (Reflect.ownKeys(value).length !== allowed.size) throw new TypeError(`invalid ${label} fields`)
+  if (reflectOwnKeys(value).length !== setSize(allowed)) throw new TypeError(`invalid ${label} fields`)
 }
 
 export function record(value, label) {
@@ -25,7 +33,7 @@ export function record(value, label) {
 }
 
 export function text(value, label) {
-  if (typeof value !== 'string' || value.trim().length === 0) {
+  if (typeof value !== 'string' || trimString(value).length === 0) {
     throw new TypeError(`ptc-plus: ${label} must be a non-empty string`)
   }
   return value
@@ -37,17 +45,18 @@ export function deepFreeze(value) {
   const pending = [value]
   const seen = new Set()
   while (pending.length > 0) {
-    const current = pending.pop()
-    if (seen.has(current)) continue
-    seen.add(current)
-    for (const key of Reflect.ownKeys(current)) {
-      const descriptor = Object.getOwnPropertyDescriptor(current, key)
-      if (descriptor !== undefined && Object.hasOwn(descriptor, 'value')) {
+    const current = popArray(pending)
+    if (setHas(seen, current)) continue
+    setAdd(seen, current)
+    const keys = reflectOwnKeys(current)
+    for (let index = 0; index < keys.length; index += 1) {
+      const descriptor = objectGetOwnPropertyDescriptor(current, keys[index])
+      if (descriptor !== undefined && objectHasOwn(descriptor, 'value')) {
         const child = descriptor.value
-        if (child !== null && typeof child === 'object') pending.push(child)
+        if (child !== null && typeof child === 'object') appendArray(pending, child)
       }
     }
-    Object.freeze(current)
+    objectFreeze(current)
   }
   return value
 }

package/internal/repl-memory-projection.js

@@ -26,6 +26,16 @@ const PROJECTION_STATE_FIELDS = new Set(['generation', 'memory', 'pendingReplCal
 const PENDING_CALL_FIELDS = new Set(['callId', 'seq'])
 const REPL_MEMORY_META_VERSION = 5
 
+/**
+ * Bound one definition source to the presentation budget. Producers apply this
+ * before a catalog entry can carry more than the validated metadata shape.
+ */
+export function boundedDefinitionSource(source) {
+  return source.length <= MAX_DEFINITION_SOURCE_LENGTH
+    ? source
+    : `${source.slice(0, MAX_DEFINITION_SOURCE_LENGTH - 3)}...`
+}
+
 function isReuseCount(value) {
   return Number.isSafeInteger(value) && value >= 0
 }

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,113 +1,212 @@
 import { types } from 'node:util'
-import { runInContext } 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
-      && runInContext(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) {
-              preview = previewBindingValue(runInContext(name, context, { timeout: 25, displayErrors: false }))
+            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 }
     },
   }