dsh-ptc-plus 0.3.1 → 0.4.1

package/internal/source-position-map.js

@@ -1,3 +1,59 @@
+import { TraceMap, decodedMappings } from '@jridgewell/trace-mapping'
+
+export const SOURCE_MAP_RUNS = Symbol.for('ptc.compiler.source-map-runs')
+
+export class SourceMapRuns {
+  constructor(data) { this.data = data; this.length = data.length / 4; this[SOURCE_MAP_RUNS] = true }
+  at(index) {
+    if (index < 0) index += this.length
+    if (index < 0 || index >= this.length) return undefined
+    const offset = index * 4
+    return { generatedStart: this.data[offset], generatedEnd: this.data[offset + 1],
+      originalStart: this.data[offset + 2], originalEnd: this.data[offset + 3] }
+  }
+  *[Symbol.iterator]() { for (let index = 0; index < this.length; index++) yield this.at(index) }
+}
+
+const isSourceMap = value => Array.isArray(value) || value instanceof SourceMapRuns
+
+const validMappingOffset = value => Number.isSafeInteger(value) && value >= 0 && value <= 0xffffffff
+
+/** Numeric mapping runs avoid retaining an object for every copied token. */
+export function createSourceMapBuilder() {
+  const blocks = []
+  const blockLength = 4096
+  let size = 0
+  // Positional writes keep the hot mapping paths from allocating a segment
+  // object that is immediately taken apart again.
+  const pushValues = (generatedStart, generatedEnd, originalStart, originalEnd) => {
+    if (!validMappingOffset(generatedStart) || !validMappingOffset(generatedEnd)
+      || !validMappingOffset(originalStart) || !validMappingOffset(originalEnd)) {
+      throw new RangeError('source mapping offsets must fit a source buffer')
+    }
+    if (size % blockLength === 0) blocks.push(new Uint32Array(blockLength))
+    const block = blocks.at(-1), offset = size % blockLength
+    block[offset] = generatedStart
+    block[offset + 1] = generatedEnd
+    block[offset + 2] = originalStart
+    block[offset + 3] = originalEnd
+    size += 4
+  }
+  return {
+    push({ generatedStart, generatedEnd, originalStart, originalEnd }) {
+      pushValues(generatedStart, generatedEnd, originalStart, originalEnd)
+    },
+    pushValues,
+    finish(compact = false) {
+      const data = new Uint32Array(size)
+      for (let index = 0; index < blocks.length; index++) {
+        data.set(blocks[index].subarray(0, Math.min(blockLength, size - index * blockLength)), index * blockLength)
+      }
+      const runs = new SourceMapRuns(data)
+      return !compact && runs.length < 4096 ? [...runs] : runs
+    },
+  }
+}
+
 export function identitySourceMap(length) {
   return [{ generatedStart: 0, generatedEnd: length, originalStart: 0, originalEnd: length }]
 }
@@ -42,16 +98,26 @@ export function createMappedTextBuilder(source, sourceOffset = 0) {
   }
 }
 
-function originalOffsetAt(sourceMap, generatedOffset) {
+function segmentIndexAt(sourceMap, generatedOffset) {
   let low = 0
   let high = sourceMap.length
+  const packed = sourceMap instanceof SourceMapRuns ? sourceMap.data : undefined
   while (low < high) {
     const middle = (low + high) >>> 1
-    if (generatedOffset < sourceMap[middle].generatedEnd) high = middle
+    const end = packed === undefined ? sourceMap.at(middle).generatedEnd : packed[middle * 4 + 1]
+    if (generatedOffset < end) high = middle
     else low = middle + 1
   }
-  const segment = sourceMap[low] ?? sourceMap.at(-1)
+  return low
+}
+
+export function sourceOffsetAt(sourceMap, generatedOffset) {
+  const segment = sourceMap.at(segmentIndexAt(sourceMap, generatedOffset)) ?? sourceMap.at(-1)
   if (segment === undefined) return generatedOffset
+  return segmentOffsetAt(segment, generatedOffset)
+}
+
+function segmentOffsetAt(segment, generatedOffset) {
   const generatedLength = segment.generatedEnd - segment.generatedStart
   const originalLength = segment.originalEnd - segment.originalStart
   const localOffset = Math.max(0, generatedOffset - segment.generatedStart)
@@ -62,51 +128,64 @@ function originalOffsetAt(sourceMap, generatedOffset) {
     + Math.floor((localOffset * (originalLength - 1)) / (generatedLength - 1))
 }
 
+/** A copied interval is already bounded by this segment. Its endpoints need
+ * no additional search through the complete source map. */
+function copiedSegmentOriginal(segment, start, end) {
+  return [segmentOffsetAt(segment, start),
+    segmentOffsetAt(segment, end - 1) + (segment.originalEnd > segment.originalStart ? 1 : 0)]
+}
+
 function mappedOffsetRange(sourceMap, start, end) {
+  const lastOffset = Math.max(start, end - 1)
+  const last = sourceMap.at(segmentIndexAt(sourceMap, lastOffset)) ?? sourceMap.at(-1)
+  const hasSourceCharacter = last === undefined || lastOffset < last.generatedEnd && last.originalEnd > last.originalStart
+  const originalLast = last === undefined ? lastOffset : segmentOffsetAt(last, lastOffset)
   return {
-    originalStart: originalOffsetAt(sourceMap, start),
-    originalEnd: originalOffsetAt(sourceMap, Math.max(start, end - 1)) + (end > start ? 1 : 0),
+    originalStart: start === lastOffset ? originalLast : sourceOffsetAt(sourceMap, start),
+    originalEnd: originalLast + (end > start && hasSourceCharacter ? 1 : 0),
   }
 }
 
-function replacementSegments(sourceMap, start, end, replacementLength, mappings) {
+/** Replacement runs reach the mapping builder as positional writes. The
+ * generator this replaced allocated a segment object for every emitted run. */
+function emitReplacementSegments(sourceMap, start, end, replacementLength, mappings, emit) {
   const { originalStart: startOriginal, originalEnd: endOriginal } = mappedOffsetRange(sourceMap, start, end)
-  if (!Array.isArray(mappings) || mappings.length === 0) {
-    return replacementLength === 0 ? [] : [{
-      generatedStart: start,
-      generatedEnd: start + replacementLength,
-      originalStart: startOriginal,
-      originalEnd: endOriginal,
-    }]
-  }
-  const segments = []
+  if (!isSourceMap(mappings) || mappings.length === 0) {
+    if (replacementLength !== 0) emit(start, start + replacementLength, startOriginal, endOriginal)
+    return
+  }
   let cursor = 0
+  let anchorOffset = start
   for (const mapping of mappings) {
     if (mapping.generatedStart > cursor) {
-      segments.push({
-        generatedStart: start + cursor,
-        generatedEnd: start + mapping.generatedStart,
-        originalStart: startOriginal,
-        originalEnd: endOriginal,
-      })
+      const nextAnchor = sourceOffsetAt(sourceMap, mapping.originalStart)
+      emit(start + cursor, start + mapping.generatedStart, nextAnchor, nextAnchor)
+    }
+    if (mapping.generatedEnd - mapping.generatedStart === mapping.originalEnd - mapping.originalStart
+      && mapping.originalEnd > mapping.originalStart) {
+      // A verbatim copy retains every previous boundary, including inserted
+      // compiler text. Collapsing its endpoints would interpolate that text
+      // into source positions and corrupt later call/write provenance.
+      for (let index = segmentIndexAt(sourceMap, mapping.originalStart); index < sourceMap.length; index++) {
+        const segment = sourceMap.at(index)
+        if (segment.generatedStart >= mapping.originalEnd) break
+        const from = Math.max(mapping.originalStart, segment.generatedStart)
+        const to = Math.min(mapping.originalEnd, segment.generatedEnd)
+        const [originalStart, originalEnd] = copiedSegmentOriginal(segment, from, to)
+        emit(start + mapping.generatedStart + from - mapping.originalStart,
+          start + mapping.generatedStart + to - mapping.originalStart, originalStart, originalEnd)
+      }
+    } else {
+      const { originalStart, originalEnd } = mappedOffsetRange(sourceMap, mapping.originalStart, mapping.originalEnd)
+      emit(start + mapping.generatedStart, start + mapping.generatedEnd, originalStart, originalEnd)
     }
-    const original = mappedOffsetRange(sourceMap, mapping.originalStart, mapping.originalEnd)
-    segments.push({
-      generatedStart: start + mapping.generatedStart,
-      generatedEnd: start + mapping.generatedEnd,
-      ...original,
-    })
     cursor = mapping.generatedEnd
+    anchorOffset = mapping.originalEnd
   }
   if (cursor < replacementLength) {
-    segments.push({
-      generatedStart: start + cursor,
-      generatedEnd: start + replacementLength,
-      originalStart: startOriginal,
-      originalEnd: endOriginal,
-    })
+    const anchor = sourceOffsetAt(sourceMap, anchorOffset)
+    emit(start + cursor, start + replacementLength, anchor, anchor)
   }
-  return segments
 }
 
 export function applySourceEdits(code, sourceMap, edits) {
@@ -120,12 +199,12 @@ export function applySourceEdits(code, sourceMap, edits) {
     if (!Number.isSafeInteger(item.start) || !Number.isSafeInteger(item.end)
       || item.start < 0 || item.end < item.start || item.end > code.length
       || item.start < previousEnd || typeof text !== 'string'
-      || (item.mappings !== undefined && !Array.isArray(item.mappings))
+      || (item.mappings !== undefined && !isSourceMap(item.mappings))
       || (item.start === item.end && previous?.start === item.start && previous.end === item.end)) {
       throw new RangeError('source edits must be bounded, ordered, and non-overlapping')
     }
-    const itemMappings = [...(item.mappings ?? [])]
-      .sort((left, right) => left.generatedStart - right.generatedStart)
+    const itemMappings = item.mappings instanceof SourceMapRuns ? item.mappings
+      : [...(item.mappings ?? [])].sort((left, right) => left.generatedStart - right.generatedStart)
     let mappingEnd = 0
     for (const mapping of itemMappings) {
       if (!Number.isSafeInteger(mapping.generatedStart) || !Number.isSafeInteger(mapping.generatedEnd)
@@ -143,27 +222,23 @@ export function applySourceEdits(code, sourceMap, edits) {
   }
 
   const chunks = []
-  const mappings = []
+  const mappings = createSourceMapBuilder()
   let generatedOffset = 0
   let sourceOffset = 0
   let segmentIndex = 0
   const appendUnchanged = end => {
     if (end <= sourceOffset) return
     chunks.push(code.slice(sourceOffset, end))
-    while (segmentIndex < sourceMap.length && sourceMap[segmentIndex].generatedEnd <= sourceOffset) segmentIndex += 1
+    while (segmentIndex < sourceMap.length && sourceMap.at(segmentIndex).generatedEnd <= sourceOffset) segmentIndex += 1
     for (let index = segmentIndex; index < sourceMap.length; index += 1) {
-      const segment = sourceMap[index]
+      const segment = sourceMap.at(index)
       if (segment.generatedStart >= end) break
       const start = Math.max(sourceOffset, segment.generatedStart)
       const stop = Math.min(end, segment.generatedEnd)
       if (stop <= start) continue
-      const { originalStart, originalEnd } = mappedOffsetRange(sourceMap, start, stop)
-      mappings.push({
-        generatedStart: generatedOffset + start - sourceOffset,
-        generatedEnd: generatedOffset + stop - sourceOffset,
-        originalStart,
-        originalEnd,
-      })
+      const [originalStart, originalEnd] = copiedSegmentOriginal(segment, start, stop)
+      mappings.pushValues(generatedOffset + start - sourceOffset, generatedOffset + stop - sourceOffset,
+        originalStart, originalEnd)
     }
     generatedOffset += end - sourceOffset
     sourceOffset = end
@@ -173,52 +248,117 @@ export function applySourceEdits(code, sourceMap, edits) {
     appendUnchanged(item.start)
     const { text } = item
     chunks.push(text)
-    mappings.push(...replacementSegments(sourceMap, item.start, item.end, text.length, item.mappings)
-      .map(segment => ({ ...segment, generatedStart: segment.generatedStart - item.start + generatedOffset,
-        generatedEnd: segment.generatedEnd - item.start + generatedOffset })))
+    emitReplacementSegments(sourceMap, item.start, item.end, text.length, item.mappings,
+      (generatedStart, generatedEnd, originalStart, originalEnd) => mappings.pushValues(
+        generatedStart - item.start + generatedOffset, generatedEnd - item.start + generatedOffset,
+        originalStart, originalEnd))
     generatedOffset += text.length
     sourceOffset = item.end
   }
   appendUnchanged(code.length)
-  return { code: chunks.join(''), sourceMap: mappings }
+  return { code: chunks.join(''), sourceMap: mappings.finish() }
+}
+
+const LINE_TERMINATORS = /\r\n|[\n\r\u2028\u2029]/gu
+
+/** JavaScript source coordinates count CRLF as one line boundary. */
+export function sourceLineStarts(source) {
+  const starts = [0]
+  for (const match of source.matchAll(LINE_TERMINATORS)) starts.push(match.index + match[0].length)
+  return starts
+}
+
+/** Visit maintained emitter coordinates without re-encoding available raw maps.
+ * All line numbers at this boundary are zero-based; absent origins stay absent. */
+export function visitSourceMappings(transformed, visit) {
+  const raw = transformed.rawMappings
+  if (raw !== undefined) {
+    for (const item of raw) visit(item.generated.line - 1, item.generated.column,
+      item.original === undefined ? undefined : item.original.line - 1, item.original?.column)
+    return
+  }
+  const nativeMap = new TraceMap(typeof transformed.map === 'string' ? JSON.parse(transformed.map) : transformed.map)
+  for (const [line, entries] of decodedMappings(nativeMap).entries()) {
+    for (const entry of entries) visit(line, entry[0], entry[2], entry[3])
+  }
+}
+
+/** Compose a parser's line/column map with the existing source-offset map. */
+export function mappedSourceTransform(code, sourceMap, transformed) {
+  const starts = sourceLineStarts(code)
+  const generatedStarts = sourceLineStarts(transformed.code)
+  const mappings = createSourceMapBuilder()
+  let previous
+  visitSourceMappings(transformed, (line, column, originalLine, originalColumn) => {
+    const generatedStart = Math.min(transformed.code.length, generatedStarts[line] + column)
+    if (previous !== undefined) {
+      previous.generatedEnd = generatedStart
+      mappings.push(previous)
+    }
+    if (starts[originalLine] === undefined) {
+      previous = undefined
+      return
+    }
+    const originalStart = Math.min(code.length, starts[originalLine] + originalColumn)
+    previous = { generatedStart, generatedEnd: transformed.code.length,
+      originalStart, originalEnd: Math.min(code.length, originalStart + 1) }
+  })
+  if (previous !== undefined) mappings.push(previous)
+  return applySourceEdits(code, sourceMap, [{ start: 0, end: code.length, text: transformed.code, mappings: mappings.finish(true) }])
+}
+
+function lineStartOffset(source, line, starts) {
+  return starts[line - 1] ?? source.length
+}
+
+function positionAtOffset(source, offset, starts) {
+  let low = 0, high = starts.length
+  while (low < high) {
+    const middle = (low + high) >>> 1
+    if (starts[middle] <= offset) low = middle + 1
+    else high = middle
+  }
+  const line = low - 1
+  return { line: line + 1, column: offset - starts[line] + 1 }
 }
 
-function lineStartOffset(source, line) {
-  let offset = 0
-  for (let current = 1; current < line; current += 1) {
-    const newline = source.indexOf('\n', offset)
-    if (newline < 0) return source.length
-    offset = newline + 1
+const coordinateIndexes = new WeakMap()
+function coordinateIndex(sourceMap, generatedSource, originalSource) {
+  let index = coordinateIndexes.get(sourceMap)
+  if (index?.generatedSource !== generatedSource || index.originalSource !== originalSource) {
+    index = { generatedSource, originalSource, generatedStarts: sourceLineStarts(generatedSource),
+      originalStarts: sourceLineStarts(originalSource) }
+    coordinateIndexes.set(sourceMap, index)
   }
-  return offset
+  return index
 }
 
-function positionAtOffset(source, offset) {
-  const prefix = source.slice(0, offset)
-  const line = prefix.split(/\r?\n/).length
-  const lastBreak = prefix.lastIndexOf('\n')
-  return { line, column: offset - lastBreak }
+export function sourceTextAtSpan(source, span, starts = sourceLineStarts(source)) {
+  return source.slice(lineStartOffset(source, span.line, starts) + span.column - 1,
+    lineStartOffset(source, span.end.line, starts) + span.end.column - 1)
 }
 
-export function mapSourcePosition(position, generatedSource, originalSource, sourceMap) {
+export function mapSourcePosition(position, generatedSource, originalSource, sourceMap, coordinates) {
   if (position === undefined || sourceMap === undefined) return position
   if (!Number.isSafeInteger(position.line) || position.line < 1
     || !Number.isSafeInteger(position.column) || position.column < 1) return position
-  const lineStart = lineStartOffset(generatedSource, position.line)
-  const mappedOffset = originalOffsetAt(sourceMap, lineStart + position.column - 1)
-  return positionAtOffset(originalSource, mappedOffset)
+  const index = coordinates ?? coordinateIndex(sourceMap, generatedSource, originalSource)
+  const lineStart = lineStartOffset(generatedSource, position.line, index.generatedStarts)
+  const mappedOffset = sourceOffsetAt(sourceMap, lineStart + position.column - 1)
+  return positionAtOffset(originalSource, mappedOffset, index.originalStarts)
 }
 
 /** Map a complete generated-source span into original cell coordinates. */
-export function mapSourceSpan(span, generatedSource, originalSource, sourceMap) {
+export function mapSourceSpan(span, generatedSource, originalSource, sourceMap, coordinates) {
   if (span === undefined) return undefined
-  const start = mapSourcePosition(span, generatedSource, originalSource, sourceMap)
+  const start = mapSourcePosition(span, generatedSource, originalSource, sourceMap, coordinates)
   if (span.end === undefined) return start === span ? span : start
   if (!Number.isSafeInteger(span.end.line) || span.end.line < 1
     || !Number.isSafeInteger(span.end.column) || span.end.column < 1) {
     return { ...start, end: span.end }
   }
-  const generatedEnd = lineStartOffset(generatedSource, span.end.line) + span.end.column - 1
+  const index = coordinates ?? coordinateIndex(sourceMap, generatedSource, originalSource)
+  const generatedEnd = lineStartOffset(generatedSource, span.end.line, index.generatedStarts) + span.end.column - 1
   const original = mappedOffsetRange(sourceMap, Math.max(0, generatedEnd - 1), generatedEnd)
-  return { ...start, end: positionAtOffset(originalSource, original.originalEnd) }
+  return { ...start, end: positionAtOffset(originalSource, original.originalEnd, index.originalStarts) }
 }

package/internal/stateful-module-compiler.js

@@ -0,0 +1,154 @@
+import { compilerModuleReference } from './compiler-module-links.js'
+import { readFileSync } from 'node:fs'
+import { createRequire, findPackageJSON } from 'node:module'
+import { basename, extname } from 'node:path'
+import { compileModuleSource, detectModuleSourceFormat, attachNamespaceSource,
+  linkCommonJsEvidenceSource } from './compiler-service.js'
+import { managedModuleAdapter, loadManagedModuleAdapter, recordStatefulModuleResolution, reserveStatefulModule,
+  statefulModuleLink, resolveStatefulModuleLink } from './stateful-module-runtime.js'
+import { createCommonJsEvidence } from './commonjs-export-evidence.js'
+import { USER_BINDING_TRANSFORM } from './module-transform-contract.js'
+import { createDynamicEnvironmentRuntime } from './dynamic-environment-runtime.js'
+import { moduleRuntimeIntrinsics } from './compiler-intrinsics.js'
+import { compilerPlatformBridge } from './compiler-platform.js'
+
+const { Map, Set, Object, Reflect, mapGet, mapHas, mapSet, setHas, setAdd, includes, startsWith,
+  replaceAllString, includesString } = moduleRuntimeIntrinsics
+const readSourceFile = readFileSync, nativeCreateRequire = createRequire, packageJsonPath = findPackageJSON
+const pathBasename = basename, pathExtension = extname, parseJson = JSON.parse
+const bufferFrom = Buffer.from, bufferToString = Buffer.prototype.toString
+const sourceText = source => typeof source === 'string' ? source
+  : Reflect.apply(bufferToString, bufferFrom(source), ['utf8'])
+const sourcePath = compilerPlatformBridge.fileURLToPath
+
+// Dependencies installed under a package's node_modules belong to Node's
+// module owner. Compiling them as if they were session source needlessly
+// parses and retains large third-party programs (for example TypeScript),
+// while providing no PTC binding continuity: only session-owned modules can
+// publish logical bindings. Namespace adaptation still wraps their native
+// result at the managed module boundary.
+function isExternalDependency(url) {
+  if (!startsWith(url, 'file:')) return false
+  const path = replaceAllString(sourcePath(url), '\\', '/')
+  return includesString(path, '/node_modules/')
+}
+
+/** Source generation returns link facts; the runtime owns registration. */
+export function compileStatefulModule(source, options) {
+  const prepared = compileModuleSource(source, options)
+  for (let index = 0; index < prepared.staticLinks.length; index++) {
+    const link = prepared.staticLinks[index]
+    statefulModuleLink(link.source, link.reference)
+  }
+  // Install reflection facts before Node can expose hoisted exports to a
+  // cyclic importer. Catalog data never enters the user's executable source.
+  if (prepared.callableSources?.length > 0) {
+    createDynamicEnvironmentRuntime().installIntrinsics().registerSources(prepared.callableSources)
+  }
+  return prepared
+}
+
+function commonJsLoadFormat(url, source) {
+  if (!startsWith(url, 'file:')) return undefined
+  const extension = pathExtension(sourcePath(url))
+  if (extension === '.mjs' || extension === '.mts') return 'module'
+  if (extension === '.cjs' || extension === '.cts') return 'commonjs'
+  if (extension !== '.js' && extension !== '.ts' && extension !== '') return undefined
+  const packagePath = packageJsonPath(url)
+  if (packagePath !== undefined && pathBasename(packagePath) === 'package.json') {
+    const type = parseJson(readSourceFile(packagePath, 'utf8')).type
+    if (type === 'module' || type === 'commonjs') return type
+  }
+  return detectModuleSourceFormat(source, { extension })
+}
+
+let nextNamespaceReference = 0
+function attachModuleNamespace(url, source, attributes, references, sourceRegions) {
+  const reference = compilerModuleReference('self', ++nextNamespaceReference)
+  mapSet(references, reference, url)
+  const text = sourceText(source)
+  return attachNamespaceSource(text, attributes, reference, sourceRegions)
+}
+
+/** Track execution-owned module graphs without changing Node's URL identity. */
+export function createUserModuleCompilationHooks({ transformForParent = () => undefined } = {}) {
+  const modules = new Map()
+  const compiled = new Set()
+  const loaded = new Set()
+  const interfaces = new Map()
+  const namespaceReferences = new Map()
+  const sourceRegionPlans = new Map()
+  const commonJsSources = new Map()
+  const commonJsEvidence = createCommonJsEvidence({ linkSource: linkCommonJsEvidenceSource })
+  const bootstrapFiles = new Set()
+  const bootstrapNames = Object.keys(nativeCreateRequire(import.meta.url).cache)
+  for (let index = 0; index < bootstrapNames.length; index++) setAdd(bootstrapFiles, bootstrapNames[index])
+  const internalRoot = compilerPlatformBridge.url('./', import.meta.url)
+  const mark = (url, { transform = USER_BINDING_TRANSFORM, compiled: prepared = false, moduleInterface, commonJsSource, sourceRegions } = {}) => {
+    if (!setHas(compiled, url) && !setHas(loaded, url)) mapSet(modules, url, transform)
+    if (prepared) {
+      setAdd(compiled, url)
+      mapSet(sourceRegionPlans, url, sourceRegions)
+      if (commonJsSource !== undefined) mapSet(commonJsSources, url, commonJsSource)
+      if (moduleInterface !== undefined) {
+        mapSet(interfaces, url, moduleInterface)
+        reserveStatefulModule(url, moduleInterface)
+      }
+    }
+  }
+  const recordResolution = (parentUrl, specifier, importAttributes, result) => {
+    recordStatefulModuleResolution(parentUrl, specifier, importAttributes, result.url)
+    const transform = mapGet(modules, parentUrl) ?? transformForParent(parentUrl)
+    // Runtime links are outside the user compilation graph. Skipping only
+    // their load would still propagate user transforms to their dependencies.
+    if (transform !== undefined && !startsWith(result.url, 'node:')
+      && !startsWith(result.url, internalRoot) && !isExternalDependency(result.url)) mark(result.url, { transform })
+  }
+  return {
+    mark,
+    resolve(specifier, context, nextResolve) {
+      const evidence = commonJsEvidence.resolve(specifier, context, recordResolution)
+      if (evidence !== undefined) return evidence
+      const link = resolveStatefulModuleLink(specifier, context)
+      if (link !== undefined) return link
+      const namespaceUrl = mapGet(namespaceReferences, specifier)
+      if (namespaceUrl !== undefined) return { url: namespaceUrl, shortCircuit: true }
+      const parentUrl = context.parentURL
+      const parentAdapter = managedModuleAdapter(parentUrl)
+      if (parentAdapter?.kind === 'module' && specifier === parentAdapter.source) {
+        return { ...parentAdapter.resolution, shortCircuit: true }
+      }
+      const importAttributes = { ...context.importAttributes }
+      const result = nextResolve(specifier, context)
+      recordResolution(parentUrl, specifier, importAttributes, result)
+      return result
+    },
+    load(url, context, nextLoad) {
+      const evidence = commonJsEvidence.load(url)
+      if (evidence !== undefined) return evidence
+      const attributes = { ...context.importAttributes }
+      const adapter = loadManagedModuleAdapter(url, attributes)
+      if (adapter !== undefined) return adapter
+      const result = nextLoad(url, context)
+      const transform = mapGet(modules, url)
+      if (transform === undefined
+        || startsWith(url, internalRoot)
+        || startsWith(url, 'file:') && setHas(bootstrapFiles, sourcePath(url))) return result
+      if (setHas(compiled, url)) return mapHas(interfaces, url)
+        ? { ...result, source: attachModuleNamespace(url, result.source, attributes, namespaceReferences, mapGet(sourceRegionPlans, url)) }
+        : mapHas(commonJsSources, url) ? { ...result, source: commonJsEvidence.attach(url, result.source, mapGet(commonJsSources, url)) } : result
+      const formats = ['module', 'commonjs', 'module-typescript', 'commonjs-typescript']
+      if (result.format !== undefined && result.format !== 'typescript' && !includes(formats, result.format)) return result
+      const source = result.source ?? readSourceFile(sourcePath(url))
+      const text = sourceText(source)
+      const format = result.format === undefined || result.format === 'typescript' ? commonJsLoadFormat(url, text) : result.format
+      if (!includes(formats, format)) return result
+      const target = startsWith(format, 'commonjs') ? 'commonjs' : 'module'
+      const prepared = compileStatefulModule(text, { transform, target, url })
+      setAdd(loaded, url)
+      if (target === 'module') reserveStatefulModule(url, prepared.moduleInterface)
+      return { ...result, format: target, source: target === 'module' ? attachModuleNamespace(url, prepared.code, attributes, namespaceReferences, prepared.sourceRegions)
+        : commonJsEvidence.attach(url, prepared.code, prepared.commonJsSource) }
+    },
+  }
+}