dsh-ptc-plus 0.3.1 → 0.4.1

package/internal/commonjs-export-evidence.js

@@ -0,0 +1,63 @@
+import { createRequire } from 'node:module'
+import { linkCommonJsEvidenceSource } from './compiler-service.js'
+import { moduleRuntimeIntrinsics } from './compiler-intrinsics.js'
+import { compilerPlatformBridge } from './compiler-platform.js'
+import { registerModuleResolutionHook } from './module-runtime-platform.js'
+
+const { Map, mapGet, mapHas, mapSet, mapDelete, startsWith, sliceString, stringify } = moduleRuntimeIntrinsics
+const nativeCreateRequire = createRequire
+
+let nextEvidence = 0
+
+/** Own analysis-only source companions for modules that actually enter Node. */
+export function createCommonJsEvidence({ linkSource = linkCommonJsEvidenceSource } = {}) {
+  const sources = new Map()
+  const modules = new Map()
+  return {
+    attach(url, code, source) {
+      let record = mapGet(modules, url)
+      if (record?.source !== source) {
+        if (record !== undefined) mapDelete(sources, record.reference)
+        // CJS resolution uses its native parent filename as well as the public
+        // context. A sibling preserves package and extension lookup semantics.
+        const reference = compilerPlatformBridge.url(`.__ptc_commonjs_evidence_${++nextEvidence}.cjs`, url)
+        const prefix = `ptc-module:evidence-link/${nextEvidence}/`
+        record = { url, source, reference, prefix, evidence: linkSource(source, prefix) }
+        mapSet(modules, url, record)
+        mapSet(sources, reference, record)
+      }
+      // This final assignment only contributes native linking evidence. The
+      // original module executes once and remains the source of every value.
+      return `${code}\n;if(false)module.exports=require(${stringify(record.reference)});\n`
+    },
+    resolve(specifier, context, recordResolution) {
+      if (mapHas(sources, specifier)) return { url: specifier, format: 'commonjs', shortCircuit: true }
+      const source = mapGet(sources, context.parentURL)
+      if (source === undefined || !startsWith(specifier, source.prefix)) return undefined
+      const originalSpecifier = sliceString(specifier, source.prefix.length)
+      let resolution
+      const request = `ptc-module:evidence-resolution/${++nextEvidence}`
+      const resolved = {}
+      const forwardedContext = { ...context, parentURL: source.url }
+      const dispose = registerModuleResolutionHook((value, details, next) => {
+        if (value !== request) return next(value, details)
+        resolution = next(originalSpecifier, forwardedContext)
+        // Stop this private request at resolution. Node's existing CJS linker
+        // owns the subsequent load; neither the evidence nor user code runs.
+        throw resolved
+      })
+      try { nativeCreateRequire(source.url)(request) } catch (error) {
+        if (error !== resolved) throw error
+      } finally { dispose() }
+      recordResolution(source.url, originalSpecifier, context.importAttributes, resolution)
+      return { ...resolution, shortCircuit: true }
+    },
+    load(url) {
+      const record = mapGet(sources, url)
+      if (record === undefined) return undefined
+      // Node scans reexported CJS source without executing it. A return also
+      // keeps accidental direct execution from running its original body.
+      return { format: 'commonjs', shortCircuit: true, source: `return;\n${record.evidence}` }
+    },
+  }
+}

package/internal/commonjs-source-evidence.js

@@ -0,0 +1,72 @@
+import { parse } from '@babel/parser'
+import { types as t } from '@babel/core'
+import { transformTypeScriptSource } from './typescript-transform.js'
+import { CELL_PARSER_PLUGINS, normalizeTypeScriptValues } from './repl-scope-normalizer.js'
+import { visitSource } from './compiler-source-regions.js'
+import { applySourceEdits, identitySourceMap } from './source-position-map.js'
+
+export function linkCommonJsEvidenceSource(source, prefix) {
+  const tree = parse(source, { sourceType: 'commonjs', errorRecovery: true, plugins: CELL_PARSER_PLUGINS })
+  const starts = []
+  t.traverseFast(tree, node => {
+    if (node.type === 'CallExpression' && node.callee.type === 'Identifier'
+      && node.callee.name === 'require' && node.arguments[0]?.type === 'StringLiteral') {
+      starts.push(node.arguments[0].start + 1)
+    }
+  })
+  const pieces = []
+  let previous = 0
+  for (const start of starts.sort((left, right) => left - right)) {
+    pieces.push(source.slice(previous, start), prefix)
+    previous = start
+  }
+  pieces.push(source.slice(previous))
+  return pieces.join('')
+}
+
+/** Preserve original spelling for the native CommonJS linker's source analysis. */
+export function commonJsExportEvidence(source, { legacy = false } = {}) {
+  try {
+    parse(source, { sourceType: 'commonjs' })
+    return source
+  } catch {
+    // Syntax validation belongs to the executable compiler. Evidence only
+    // removes type ranges that would interfere with Node's lexical analysis.
+  }
+  if (!legacy) {
+    const normalized = normalizeTypeScriptValues(source, identitySourceMap(source.length), 'commonjs').code
+    const tree = parse(normalized, { sourceType: 'commonjs', errorRecovery: true, plugins: CELL_PARSER_PLUGINS })
+    const edits = []
+    visitSource(tree, { enter(path) {
+      const node = path.node
+      if (path.isTSType() || path.isTSTypeAnnotation() || path.isTSTypeParameterDeclaration()
+        || path.isTSTypeParameterInstantiation()) {
+        edits.push({ start: node.start, end: node.end, text: '' })
+        path.skip()
+      } else if (node.type.startsWith('TS') && node.expression !== undefined) {
+        edits.push({ start: node.start, end: node.expression.start, text: '' },
+          { start: node.expression.end, end: node.end, text: '' })
+        for (const key of t.VISITOR_KEYS[node.type]) if (key !== 'expression') path.skipKey(key)
+      }
+    } })
+    return applySourceEdits(normalized, identitySourceMap(normalized.length), edits.map(edit => ({ ...edit,
+      text: normalized.slice(edit.start, edit.end).replace(/[^\s]/gu, ' ') }))).code
+  }
+  // Strip types without printing JavaScript: even parentheses and property
+  // spellings affect Node's lexical detection. The wrapper permits CJS return
+  // and new.target, and is removed before top-level reexport analysis.
+  const prefix = 'function __ptc_commonjs_evidence__(){\n'
+  const wrapped = `${prefix}${source}\n}`
+  let javascript
+  try {
+    javascript = transformTypeScriptSource(wrapped, { mode: 'strip-only' }).code.slice(prefix.length, -2)
+  } catch (error) {
+    if (error.cause?.code !== 'UnsupportedSyntax') throw error
+    // Legacy TypeScript runtime constructs still use their recorded lowering.
+    const transformed = transformTypeScriptSource(wrapped, { module: false,
+      transform: { noEmptyExport: true } }).code
+    const body = parse(transformed).program.body[0].body
+    javascript = transformed.slice(body.start + 1, body.end - 1)
+  }
+  return javascript
+}

package/internal/compiler-amaro.cjs

@@ -0,0 +1,2 @@
+// Resolve through the private platform at operation time, not core startup.
+module.exports = () => require('amaro')

package/internal/compiler-compression.js

@@ -0,0 +1,12 @@
+import { deflateSync, inflateSync } from 'fflate/browser'
+
+/** Callable catalog blocks retain the raw DEFLATE wire format. The private
+ * compiler owns the library's JavaScript globals and typed-array operations. */
+export const deflateRawSync = input => Buffer.from(deflateSync(input))
+
+export function inflateRawSync(input, { maxOutputLength } = {}) {
+  const output = maxOutputLength === undefined ? undefined : new Uint8Array(maxOutputLength + 1)
+  const result = inflateSync(input, { out: output })
+  if (output !== undefined && result.length > maxOutputLength) throw new RangeError('callable source block exceeds its declared limit')
+  return Buffer.from(result)
+}

package/internal/compiler-data.js

@@ -0,0 +1,58 @@
+import { types } from 'node:util'
+import { SourceMapRuns, SOURCE_MAP_RUNS } from './source-position-map.js'
+import { compilerDescriptors } from './compiler-descriptors.js'
+
+const { isMap, isSet, isUint32Array } = types
+const ownKeys = Reflect.ownKeys
+const descriptor = Object.getOwnPropertyDescriptor
+const defineData = compilerDescriptors.defineDataProperty
+const setPrototypeOf = Object.setPrototypeOf
+const stringify = JSON.stringify
+const array = Array.isArray
+const NativeMap = Map, NativeSet = Set, NativeUint32Array = Uint32Array, NativeTypeError = TypeError
+const uncurry = Function.prototype.bind.bind(Function.prototype.call)
+const mapForEach = uncurry(Map.prototype.forEach), mapSet = uncurry(Map.prototype.set)
+const setForEach = uncurry(Set.prototype.forEach), setAdd = uncurry(Set.prototype.add)
+
+/** Compiler messages contain data only. Rehome collections instead of invoking
+ * methods inherited from a caller's mutable realm. No user value crosses here. */
+export function copyCompilerData(value) {
+  return copyData(value, false)
+}
+
+/** Internal JSON keys have data fields, never inherited source serialization
+ * hooks. Source values continue to use their own realm's JSON operations. */
+export function stringifyCompilerData(value) {
+  return stringify(copyData(value, true))
+}
+
+function copyData(value, json) {
+  if (value === null || typeof value !== 'object') {
+    if (typeof value === 'function' || typeof value === 'symbol') throw new NativeTypeError('compiler messages must contain data')
+    return value
+  }
+  if (!json && isUint32Array(value)) return new NativeUint32Array(value)
+  if (!json && descriptor(value, SOURCE_MAP_RUNS)?.value === true) return new SourceMapRuns(copyData(value.data, false))
+  if (!json && isMap(value)) {
+    const result = new NativeMap()
+    mapForEach(value, (item, key) => mapSet(result, copyData(key, false), copyData(item, false)))
+    return result
+  }
+  if (!json && isSet(value)) {
+    const result = new NativeSet()
+    setForEach(value, item => setAdd(result, copyData(item, false)))
+    return result
+  }
+  const result = array(value) ? [] : {}
+  if (json) setPrototypeOf(result, null)
+  const keys = ownKeys(value)
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index]
+    if (key === 'length' && array(value)) continue
+    const field = descriptor(value, key)
+    if (!('value' in field)) throw new NativeTypeError('compiler messages must not contain accessors')
+    defineData(result, key, copyData(field.value, json), field.enumerable)
+  }
+  if (array(value)) result.length = value.length
+  return result
+}

package/internal/compiler-descriptors.js

@@ -0,0 +1,54 @@
+/** Private descriptors contain own fields only. Native source reflection keeps
+ * its separate ToPropertyDescriptor behavior, including inherited fields. */
+export function createCompilerDescriptors(object, reflect) {
+  const define = object.defineProperty, defineMany = object.defineProperties
+  const ownKeys = reflect.ownKeys, ownField = object.getOwnPropertyDescriptor
+  const reflectDefine = reflect.defineProperty
+  const descriptor = fields => ({ __proto__: null, ...fields })
+  const ownedObject = function(value) { return object(value) }
+  const names = object.getOwnPropertyNames(object)
+  for (let index = 0; index < names.length; index++) {
+    const name = names[index]
+    if (name !== 'name' && name !== 'length' && name !== 'prototype') {
+      define(ownedObject, name, descriptor(ownField(object, name)))
+    }
+  }
+  const operations = {
+    Object: ownedObject,
+    descriptor,
+    getOwnPropertyDescriptor(target, key) {
+      const fields = ownField(target, key)
+      return fields === void 0 ? void 0 : descriptor(fields)
+    },
+    defineProperty: (target, key, fields) => define(target, key, descriptor(fields)),
+    reflectDefineProperty: (target, key, fields) => reflectDefine(target, key, descriptor(fields)),
+    // Rehomed compiler data always writes an owned data field. The null
+    // prototype still keeps native descriptor conversion from reaching an
+    // inherited field, and this writer reaches it without the intermediate
+    // own-field descriptor the generic path copies for every property.
+    defineDataProperty(target, key, value, enumerable) {
+      const fields = { __proto__: null }
+      fields.value = value
+      fields.enumerable = enumerable
+      fields.writable = true
+      fields.configurable = true
+      return define(target, key, fields)
+    },
+    defineProperties(target, fields) {
+      const table = { __proto__: null }, keys = ownKeys(fields)
+      for (let index = 0; index < keys.length; index++) {
+        const key = keys[index]
+        if (ownField(fields, key).enumerable) table[key] = descriptor(fields[key])
+      }
+      return defineMany(target, table)
+    },
+  }
+  ownedObject.defineProperty = operations.defineProperty
+  ownedObject.defineProperties = operations.defineProperties
+  ownedObject.getOwnPropertyDescriptor = operations.getOwnPropertyDescriptor
+  return operations
+}
+
+// The same construction contract is instantiated in emitted realms.
+export const compilerDescriptorSource = Function.prototype.toString.call(createCompilerDescriptors)
+export const compilerDescriptors = createCompilerDescriptors(Object, Reflect)

package/internal/compiler-dynamic-cache.js

@@ -0,0 +1,48 @@
+import { copyCompilerData } from './compiler-data.js'
+
+/** Reuse syntax preparation, never an eval activation or its values. Callable
+ * source facts are live inputs and must still match before a result is reused. */
+export function createCachedDynamicCompiler(compute, { maxEntries = 64, maxCharacters = 2 * 1024 * 1024 } = {}) {
+  const entries = new Map()
+  let characters = 0
+  return (source, options = {}) => {
+    const { resolveOriginalSource, ...syntax } = options
+    // Cell plans carry operation owners and generation-specific callbacks.
+    if (syntax.cell !== undefined || typeof source !== 'string') return compute(source, options)
+    const key = JSON.stringify([source, syntax])
+    if (maxEntries <= 0 || key.length > maxCharacters) return compute(source, options)
+    const resolved = new Map()
+    const resolve = text => {
+      if (!resolved.has(text)) resolved.set(text, resolveOriginalSource?.(text))
+      return resolved.get(text)
+    }
+    const cached = entries.get(key)
+    if (cached !== undefined) {
+      entries.delete(key)
+      characters -= cached.characters
+      if (cached.sources.every(([text, original]) => resolve(text) === original)) {
+        entries.set(key, cached)
+        characters += cached.characters
+        return copyCompilerData(cached.value)
+      }
+    }
+    const sources = new Map()
+    const value = compute(source, { ...syntax, resolveOriginalSource(text) {
+      const original = resolve(text)
+      sources.set(text, original)
+      return original
+    } })
+    const record = { value, sources: [...sources] }
+    record.characters = key.length + JSON.stringify(record).length
+    if (record.characters <= maxCharacters) {
+      while (entries.size >= maxEntries || characters + record.characters > maxCharacters) {
+        const oldest = entries.keys().next().value
+        characters -= entries.get(oldest).characters
+        entries.delete(oldest)
+      }
+      entries.set(key, record)
+      characters += record.characters
+    }
+    return copyCompilerData(value)
+  }
+}

package/internal/compiler-entry.js

@@ -0,0 +1,35 @@
+import { prepareProgram, prepareConsoleProgram, classifyDurability } from './cell-analysis.js'
+import { PreflightError } from './cell-analysis-contract.js'
+import { ModuleRewriteError } from './cell-rewriter.js'
+import { compileDynamicEnvironmentSource } from './dynamic-environment-compiler.js'
+import { compileStatefulModule, detectModuleSourceFormat, attachModuleNamespace,
+  linkCommonJsEvidenceSource } from './module-compilation.js'
+import { copyCompilerData } from './compiler-data.js'
+import { identifier, exportedSymbols, sourceDurability } from './binding-source-analysis.js'
+import { hashText, deflateText, inflateText } from './compiler-text.js'
+import { createCallableSourceCatalog } from './callable-source-encoding.js'
+import { createCachedDynamicCompiler } from './compiler-dynamic-cache.js'
+
+const operations = { prepareProgram, prepareConsoleProgram, classifyDurability,
+  compileDynamicEnvironmentSource: createCachedDynamicCompiler(compileDynamicEnvironmentSource),
+  compileStatefulModule, detectModuleSourceFormat, attachModuleNamespace, linkCommonJsEvidenceSource,
+  identifier, exportedSymbols, sourceDurability, hashText, deflateText, inflateText, createCallableSourceCatalog }
+
+/** Synchronous source preparation has no module loader or runtime state. */
+export function compile(operation, input, originalSource) {
+  try {
+    const args = copyCompilerData(input)
+    if (originalSource !== undefined) args[1].resolveOriginalSource = source => originalSource(source)
+    return { value: operations[operation](...args) }
+  } catch (error) {
+    const properties = {}
+    // Parser errors may own methods for cloning diagnostics. Only diagnostic
+    // data crosses the boundary; native error prototypes belong to the caller.
+    for (const [name, field] of Object.entries(Object.getOwnPropertyDescriptors(error))) {
+      if ('value' in field && typeof field.value !== 'function') properties[name] = field
+    }
+    return { error: { kind: error instanceof ModuleRewriteError ? 'ModuleRewriteError'
+      : error instanceof PreflightError ? 'PreflightError' : error.name,
+    message: error.message, properties } }
+  }
+}

package/internal/compiler-generated-names.js

@@ -0,0 +1,17 @@
+/** Babel's transform retains its scope and declaration machinery, while the
+ * complete compilation unit owns uniqueness across separately parsed regions. */
+export function withGeneratedNameAllocator(scope, allocate, transform) {
+  const previous = Object.getOwnPropertyDescriptor(scope, 'generateUid')
+  Object.defineProperty(scope, 'generateUid', { configurable: true, writable: true, value() {
+    const name = allocate('native_temporary')
+    const program = this.getProgramParent()
+    program.references[name] = true
+    program.uids[name] = true
+    return name
+  } })
+  try { return transform() }
+  finally {
+    if (previous === undefined) delete scope.generateUid
+    else Object.defineProperty(scope, 'generateUid', previous)
+  }
+}

package/internal/compiler-intrinsics.js

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

package/internal/compiler-module-links.js

@@ -0,0 +1,34 @@
+import { fileURLToPath } from 'node:url'
+
+const encodeReference = encodeURIComponent
+
+// These ambient inputs must remain outside source-owned CommonJS bindings.
+export const commonJsCompilerGlobals = new Set(['process'])
+
+/** Node's synchronous ESM linker validates protocols before public hooks.
+ * Private references therefore use a native protocol and fail if unclaimed. */
+export function compilerModuleReference(kind, identity) {
+  return `data:text/javascript,throw%20new%20Error(%22Unresolved%20PTC%20module%20link%22)#ptc-${kind}/${encodeReference(identity)}`
+}
+
+const STATIC_LINK_KIND = 'static'
+const ATTRIBUTED_LINK_KIND = 'static-attributed'
+
+/** Reference one static link. Node 22.19 binds every edge that shares a request
+ * URL to the module of the last resolution, so attribute-distinct imports of
+ * one source need distinct native requests. Attribute-bearing links use their
+ * own reference kind and a JSON identity, which no source specifier can equal;
+ * attribute-free links keep the reference they had before attributes were
+ * distinguished. */
+export function staticModuleLinkReference(source, attributes) {
+  const entries = Object.entries(attributes ?? {})
+  if (entries.length === 0) return compilerModuleReference(STATIC_LINK_KIND, source)
+  entries.sort((left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0)
+  return compilerModuleReference(ATTRIBUTED_LINK_KIND, JSON.stringify([source, entries]))
+}
+
+/** Compiler helpers resolve from their own URL, independently of source-owned
+ * wrapper bindings and the ESM translator's restricted CommonJS require. */
+export function commonJsCompilerImport(url) {
+  return `process.getBuiltinModule('module').createRequire(${JSON.stringify(url.href)})(${JSON.stringify(fileURLToPath(url))})`
+}

package/internal/compiler-operations.js

@@ -0,0 +1,61 @@
+import { types as t } from '@babel/core'
+
+/** Binding descriptors belong to a compilation; each AST owns its new operations. */
+export function createCompilerOperationPlanner({ bindings = [], internalBindings = [], environmentName, rootRuntime } = {}) {
+  const compilerBindings = new Set(internalBindings)
+  const sourceInitializers = new Set(bindings.filter(binding => binding.role === 'source-initializer')
+    .map(binding => binding.physicalName))
+  const transports = new Map(bindings.filter(binding => binding.property !== undefined || binding.accessor === true)
+    .map(binding => [binding.physicalName, binding]))
+  const roots = new Set([environmentName, rootRuntime].filter(name => name !== undefined))
+  const ownedBindings = new Set([...compilerBindings, ...transports.keys(), ...roots])
+  const declaration = path => (path.isVariableDeclarator() || path.isFunctionDeclaration())
+    && (compilerBindings.has(path.node.id?.name) || roots.has(path.node.id?.name)) && !sourceInitializers.has(path.node.id.name)
+  const transport = node => t.isIdentifier(node) ? transports.get(node.name)
+    : t.isCallExpression(node) && t.isIdentifier(node.callee) && transports.get(node.callee.name)?.accessor === true
+      ? transports.get(node.callee.name) : undefined
+  const privateReceiver = node => t.isIdentifier(node) && roots.has(node.name)
+  const compilerCall = node => {
+    const callee = node.callee
+    if (t.isIdentifier(callee)) return compilerBindings.has(callee.name) && !sourceInitializers.has(callee.name)
+      || transports.get(callee.name)?.accessor === true
+    if (!t.isMemberExpression(callee) || callee.computed) return false
+    const owner = transport(callee.object)
+    return privateReceiver(callee.object) || owner !== undefined && owner.property !== undefined
+      && callee.property.name !== owner.property
+  }
+  return tree => {
+    const addedBindings = new Set()
+    const internal = { has: name => ownedBindings.has(name) || addedBindings.has(name), add: name => addedBindings.add(name) }
+    const sourceNodes = new WeakSet()
+    const operations = new WeakSet()
+    const values = new WeakSet()
+    const callees = new WeakSet()
+    const operation = node => {
+      operations.add(node)
+      if (node.callee !== undefined) {
+        callees.add(node.callee)
+        t.traverseFast(node.callee, child => operations.add(child))
+      }
+      return node
+    }
+    t.traverseFast(tree, node => sourceNodes.add(node))
+    t.traverseFast(tree, node => {
+      if ((t.isCallExpression(node) || t.isNewExpression(node)) && compilerCall(node)) operation(node)
+    })
+    return {
+      internal,
+      sourceInitializers,
+      declaration,
+      owns: node => operations.has(node),
+      callee: node => callees.has(node),
+      isValue: node => values.has(node),
+      value(node) { values.add(node); return node },
+      operation,
+      generated(output) {
+        // Original argument nodes remain source-owned inside new helper shells.
+        t.traverseFast(output, node => { if (!sourceNodes.has(node)) operations.add(node) })
+      },
+    }
+  }
+}

package/internal/compiler-platform-factory.js

@@ -0,0 +1,84 @@
+/** Compiler dependencies see only containers and callable prototypes owned by
+ * their private realm. The host bridge supplies captured data operations. */
+export function createPlatform(bridge) {
+  const copyBytes = bytes => {
+    const result = new Uint8Array(bytes.length)
+    for (let index = 0; index < bytes.length; index++) result[index] = bytes[index]
+    return result
+  }
+  const copyRecord = record => {
+    const result = {}
+    for (const key of Object.keys(record)) result[key] = record[key]
+    return result
+  }
+  // This is the compiler's text codec subset, not a general Node Buffer shim.
+  class CompilerBuffer extends Uint8Array {
+    static from(value, encoding = 'utf8') {
+      if (typeof value !== 'string') {
+        const result = new CompilerBuffer(value.length)
+        for (let index = 0; index < value.length; index++) result[index] = value[index]
+        return result
+      }
+      if (!['utf8', 'utf16le', 'base64'].includes(encoding)) throw new TypeError(`unsupported compiler encoding: ${encoding}`)
+      const { buffer, length } = bridge.encode(value, encoding)
+      const result = new CompilerBuffer(length)
+      for (let index = 0; index < length; index++) result[index] = buffer[index]
+      return result
+    }
+    toString(encoding = 'utf8') {
+      if (!['utf8', 'utf16le', 'base64'].includes(encoding)) throw new TypeError(`unsupported compiler encoding: ${encoding}`)
+      return bridge.decode(this, encoding)
+    }
+  }
+  class CompilerURL {
+    constructor(input, base) { this.href = bridge.url(String(input), base === undefined ? undefined : String(base)) }
+    toString() { return this.href }
+  }
+  class TextEncoder {
+    #encoder = bridge.textEncoder()
+    encode(source = '') { return copyBytes(this.#encoder.encode(source)) }
+    encodeInto(source, output) { return copyRecord(this.#encoder.encodeInto(source, output)) }
+  }
+  class TextDecoder {
+    #decode
+    constructor(label, options) { this.#decode = bridge.textDecoder(label, options) }
+    decode(input, options) { return this.#decode(input, options) }
+  }
+  class SourceMap {
+    #map
+    constructor(payload) { this.#map = bridge.sourceMap(payload) }
+    findEntry(line, column) { return copyRecord(this.#map.findEntry(line, column)) }
+    findOrigin(line, column) { return copyRecord(this.#map.findOrigin(line, column)) }
+  }
+  const unavailable = () => { throw new Error('compiler dependencies cannot access the filesystem or load configuration') }
+  const modules = {
+    buffer: { Buffer: CompilerBuffer },
+    crypto: { createHash(algorithm) {
+      const hash = bridge.hash(algorithm)
+      return { update(source, encoding) { hash.update(source, encoding); return this },
+        digest(encoding) { return hash.digest(encoding) } }
+    } },
+    module: { SourceMap, stripTypeScriptTypes: (source, options) => bridge.stripTypeScriptTypes(source, options) },
+    url: { URL: CompilerURL, fileURLToPath: url => bridge.fileURLToPath(String(url)) },
+    util: { TextEncoder, TextDecoder, deprecate: callback => callback,
+      types: { isMap: value => bridge.typeChecks.isMap(value), isSet: value => bridge.typeChecks.isSet(value),
+        isUint32Array: value => bridge.typeChecks.isUint32Array(value) } },
+    tty: { isatty: () => false },
+    fs: { existsSync: unavailable, statSync: unavailable, readFileSync: unavailable,
+      readFile: unavailable, stat: unavailable },
+    assert(value, message) { if (!value) throw new Error(message) },
+  }
+  return {
+    require(name) {
+      const key = name.startsWith('node:') ? name.slice(5) : name
+      if (key.startsWith('compiler-asset:')) return bridge.loadAsset(key)
+      if (key === 'typescript' || key === 'amaro') return bridge.loadDependency(key)
+      if (!Object.hasOwn(modules, key)) throw new Error(`compiler cannot load dependency: ${name}`)
+      return modules[key]
+    },
+    process: { env: {}, version: `v${bridge.nodeVersion}`, versions: { node: bridge.nodeVersion },
+      platform: bridge.platform, features: { typescript: bridge.typescript }, cwd: () => bridge.cwd,
+      argv: [], stdout: { fd: 1, isTTY: false }, stderr: { fd: 2, isTTY: false } },
+    Buffer: CompilerBuffer, URL: CompilerURL, TextEncoder, TextDecoder,
+  }
+}