dsh-ptc-plus 0.3.2 → 0.4.1

package/internal/dynamic-environment-integration.js

@@ -0,0 +1,87 @@
+import { commonJsCompilerImport } from './compiler-module-links.js'
+import { createHash } from 'node:crypto'
+import { createGeneratedNameAllocator } from './binding-pattern.js'
+import { compileDynamicEnvironmentSource } from './dynamic-environment-compiler.js'
+import { applySourceEdits, mappedSourceTransform, mapSourceSpan, sourceLineStarts, sourceTextAtSpan, sourceOffsetAt } from './source-position-map.js'
+import { visitRegionSource, applyRegionEdits } from './compiler-region-output.js'
+import { visitSource } from './compiler-source-regions.js'
+
+/** Keep dynamic name resolution behind the lexical facts of the cell compiler. */
+export function adaptDynamicCell(code, sourceMap, options) {
+  const parserOptions = { sourceType: options.sourceType ?? 'script',
+    ...(options.sourceType === 'commonjs' ? {} : { allowAwaitOutsideFunction: true, allowReturnOutsideFunction: true }),
+    plugins: options.parserPlugins }
+  let rootEnd, directiveEnd, strict, allocate
+  let lexicalDynamic = options.sourceRegions?.lexicalDynamic ?? false
+  const discoverDynamics = options.sourceRegions?.lexicalDynamic === undefined
+  const inspectRegion = region => region.kind === 'program' || discoverDynamics || options.rootRuntime !== undefined
+  visitRegionSource({ code, sourceMap, sourceRegions: options.sourceRegions }, parserOptions, input => {
+    allocate ??= options.sourceRegions?.allocate ?? createGeneratedNameAllocator(input.tree, options.reservedBindings ?? [])
+    if (input.region.kind === 'program') {
+      directiveEnd = input.tree.program.directives.at(-1)?.end ?? input.tree.program.interpreter?.end ?? 0
+      strict = input.tree.program.directives.some(directive => directive.value.value === 'use strict')
+    }
+    if (discoverDynamics || options.rootRuntime !== undefined) visitSource(input.tree, {
+      VariableDeclarator(path) {
+        if (path.node.id.name === options.rootRuntime) rootEnd = sourceOffsetAt(input.sourceMap, path.parent.end - 1) + 1
+      },
+      CallExpression(path) { if (path.node.callee.type === 'Identifier' && path.node.callee.name === 'eval') lexicalDynamic = true },
+      WithStatement() { lexicalDynamic = true },
+    })
+  }, inspectRegion)
+  const environmentName = allocate('dynamic_environment')
+  let expression
+  let setup
+  if (options.module === true) {
+    const runtimeUrl = new URL('./dynamic-environment-runtime.js', import.meta.url)
+    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]) }
+    } 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`
+    }
+  } else setup = options.nativeRoot === true ? `\nconst ${environmentName}=${options.environmentGlobal};\n`
+    : `\nconst ${environmentName}=${options.rootRuntime}.dynamic();\n`
+  const insertion = options.module === true || options.nativeRoot === true
+    ? directiveEnd : rootEnd
+  const framed = applyRegionEdits({ code, sourceMap, sourceRegions: options.sourceRegions }, [{ start: insertion, end: insertion, text: setup }])
+  const callableRanges = options.callableRanges?.map(range => ({ ...range,
+    start: range.start >= insertion ? range.start + setup.length : range.start,
+    end: range.end > insertion ? range.end + setup.length : range.end }))
+  const dynamicOrigins = []
+  const sourceIdentity = createHash('sha256').update(options.originalSource).digest('hex')
+  const originalLineStarts = sourceLineStarts(options.originalSource)
+  const coordinates = { generatedStarts: sourceLineStarts(framed.code), originalStarts: originalLineStarts }
+  const evalOrigin = node => {
+    const definitionSpan = mapSourceSpan({ line: node.loc.start.line, column: node.loc.start.column + 1,
+      end: { line: node.loc.end.line, column: node.loc.end.column + 1 } }, framed.code, options.originalSource, framed.sourceMap, coordinates)
+    const target = `eval:${sourceIdentity}:${definitionSpan.line}:${definitionSpan.column}`
+    dynamicOrigins.push({ target, definitionSpan })
+    return target
+  }
+  const writeTarget = node => {
+    const position = mapSourceSpan({ line: node.loc.start.line, column: node.loc.start.column + 1 },
+      framed.code, options.originalSource, framed.sourceMap, coordinates)
+    return `write:${sourceIdentity}:${position.line}:${position.column}:${node.name}`
+  }
+  const calleeSource = node => sourceTextAtSpan(options.originalSource, mapSourceSpan({
+    line: node.loc.start.line, column: node.loc.start.column + 1,
+    end: { line: node.loc.end.line, column: node.loc.end.column + 1 },
+  }, framed.code, options.originalSource, framed.sourceMap, coordinates), originalLineStarts)
+  const result = compileDynamicEnvironmentSource(framed.code, { cell: { ...options, environmentName,
+    sourceRegions: framed.sourceRegions,
+    callableRanges,
+    staticOnly: !lexicalDynamic && options.logicalRoots !== true,
+    calleeSource,
+    environmentExpression: expression, evalOrigin: options.module === true ? undefined : evalOrigin,
+    writeTarget: options.module === true ? undefined : writeTarget } })
+  const emission = result.sourceOffsets === undefined
+    ? mappedSourceTransform(framed.code, framed.sourceMap, { code: result.code, map: result.sourceMap })
+    : applySourceEdits(framed.code, framed.sourceMap, [{ start: 0, end: framed.code.length, text: result.code, mappings: result.sourceOffsets }])
+  return { ...emission, sourceRegions: result.sourceRegions, callableRanges: result.callableRanges,
+    dynamicOrigins, dynamicEnvironmentName: environmentName }
+}

package/internal/dynamic-environment-runtime.js

@@ -0,0 +1,362 @@
+import { compileDynamicSource, isCompilerSyntaxError } from './compiler-service.js'
+import { createNativeCallAdapter } from './dynamic-native-runtime.js'
+import { captureCompilerIntrinsics, moduleRuntimeIntrinsics as internal } from './compiler-intrinsics.js'
+import { types } from 'node:util'
+
+const reflectionIntrinsics = new internal.WeakMap()
+function captureReflection(reflect) {
+  let captured = internal.weakMapGet(reflectionIntrinsics, reflect)
+  if (captured === undefined) {
+    captured = { apply: reflect.apply, construct: reflect.construct, get: reflect.get,
+      has: reflect.has, set: reflect.set, deleteProperty: reflect.deleteProperty,
+      defineProperty: reflect.defineProperty, ownKeys: reflect.ownKeys }
+    internal.weakMapSet(reflectionIntrinsics, reflect, captured)
+    internal.weakMapSet(reflectionIntrinsics, captured, captured)
+  }
+  return captured
+}
+const defaultIntrinsics = { intrinsicEval: eval, realmFunction: Function, globalObject: globalThis, reflect: captureReflection(Reflect) }
+
+const isObject = value => value !== null && (typeof value === 'object' || typeof value === 'function')
+const isMap = types.isMap
+const bindingStores = new internal.WeakMap()
+const asBindings = value => {
+  if (internal.isArray(value)) {
+    const result = new internal.Map()
+    for (let index = 0; index < value.length; index++) {
+      const entry = value[index]
+      internal.mapSet(result, entry[0], entry[1])
+    }
+    value = result
+  }
+  // Logical roots implement this same live lookup/update contract. Native Map
+  // storage adapts once; callers never select its mutable prototype methods.
+  if (!isMap(value)) return value
+  let result = internal.weakMapGet(bindingStores, value)
+  if (result !== undefined) return result
+  result = { has: name => internal.mapHas(value, name), get: name => internal.mapGet(value, name),
+    set: (name, binding) => internal.mapSet(value, name, binding), delete: name => internal.mapDelete(value, name),
+    forEach: visit => internal.mapForEach(value, visit) }
+  internal.weakMapSet(bindingStores, value, result)
+  return result
+}
+
+/** Native reference operations over compiler-proved lexical and object frames. */
+export function createDynamicEnvironmentRuntime({
+  importModule = (source, options) => import(source, options),
+  intrinsicEval = defaultIntrinsics.intrinsicEval, realmFunction = defaultIntrinsics.realmFunction, globalObject = defaultIntrinsics.globalObject,
+  errors, reflect = defaultIntrinsics.reflect, object, interfaceOwner,
+} = {}) {
+  const intrinsics = captureCompilerIntrinsics(realmFunction)
+  const { unscopables, Object: intrinsicObject, array: internalArray } = intrinsics
+  object ??= intrinsicObject
+  errors ??= intrinsics
+  // Reference mechanics use the realm's captured operations. Explicit source
+  // Reflect calls still observe the mutable user-visible Reflect object.
+  reflect = captureReflection(reflect)
+  const parameterEnvironments = new internal.WeakMap()
+  let rootEnvironment
+  let defaultRootEnvironment
+  const evaluate = (callee, receiver, args, environment, compilerOptions = {}) => {
+    if (!nativeCalls.isEval(callee)) return reflect.apply(callee, receiver, args)
+    const source = args[0]
+    if (typeof source !== 'string') return source
+    let compiled
+    try {
+      compiled = compileDynamicSource(source, { strict: environment.strict, allowNewTarget: environment.allowNewTarget,
+        privateNames: environment.privateNames, allowSuper: environment.allowSuper, allowSuperCall: environment.allowSuperCall,
+        forbidArguments: environment.forbidArguments, resolveOriginalSource: nativeCalls.originalSource, ...compilerOptions })
+    } catch (error) {
+      if (!isCompilerSyntaxError(error)) throw error
+      throw new errors.SyntaxError(error.message)
+    }
+    nativeCalls.registerSources(compiled.callableSources)
+    environment.declareEvalVars(compiled.varNames)
+    return nativeCalls.evaluate(compiled, environment)
+  }
+  const nativeCalls = createNativeCallAdapter({ realmFunction, intrinsicEval, reflect, errors, evaluate, interfaceOwner,
+    rootEnvironment(origin) {
+      if (rootEnvironment === undefined && defaultRootEnvironment === undefined) {
+        const varFrame = new internal.Map()
+        defaultRootEnvironment = environment({ varFrame, frames: [{ kind: 'lexical', bindings: varFrame }],
+          declareVars: declareGlobals,
+          createVar(name) {
+            const target = ambientReference(name, false)
+            return { kind: 'var', get: () => target.value, set: value => { target.value = value },
+              typeof: () => target.typeof(), delete: () => target.delete() }
+          },
+        })
+      }
+      return (rootEnvironment?.() ?? defaultRootEnvironment).context({ strict: false,
+        getThis: () => globalObject, allowNewTarget: false }).at(origin)
+    },
+  })
+  function declareGlobals(names, functionNames = []) {
+    for (let index = 0; index < functionNames.length; index++) {
+      const name = functionNames[index]
+      if (!internal.includes(names, name)) continue
+      const descriptor = intrinsicObject.getOwnPropertyDescriptor(globalObject, name)
+      const allowed = descriptor === undefined ? intrinsicObject.isExtensible(globalObject)
+        : descriptor.configurable || intrinsicObject.hasOwn(descriptor, 'value') && descriptor.writable && descriptor.enumerable
+      if (!allowed) throw new errors.TypeError(`Cannot declare global function '${name}'`)
+    }
+    nativeCalls.declareGlobals(names)
+  }
+  const reference = (name, descriptor, receiver, strict, origin, writeTarget) => descriptor.reference === undefined ? ({
+    get value() { return descriptor.get() },
+    set value(value) {
+      if (descriptor.kind === 'self' && descriptor.set === undefined) {
+        if (strict) throw new errors.TypeError('Assignment to constant variable.')
+        return
+      }
+      descriptor.set(value, strict, origin, writeTarget)
+    },
+    get callee() {
+      const value = descriptor.get()
+      return nativeCalls.referenceCall(value, receiver)
+    },
+    get evalInvocation() {
+      const value = descriptor.get()
+      return (environment, args, callOrigin) => nativeCalls.isEval(value)
+        ? () => evaluate(value, receiver, args, environment)
+        : nativeCalls.beginInvocation(nativeCalls.prepareInvocation(value, receiver, callOrigin), args)
+    },
+    typeof() { return descriptor.typeof === undefined ? typeof descriptor.get() : descriptor.typeof() },
+    delete() { return descriptor.delete === undefined ? false : descriptor.delete(strict) },
+  }) : descriptor.reference()
+  const forwardReference = resolve => ({
+    get value() { return resolve().value },
+    set value(value) { resolve().value = value },
+    get callee() { return resolve().callee },
+    get evalInvocation() { return resolve().evalInvocation },
+    typeof() { return resolve().typeof() },
+    delete() { return resolve().delete() },
+  })
+  const objectReference = (object, name, strict) => reference(name, {
+    get: () => reflect.get(object, name, object),
+    set(value) {
+      if (!reflect.set(object, name, value, object) && strict) throw new errors.TypeError(`Cannot assign to property '${name}'`)
+    },
+    delete() {
+      const deleted = reflect.deleteProperty(object, name)
+      if (!deleted && strict) throw new errors.TypeError(`Cannot delete property '${name}'`)
+      return deleted
+    },
+  }, object, strict)
+  const ambientReference = (name, strict) => reference(name, {
+    get() {
+      if (!reflect.has(globalObject, name)) throw new errors.ReferenceError(`${name} is not defined`)
+      return reflect.get(globalObject, name, globalObject)
+    },
+    set(value) {
+      if (strict && !reflect.has(globalObject, name)) throw new errors.ReferenceError(`${name} is not defined`)
+      if (!reflect.set(globalObject, name, value, globalObject) && strict) throw new errors.TypeError(`Cannot assign to '${name}'`)
+    },
+    typeof: () => reflect.has(globalObject, name) ? typeof reflect.get(globalObject, name, globalObject) : 'undefined',
+    delete: () => reflect.deleteProperty(globalObject, name),
+  }, undefined, strict)
+
+  function environment({ frames = [], varFrame = new internal.Map(), strict = false, origin, lexicalContext = {},
+    getThis = () => globalObject, getNewTarget = () => undefined, allowNewTarget = false,
+    ambient = ambientReference, createVar, declareVars, nativeAwait = false } = {}) {
+    varFrame = asBindings(varFrame)
+    const capturedFrames = []
+    for (let index = 0; index < frames.length; index++) {
+      const frame = frames[index]
+      internal.appendArray(capturedFrames, frame.kind === 'object' ? frame : { ...frame, bindings: asBindings(frame.bindings) })
+    }
+    frames = capturedFrames
+    const result = {
+      importModule,
+      internalArray,
+      expose: nativeCalls.exposedValue,
+      prepareCall: nativeCalls.prepareCall,
+      prepareInvocation: nativeCalls.prepareInvocation,
+      releaseMemberReceiver: nativeCalls.releaseMemberReceiver,
+      prepareMemberInvocation: nativeCalls.prepareMemberInvocation,
+      beginInvocation: nativeCalls.beginInvocation,
+      prepareTagInvocation: nativeCalls.prepareTagInvocation,
+      templateArguments: nativeCalls.templateArguments,
+      propagate: nativeCalls.propagate,
+      strict,
+      allowNewTarget,
+      privateNames: internal.Object.keys(lexicalContext.privateReferences ?? {}),
+      allowSuper: lexicalContext.getSuper !== undefined,
+      allowSuperCall: lexicalContext.callSuper !== undefined,
+      forbidArguments: lexicalContext.forbidArguments === true,
+      thisValue: () => getThis(),
+      newTarget: () => getNewTarget(),
+      get superReference() {
+        const receiver = getThis()
+        return key => reference(key, lexicalContext.getSuper(key), receiver, strict)
+      },
+      get superCall() { return lexicalContext.callSuper },
+      privateReference(name, receiver, optional = false) {
+        return optional && receiver == null ? undefined : reference(name, lexicalContext.privateReferences[name](receiver), receiver, strict)
+      },
+      privateHas(name, receiver) { return lexicalContext.privateReferences[name](receiver).has() },
+      reference(name, writeTarget) {
+        for (let index = 0; index < frames.length; index++) {
+          const frame = frames[index]
+          if (frame.kind === 'lexical' || frame.kind === 'self') {
+            if (frame.bindings.has(name)) return reference(name, frame.bindings.get(name), undefined, strict, origin, writeTarget)
+          } else if (reflect.has(frame.object, name)) {
+            const excluded = reflect.get(frame.object, unscopables, frame.object)
+            if (!isObject(excluded) || !reflect.get(excluded, name, excluded)) return objectReference(frame.object, name, strict)
+          }
+        }
+        return ambient(name, strict, origin, writeTarget)
+      },
+      deferredReference(name, writeTarget) {
+        return forwardReference(() => result.reference(name, writeTarget))
+      },
+      withReference(name, withDepth, fallback) {
+        const select = () => {
+          let remaining = withDepth
+          for (let index = 0; index < frames.length; index++) {
+            const frame = frames[index]
+            if (remaining === 0) break
+            if (frame.kind !== 'object') continue
+            remaining--
+            if (!reflect.has(frame.object, name)) continue
+            const excluded = reflect.get(frame.object, unscopables, frame.object)
+            if (!isObject(excluded) || !reflect.get(excluded, name, excluded)) return objectReference(frame.object, name, strict)
+          }
+          return reference(name, fallback, undefined, strict, origin)
+        }
+        return forwardReference(select)
+      },
+      initialize(name, value) {
+        result.reference(name).value = value
+        return value
+      },
+      capture(scopes, nextStrict = strict, rootIndex = -1) {
+        const captured = []
+        for (let index = 0; index < scopes.length; index++) internal.appendArray(captured, { kind: 'lexical', bindings: asBindings(scopes[index]) })
+        let combined = internal.copyArray(frames, 0, frames.length, internal.copyArray(captured))
+        if (nativeAwait && rootIndex >= 0) {
+          let boundary = 0
+          for (let index = 0; index < frames.length; index++) {
+            if (frames[index].kind === 'lexical' && frames[index].bindings === varFrame) { boundary = index + 1; break }
+          }
+          for (let index = rootIndex; index < captured.length; index++) captured[index].bindings.forEach((binding, name) => {
+            if (binding.kind === 'hoisted' && !varFrame.has(name)) varFrame.set(name, binding)
+          })
+          combined = internal.copyArray(captured, 0, rootIndex)
+          internal.copyArray(frames, 0, boundary, combined)
+          internal.copyArray(captured, rootIndex, captured.length, combined)
+          internal.copyArray(frames, boundary, frames.length, combined)
+        }
+        return environment({ frames: combined,
+          varFrame, strict: nextStrict, getThis, getNewTarget, allowNewTarget, ambient, createVar, declareVars, nativeAwait, origin, lexicalContext })
+      },
+      awaitActivation() {
+        const local = new internal.Map()
+        return environment({ frames: internal.copyArray(frames, 0, frames.length, [{ kind: 'lexical', bindings: local }]), varFrame: local,
+          strict, getThis, getNewTarget, allowNewTarget, ambient, nativeAwait: true, origin, lexicalContext })
+      },
+      activation(bindings, nextGetThis = getThis, nextGetNewTarget = getNewTarget, nextStrict = strict, ownFunction = true, selfBindings) {
+        bindings = asBindings(bindings)
+        const activationFrames = [{ kind: 'lexical', bindings }]
+        if (selfBindings !== undefined) internal.appendArray(activationFrames, { kind: 'self', bindings: asBindings(selfBindings) })
+        return environment({ frames: internal.copyArray(frames, 0, frames.length, activationFrames), varFrame: bindings,
+          strict: nextStrict, getThis: nextGetThis, getNewTarget: nextGetNewTarget, allowNewTarget: ownFunction || allowNewTarget, ambient, origin,
+          lexicalContext: ownFunction ? { privateReferences: lexicalContext.privateReferences } : lexicalContext })
+      },
+      parameters(key, bindings, nextGetThis = getThis, nextGetNewTarget = getNewTarget, nextStrict = strict, ownFunction = true, selfBindings) {
+        let selected = internal.weakMapGet(parameterEnvironments, key)
+        if (selected === undefined) {
+          bindings = asBindings(bindings)
+          if (ownFunction && !bindings.has('arguments')) {
+            let value = key
+            bindings.set('arguments', { kind: 'param', get: () => value, set: next => { value = next } })
+          }
+          const parameterFrames = [{ kind: 'lexical', bindings }]
+          if (selfBindings !== undefined) internal.appendArray(parameterFrames, { kind: 'self', bindings: asBindings(selfBindings) })
+          selected = environment({ frames: internal.copyArray(frames, 0, frames.length, parameterFrames), varFrame: bindings,
+            strict: nextStrict, getThis: nextGetThis, getNewTarget: nextGetNewTarget, allowNewTarget: ownFunction || allowNewTarget, ambient, origin, lexicalContext })
+          internal.weakMapSet(parameterEnvironments, key, selected)
+        }
+        return selected
+      },
+      propertyKey(value) { return reflect.ownKeys({ [value]: undefined })[0] },
+      parameterArrow(fn, name) {
+        intrinsics.Reflect.defineProperty(fn, 'length', { value: internal.max(0, fn.length - 1) })
+        if (name !== undefined && fn.name === '') intrinsics.Reflect.defineProperty(fn, 'name', { value: name })
+        const adapter = new internal.Proxy(fn, { apply(target, receiver, args) {
+          return reflect.apply(target, receiver, internal.copyArray(args, 0, args.length, [{}]))
+        } })
+        return nativeCalls.registerCallableSourceTarget(adapter, fn)
+      },
+      context(options) { return environment({ frames, varFrame, strict: options.strict ?? strict,
+        getThis: options.getThis ?? getThis, getNewTarget: options.getNewTarget ?? getNewTarget,
+        allowNewTarget: options.allowNewTarget ?? allowNewTarget, ambient, createVar, declareVars, nativeAwait, origin,
+        lexicalContext: { ...lexicalContext, ...options } }) },
+      at(nextOrigin) { return environment({ frames, varFrame, strict, getThis, getNewTarget,
+        allowNewTarget, ambient, createVar, declareVars, nativeAwait, origin: nextOrigin, lexicalContext }) },
+      withObject(value) {
+        if (value === null || value === undefined) throw new errors.TypeError('Cannot convert undefined or null to object')
+        return environment({ frames: internal.copyArray(frames, 0, frames.length, [{ kind: 'object', object: object(value) }]),
+          varFrame, strict, getThis, getNewTarget, allowNewTarget, ambient, createVar, declareVars, nativeAwait, origin, lexicalContext })
+      },
+      declareEvalVars(names) {
+        // EvalDeclarationInstantiation checks every name before any initializer
+        // runs. Object environments do not create lexical conflicts.
+        for (let index = 0; index < names.length; index++) {
+          const name = names[index]
+          for (let frameIndex = 0; frameIndex < frames.length; frameIndex++) {
+            const frame = frames[frameIndex]
+            if (frame.kind !== 'lexical') continue
+            const binding = frame.bindings.get(name)
+            if (binding !== undefined && binding.kind !== 'var' && binding.kind !== 'param' && binding.kind !== 'hoisted') {
+              throw new errors.SyntaxError(`Identifier '${name}' has already been declared`)
+            }
+            if (frame.bindings === varFrame) break
+          }
+        }
+        if (declareVars === undefined) {
+          const declarations = []
+          for (let index = 0; index < names.length; index++) internal.appendArray(declarations, [names[index]])
+          result.initializeEvalDeclarations(declarations)
+        }
+      },
+      initializeEvalDeclarations(declarations) {
+        for (let index = 0; index < declarations.length; index++) {
+          const declaration = declarations[index]
+          const name = declaration[0], value = declaration[1], isFunction = declaration[2] === true
+          declareVars?.([name], isFunction ? [name] : [])
+          if (!varFrame.has(name)) {
+            if (createVar !== undefined) varFrame.set(name, createVar(name, origin))
+            else {
+              let current
+              const binding = { kind: 'var', get: () => current, set: next => {
+                current = next
+                varFrame.set(name, binding)
+              }, delete: () => varFrame.delete(name) }
+              varFrame.set(name, binding)
+            }
+          }
+          if (isFunction) result.initializeEvalFunction(name, value)
+        }
+      },
+      initializeEvalFunction(name, value) { varFrame.get(name).set(value, strict, origin) },
+    }
+    return result
+  }
+  return {
+    installIntrinsics() { nativeCalls.install(); return this },
+    exposedIntrinsic: nativeCalls.exposedValue,
+    registerSources: nativeCalls.registerSources,
+    declareGlobals,
+    setRootEnvironment(getEnvironment) { rootEnvironment = getEnvironment },
+    reference,
+    environment(options = {}) {
+      const varFrame = options.varFrame ?? new internal.Map()
+      const frames = internal.copyArray(options.frames ?? [])
+      if (options.nativeBindings !== undefined) internal.appendArray(frames, { kind: 'lexical', bindings: asBindings(options.nativeBindings) })
+      internal.appendArray(frames, { kind: 'lexical', bindings: varFrame })
+      return environment({ ...options, varFrame, frames })
+    },
+    evaluate,
+  }
+}

package/internal/dynamic-native-calls.js

@@ -0,0 +1,150 @@
+import traverseModule from '@babel/traverse'
+import { types as t } from '@babel/core'
+import { transform as transformOptional, transformOptionalChain } from '@babel/plugin-transform-optional-chaining'
+import { isWriteIdentifier as isWriteTarget } from './binding-pattern.js'
+import { withGeneratedNameAllocator } from './compiler-generated-names.js'
+
+const traverse = traverseModule.default ?? traverseModule
+
+/** Select intrinsic interfaces at owned source value and invocation boundaries. */
+export function rewriteNativeCalls(tree, environment, { origin, skip, operations, originalCallees, allocate }) {
+  const { internal } = operations
+  let memberReceiver
+  let programScope
+  const helper = (name, args) => {
+    return operations.operation(t.callExpression(t.memberExpression(t.cloneNode(environment), t.identifier(name)), args))
+  }
+  const skipOwned = path => path.isTSType() || skip(path)
+    || operations.callee(path.node)
+  const undefinedValue = () => t.unaryExpression('void', t.numericLiteral(0))
+  if (originalCallees === undefined) {
+    originalCallees = new WeakSet()
+    traverse(tree, {
+      enter(path) { if (path.isTSType() || skip(path)) path.skip() },
+      'CallExpression|OptionalCallExpression'(path) { originalCallees.add(path.node.callee) },
+    })
+  }
+  traverse(tree, { Program(path) { programScope = path.scope; path.stop() } })
+  const expose = path => {
+    // Only GetValue results select an interface. References must retain their
+    // write/delete semantics, receivers and optional-chain short circuiting.
+    const parent = path.parentPath
+    if (operations.owns(path.node) && !operations.isValue(path.node)
+      || !path.isReferenced() || isWriteTarget(path) || parent.isUnaryExpression({ operator: 'delete' })
+      || parent.isUnaryExpression({ operator: 'typeof' }) && path.isIdentifier()
+      || (parent.isCallExpression() || parent.isOptionalCallExpression()) && path.key === 'callee'
+      || parent.isTaggedTemplateExpression() && path.key === 'tag'
+      || parent.isDecorator()
+      || parent.isOptionalMemberExpression() && path.key === 'object'
+      || path.isIdentifier() && internal.has(path.node.name)) return
+    if (parent.isObjectProperty() && parent.node.shorthand) {
+      parent.node.shorthand = false
+      parent.node.computed = true
+      parent.node.key = t.stringLiteral(path.node.name)
+    }
+    path.replaceWith(t.inherits(helper('expose', [path.node]), path.node))
+    path.skip()
+  }
+  const prepare = (callee, target, optional = false) => {
+    const stamp = target === undefined ? undefinedValue() : t.valueToNode(target)
+    const options = [stamp, t.booleanLiteral(optional)]
+    const prepared = (name, args) => t.inherits(helper(name, args), callee)
+    if (t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) {
+      if (t.isSuper(callee.object)) return prepared('prepareInvocation', [callee, t.thisExpression(), ...options])
+      if (memberReceiver === undefined) {
+        memberReceiver = t.identifier(allocate('member_receiver'))
+        programScope.push({ id: memberReceiver })
+        internal.add(memberReceiver.name)
+      }
+      // Argument evaluation saves the receiver before key/getter reentrancy can
+      // change the temporary; the member read itself stays in its source frame.
+      const receiver = helper('releaseMemberReceiver', [t.cloneNode(memberReceiver),
+        t.assignmentExpression('=', t.cloneNode(memberReceiver), undefinedValue())])
+      return prepared('prepareMemberInvocation', [t.assignmentExpression('=', t.cloneNode(memberReceiver), callee.object),
+        t.inherits(t.memberExpression(receiver, callee.property, callee.computed), callee), ...options])
+    }
+    return prepared('prepareInvocation', [callee, undefinedValue(), ...options])
+  }
+  const invoke = (prepared, args) => operations.operation(t.callExpression(helper('beginInvocation', [prepared, args]), []))
+  // Receiver extraction must run after complete chains acquire their native
+  // short-circuit boundary, including grouped calls and computed-key effects.
+  traverse(tree, {
+    enter(path) { if (skipOwned(path)) path.skip() },
+    'OptionalCallExpression|OptionalMemberExpression'(path) {
+      const assumptions = { pureGetters: false, noDocumentAll: false }
+      withGeneratedNameAllocator(path.scope, allocate, () => {
+        if (path.isOptionalMemberExpression() && path.parentPath.isTaggedTemplateExpression()) {
+          const target = origin(path.parent)
+          transformOptionalChain(path, assumptions, path, undefinedValue(), callee => helper('prepareTagInvocation', [prepare(callee, target)]))
+        } else transformOptional(path, assumptions)
+      })
+    },
+  })
+  traverse(tree, {
+    enter(path) { if (skipOwned(path)) path.skip() },
+    'TSAsExpression|TSSatisfiesExpression|TSNonNullExpression|TSTypeAssertion': { enter(path) {
+      path.replaceWith(path.node.expression)
+    } },
+    ExportSpecifier(path) {
+      // Babel's printer compares identifier names when eliding an alias. Both
+      // string ModuleExportNames otherwise appear equal as undefined names.
+      const { local, exported } = path.node
+      if (t.isStringLiteral(local) && t.isStringLiteral(exported)) exported.name = exported.value
+      path.skip()
+    },
+    ReferencedIdentifier: { exit: expose },
+    'MemberExpression|OptionalMemberExpression|AwaitExpression|YieldExpression': { exit: expose },
+    ThrowStatement: { exit(path) {
+      if (operations.owns(path.node)) return
+      const argument = path.node.argument
+      path.node.argument = t.inherits(helper('propagate', [argument, t.valueToNode(origin(argument))]), argument)
+      path.skip()
+    } },
+    'CallExpression|OptionalCallExpression': { exit(path) {
+      if (operations.owns(path.node)) {
+        if (operations.isValue(path.node)) expose(path)
+        return
+      }
+      if (t.isSuper(path.node.callee) || t.isImport(path.node.callee)
+        || t.isIdentifier(path.node.callee, { name: 'eval' })) return
+      const node = path.node
+      // Babel expresses saved receivers through generated call/bind members.
+      // The intrinsic interface already owns invocation, so use the saved
+      // receiver directly without observing user-replaced call/bind properties.
+      if (t.isMemberExpression(node.callee) && !originalCallees.has(node.callee)
+        && t.isIdentifier(node.callee.property) && ['call', 'bind'].includes(node.callee.property.name)) {
+        const prepared = helper('prepareInvocation', [node.callee.object, node.arguments[0],
+          t.valueToNode(origin(node)), t.booleanLiteral(false)])
+        path.replaceWith(t.inherits(node.callee.property.name === 'bind'
+          ? helper('prepareTagInvocation', [prepared]) : invoke(prepared, t.arrayExpression(node.arguments.slice(1))), node))
+        path.skip()
+        return
+      }
+      const callee = prepare(node.callee, origin(node), node.optional === true)
+      path.replaceWith(t.inherits(invoke(callee, t.arrayExpression(node.arguments)), node))
+      path.skip()
+    } },
+    NewExpression: { exit(path) {
+      if (operations.owns(path.node)) return
+      const target = origin(path.node)
+      const invocation = t.inherits(invoke(helper('prepareInvocation', [path.node.callee, undefinedValue(),
+        target === undefined ? undefinedValue() : t.valueToNode(target), t.booleanLiteral(false), t.booleanLiteral(true)]), t.arrayExpression(path.node.arguments)), path.node)
+      // Native Error construction records the continuation call site. Anchor
+      // that private call to the original new expression, after its arguments.
+      if (invocation.loc !== undefined) invocation.callee.loc = { ...invocation.loc, end: invocation.loc.start }
+      path.replaceWith(invocation)
+      path.skip()
+    } },
+    TaggedTemplateExpression: { exit(path) {
+      if (operations.owns(path.node)) return
+      const args = t.taggedTemplateExpression(t.memberExpression(t.cloneNode(environment), t.identifier('templateArguments')), path.node.quasi)
+      path.replaceWith(t.inherits(invoke(prepare(path.node.tag, origin(path.node)), args), path.node))
+      path.skip()
+    } },
+    Decorator: { exit(path) {
+      if (operations.owns(path.node)) return
+      path.node.expression = helper('prepareTagInvocation', [prepare(path.node.expression, origin(path.node))])
+      path.skip()
+    } },
+  })
+}