dsh-ptc-plus 0.3.1 → 0.4.1

package/internal/compiler-platform.js

@@ -0,0 +1,136 @@
+import { Buffer } from 'node:buffer'
+import { createHash, Hash } from 'node:crypto'
+import { SourceMap, stripTypeScriptTypes } from 'node:module'
+import { URL, fileURLToPath, pathToFileURL } from 'node:url'
+import { TextDecoder, TextEncoder, types } from 'node:util'
+import { Script } from 'node:vm'
+import { readFileSync } from 'node:fs'
+import { compilerDescriptors } from './compiler-descriptors.js'
+
+const apply = Reflect.apply
+const define = compilerDescriptors.defineProperty
+const descriptor = Object.getOwnPropertyDescriptor
+// Node's named ESM exports can be updated by syncBuiltinESMExports. The bridge
+// retains operations captured before user execution, not their live bindings.
+const NativeURL = URL, NativeSourceMap = SourceMap
+const NativeScript = Script, nativeReadFileSync = readFileSync
+const NativeTextEncoder = TextEncoder, NativeTextDecoder = TextDecoder
+const nativeCreateHash = createHash, nativeFileURLToPath = fileURLToPath
+const nativePathToFileURL = pathToFileURL
+const nativeStripTypeScriptTypes = stripTypeScriptTypes
+const runInContext = Script.prototype.runInContext
+const NativeUint8Array = Uint8Array
+const NativeWeakRef = WeakRef, deref = WeakRef.prototype.deref
+const NativeError = Error
+const parseJson = JSON.parse
+const hasOwn = Object.hasOwn
+const byteLength = Buffer.byteLength
+const codecs = {
+  utf8: { write: Buffer.prototype.utf8Write, slice: Buffer.prototype.utf8Slice },
+  utf16le: { write: Buffer.prototype.ucs2Write, slice: Buffer.prototype.ucs2Slice },
+  base64: { write: Buffer.prototype.base64Write, slice: Buffer.prototype.base64Slice },
+}
+const encoderEncode = NativeTextEncoder.prototype.encode
+const encoderEncodeInto = NativeTextEncoder.prototype.encodeInto
+const decoderDecode = NativeTextDecoder.prototype.decode
+const hashUpdate = Hash.prototype.update, hashDigest = Hash.prototype.digest
+const sourceMapEntry = NativeSourceMap.prototype.findEntry
+const sourceMapOrigin = NativeSourceMap.prototype.findOrigin
+const urlFields = ['href', 'protocol', 'hostname', 'pathname']
+const urlGetters = urlFields.map(name => descriptor(NativeURL.prototype, name).get)
+const cwd = process.cwd()
+const nodeVersion = process.versions.node
+const platform = process.platform
+const typescript = process.features.typescript
+const typeChecks = { isMap: types.isMap, isSet: types.isSet, isUint32Array: types.isUint32Array }
+
+function nativeUrl(input, base) {
+  const url = new NativeURL(input, base)
+  return ownUrl(url)
+}
+
+function ownUrl(url) {
+  // fileURLToPath reads these public accessors. Snapshot their captured native
+  // values on the private instance before calling the platform operation.
+  for (let index = 0; index < urlFields.length; index++) {
+    define(url, urlFields[index], { value: apply(urlGetters[index], url, []) })
+  }
+  return url
+}
+
+export const compilerPlatformBridge = {
+  cwd, nodeVersion, platform, typescript,
+  stripTypeScriptTypes: (source, options) => nativeStripTypeScriptTypes(source, options),
+  url: (input, base) => nativeUrl(input, base).href,
+  fileURLToPath: input => nativeFileURLToPath(nativeUrl(input)),
+  pathToFileURL: input => ownUrl(nativePathToFileURL(input)),
+  encode(source, encoding) {
+    const buffer = new NativeUint8Array(byteLength(source, encoding))
+    const length = apply(codecs[encoding].write, buffer, [source, 0, buffer.length])
+    return { buffer, length }
+  },
+  decode: (buffer, encoding) => apply(codecs[encoding].slice, buffer, [0, buffer.length]),
+  textEncoder() {
+    const encoder = new NativeTextEncoder()
+    return { encode: source => apply(encoderEncode, encoder, [source]),
+      encodeInto: (source, output) => apply(encoderEncodeInto, encoder, [source, output]) }
+  },
+  textDecoder: (label, options) => {
+    const decoder = new NativeTextDecoder(label, options)
+    return (input, options) => apply(decoderDecode, decoder, [input, options])
+  },
+  hash(algorithm) {
+    const hash = nativeCreateHash(algorithm)
+    return { update: (source, encoding) => { apply(hashUpdate, hash, [source, encoding]) },
+      digest: encoding => apply(hashDigest, hash, [encoding]) }
+  },
+  sourceMap(payload) {
+    const map = new NativeSourceMap(payload)
+    define(map, 'findEntry', { value: sourceMapEntry })
+    return { findEntry: (line, column) => apply(sourceMapEntry, map, [line, column]),
+      findOrigin: (line, column) => apply(sourceMapOrigin, map, [line, column]) }
+  },
+  typeChecks,
+}
+
+const platformUrl = new NativeURL('../compiler-platform.cjs', import.meta.url)
+const platformFilename = nativeFileURLToPath(platformUrl)
+let platformScript
+const dependencyFiles = { __proto__: null,
+  typescript: nativeFileURLToPath(new NativeURL('../compiler-typescript.cjs', import.meta.url)),
+  amaro: nativeFileURLToPath(new NativeURL('../compiler-amaro.cjs', import.meta.url)),
+}
+const assetManifestUrl = new NativeURL('../compiler-assets.json', import.meta.url)
+const assetManifestFilename = nativeFileURLToPath(assetManifestUrl)
+const assetManifestHref = assetManifestUrl.href
+let assetFiles
+
+export function installCompilerPlatform(context) {
+  platformScript ??= new NativeScript(nativeReadFileSync(platformFilename, 'utf8'),
+    { __proto__: null, filename: platformFilename, displayErrors: false })
+  define(context, 'module', { value: { exports: {} }, configurable: true, writable: true })
+  apply(runInContext, platformScript, [context, { __proto__: null, displayErrors: false }])
+  const dependencies = { __proto__: null }
+  const platform = context.module.exports.createPlatform({ ...compilerPlatformBridge,
+    loadAsset(name) {
+      assetFiles ??= parseJson(nativeReadFileSync(assetManifestFilename, 'utf8'))
+      if (!hasOwn(assetFiles, name)) throw new NativeError('unknown compiler asset')
+      const filename = nativeFileURLToPath(nativeUrl(assetFiles[name], assetManifestHref))
+      return parseJson(nativeReadFileSync(filename, 'utf8'))
+    },
+    loadDependency(name) {
+      // Fixed optional modules own no program state. A caller holds exports
+      // during use; idle compiler realms need not pin their code or WASM data.
+      let dependency = dependencies[name] === undefined ? undefined : apply(deref, dependencies[name], [])
+      if (dependency === undefined) {
+        const filename = dependencyFiles[name]
+        const script = new NativeScript(nativeReadFileSync(filename, 'utf8'), { __proto__: null, filename, displayErrors: false })
+        dependency = apply(runInContext, script, [context, { __proto__: null, displayErrors: false }])
+        dependencies[name] = new NativeWeakRef(dependency)
+      }
+      return dependency
+    },
+  })
+  const names = ['require', 'process', 'Buffer', 'URL', 'TextEncoder', 'TextDecoder']
+  for (let index = 0; index < names.length; index++) define(context, names[index], { value: platform[names[index]] })
+}

package/internal/compiler-record-roles.js

@@ -0,0 +1,53 @@
+import { types as t } from '@babel/core'
+
+/** Prove ownership from consumers, before helper operations lose binding facts.
+ * Reading a field exposes its value, not its record. Passing or publishing the
+ * record itself requires a known private consumer; uncertainty retains the
+ * ordinary source-facing object contract. */
+export function privateGeneratedRecords(file) {
+  const records = new WeakSet()
+  const resolve = path => {
+    if (!path.isIdentifier()) return path
+    const binding = path.scope.getBinding(path.node.name)
+    return binding?.constant && binding.path.isVariableDeclarator() ? binding.path.get('init') : path
+  }
+  const privateBinding = (binding, seen) => {
+    if (!binding || binding.identifier.loc) return false
+    if (seen.has(binding)) return true
+    seen.add(binding)
+    return binding.referencePaths.every(path => privateUse(path, seen))
+  }
+  const privateUse = (path, seen) => {
+    const parent = path.parentPath
+    if (parent.isMemberExpression() && path.key === 'object') {
+      return !parent.parentPath.isCallExpression({ callee: parent.node })
+        && !parent.parentPath.isOptionalCallExpression({ callee: parent.node })
+        && !parent.parentPath.isTaggedTemplateExpression({ tag: parent.node })
+    }
+    if (parent.isVariableDeclarator() && path.key === 'init' && t.isIdentifier(parent.node.id)) {
+      return privateBinding(parent.scope.getBinding(parent.node.id.name), seen)
+    }
+    if (parent.isAssignmentExpression({ operator: '=' }) && path.key === 'right' && t.isIdentifier(parent.node.left)) {
+      return privateBinding(parent.scope.getBinding(parent.node.left.name), seen)
+        && (parent.parentPath.isExpressionStatement() || privateUse(parent, seen))
+    }
+    if (!parent.isCallExpression() || path.listKey !== 'arguments') return false
+    const callee = resolve(parent.get('callee'))
+    if (!callee.isMemberExpression() || callee.node.computed) return false
+    const receiver = resolve(callee.get('object'))
+    if (callee.node.property.name === 'bind' && receiver.isFunctionExpression() && !receiver.node.loc && path.key > 0) {
+      const parameter = receiver.node.params[path.key - 1]
+      return t.isIdentifier(parameter) && privateBinding(receiver.scope.getBinding(parameter.name), seen)
+    }
+    // Captured descriptor operations consume own fields, never publish the
+    // transport object. Source Object calls have locations and are excluded.
+    return path.key === 2 && callee.node.property.name === 'defineProperty'
+      && receiver.isIdentifier({ name: 'Object' }) && !receiver.node.loc
+  }
+  file.path.traverse({ ObjectExpression(path) {
+    if (!path.node.loc && path.node.properties.every(property => t.isObjectProperty(property)
+      && !property.computed && !t.isIdentifier(property.key, { name: '__proto__' })
+      && !t.isStringLiteral(property.key, { value: '__proto__' })) && privateUse(path, new Set())) records.add(path.node)
+  } })
+  return records
+}

package/internal/compiler-region-output.js

@@ -0,0 +1,259 @@
+import { parse } from '@babel/parser'
+import { types as t } from '@babel/core'
+import { createGeneratedNameAllocator } from './binding-pattern.js'
+import { applySourceEdits, identitySourceMap, createSourceMapBuilder, mappedSourceTransform, sourceLineStarts } from './source-position-map.js'
+
+const REGION_LENGTH = 32768
+
+/** Scheduling closures end with compilation; only source spans reach runtime. */
+export const sourceRegionData = facts => facts === undefined ? undefined : { regions: facts.regions }
+
+function collectSourceFeatures(node, features) {
+  if (node.decorators?.length || node.type === 'ClassAccessorProperty') features.decorated = true
+  if (node.type === 'VariableDeclaration' && (node.kind === 'using' || node.kind === 'await using')) features.resources = true
+  if (node.type === 'WithStatement' || node.type === 'CallExpression'
+    && node.callee.type === 'Identifier' && node.callee.name === 'eval') features.lexicalDynamic = true
+}
+
+/** Lowering decisions use parsed syntax, including features in nested bodies. */
+export function sourceFeatures(tree) {
+  const features = { decorated: false, resources: false, lexicalDynamic: false }
+  t.traverseFast(tree, node => collectSourceFeatures(node, features))
+  return features
+}
+
+/** Native lowering has already established syntax and declaration ownership.
+ * Index its source without creating a whole-module Babel path/scope graph. */
+export function indexSourceRegions(source, options, tree = parse(source, options)) {
+  const regions = []
+  const features = { decorated: false, resources: false, lexicalDynamic: false }
+  const walk = (node, context) => {
+    if (!node) return
+    collectSourceFeatures(node, features)
+    if (t.isFunction(node)) context = { ...context, async: node.async, generator: node.generator, labels: [] }
+    if (node.type === 'LabeledStatement') context = { ...context, labels: [...context.labels ?? [], node.label.name] }
+    if (t.isClass(node)) context = { ...context, strict: true, privateNames: [...context.privateNames ?? [],
+      ...node.body.body.filter(member => member.key?.type === 'PrivateName').map(member => member.key.id.name)] }
+    if (node.directives?.some(item => item.value.value === 'use strict')) context = { ...context, strict: true }
+    if (node.type === 'BlockStatement' && node.end - node.start > REGION_LENGTH / 2) {
+      regions.push({ start: node.start, end: node.end, kind: 'block', ...context })
+    }
+    if (node.type === 'Program' || node.type === 'BlockStatement') {
+      let first, last
+      for (const statement of node.body) {
+        first ??= statement.start
+        last = statement.end
+        if (last - first >= REGION_LENGTH / 2) {
+          regions.push({ start: first, end: last, kind: 'statements', top: node.type === 'Program', ...context })
+          first = undefined
+        }
+      }
+      if (first !== undefined && first !== node.body[0]?.start) {
+        regions.push({ start: first, end: last, kind: 'statements', top: node.type === 'Program', ...context })
+      }
+    }
+    for (const key of t.VISITOR_KEYS[node.type] ?? []) {
+      const child = node[key]
+      if (Array.isArray(child)) { for (const item of child) walk(item, context) }
+      else walk(child, context)
+    }
+  }
+  walk(tree.program, { strict: options.sourceType === 'module' })
+  return { regions, allocate: createGeneratedNameAllocator(tree), ...features }
+}
+
+/** Scheduling uses typed output slots, never scans source for brace-like text. */
+export function sourceRegionPlan(source, facts) {
+  const root = { start: 0, end: source.length, kind: 'program', children: [] }
+  const stack = [root]
+  for (const fact of [...facts?.regions ?? []].sort((a, b) => a.start - b.start || b.end - a.end)) {
+    while (stack.length > 1 && fact.start >= stack.at(-1).end) stack.pop()
+    while (stack.length > 1 && fact.end > stack.at(-1).end) stack.pop()
+    const parent = stack.at(-1)
+    if (parent.start === fact.start && parent.end === fact.end) continue
+    const region = { ...fact, children: [] }
+    parent.children.push(region)
+    stack.push(region)
+  }
+  const trim = region => {
+    if (region.end - region.start <= REGION_LENGTH) region.children = []
+    else for (const child of region.children) trim(child)
+  }
+  trim(root)
+  return root
+}
+
+export function regionInput(source, region, options) {
+  const changes = region.children.map((child, index) => ({ start: child.start - region.start,
+    end: child.end - region.start, text: '{}', child, index }))
+  const body = source.slice(region.start, region.end)
+  const outlined = applySourceEdits(body, identitySourceMap(body.length), changes)
+  const top = (region.kind === 'program' || region.top && region.kind === 'statements')
+    && !(options.wrapCommonJs && options.sourceType === 'commonjs')
+  let prefix = '', suffix = ''
+  if (!top) {
+    prefix = `${region.async ? 'async ' : ''}function${region.generator ? '*' : ''} __ptc_region__(){`
+    if (region.strict) prefix += '"use strict";'
+    for (const label of region.labels ?? []) prefix += `${label}:`
+    prefix += 'while(0){'
+    suffix = '\n}}'
+  }
+  const code = prefix + outlined.code + suffix
+  const parserOptions = { ...options, strictMode: region.strict ?? options.strictMode,
+    allowSuperOutsideMethod: true, allowUndeclaredExports: options.sourceType === 'module', errorRecovery: true }
+  const tree = parse(code, parserOptions)
+  for (const error of tree.errors) {
+    if (error.reasonCode === 'InvalidPrivateFieldResolution' && region.privateNames?.includes(error.details.identifierName)) continue
+    throw error
+  }
+  let selected = tree.program
+  if (!top) {
+    let statement = tree.program.body[0].body.body[0]
+    while (statement.type === 'LabeledStatement') statement = statement.body
+    selected = statement.body
+  }
+  const slots = []
+  let delta = prefix.length
+  for (const change of changes) {
+    slots.push({ start: change.start + delta, end: change.start + delta + change.text.length, child: change.child })
+    delta += change.text.length - (change.end - change.start)
+  }
+  const mappings = createSourceMapBuilder()
+  for (const item of outlined.sourceMap) mappings.push({ ...item,
+    originalStart: item.originalStart + region.start, originalEnd: item.originalEnd + region.start })
+  let mapped = { code: outlined.code, sourceMap: mappings.finish() }
+  if (prefix) mapped = applySourceEdits(mapped.code, mapped.sourceMap, [
+    { start: 0, end: 0, text: prefix }, { start: mapped.code.length, end: mapped.code.length, text: suffix },
+  ])
+  return { tree, selected, code, prefix, suffix, slots, outlined, region, sourceMap: mapped.sourceMap }
+}
+
+/** Edits retain region ownership when a phase changes tokens or inserts helpers. */
+export function applyRegionEdits(mapped, edits) {
+  const ordered = [...edits].sort((a, b) => a.start - b.start || a.end - b.end)
+  const position = (offset, after) => {
+    let delta = 0
+    for (const edit of ordered) {
+      if (edit.end > offset || edit.end === offset && edit.start === edit.end && !after) break
+      delta += (edit.text?.length ?? 0) - (edit.end - edit.start)
+    }
+    return offset + delta
+  }
+  return { ...mapped, ...applySourceEdits(mapped.code, mapped.sourceMap, ordered),
+    ...(mapped.sourceRegions === undefined ? {} : { sourceRegions: { ...mapped.sourceRegions,
+      regions: mapped.sourceRegions.regions.map(region => ({ ...region,
+        start: position(region.start, true), end: position(region.end, false) })) } }) }
+}
+
+export function visitRegionSource(mapped, options, visitor, select) {
+  const root = sourceRegionPlan(mapped.code, mapped.sourceRegions)
+  const visit = region => {
+    if (select === undefined || select(region)) visitor(regionInput(mapped.code, region, { ...options, attachComment: false }))
+    for (const child of region.children) visit(child)
+  }
+  visit(root)
+}
+
+/** Compose exact child slots after the maintained generator emits their parent. */
+export function transformRegionSource(mapped, options, transform, inspectOutput) {
+  const root = sourceRegionPlan(mapped.code, mapped.sourceRegions)
+  const visit = region => {
+    let input = regionInput(mapped.code, region, options)
+    let generated = transform(input)
+    const emission = generated.sourceOffsets === undefined
+      ? mappedSourceTransform(input.code, input.sourceMap, generated)
+      : applySourceEdits(input.code, input.sourceMap,
+        [{ start: 0, end: input.code.length, text: generated.code, mappings: generated.sourceOffsets }])
+    const starts = new Map(input.slots.map(slot => [slot.start, slot]))
+    const ends = new Map(input.slots.map(slot => [slot.end - 1, slot]))
+    let outputSlots = generated.slotRanges
+    let output = inspectOutput !== undefined || outputSlots === undefined && input.slots.length
+      ? regionInput(generated.code, { ...region, start: 0, end: generated.code.length, children: [] },
+        { ...options, attachComment: false }) : undefined
+    if (outputSlots === undefined && input.slots.length) {
+      const inputStarts = sourceLineStarts(input.code), outputStarts = sourceLineStarts(generated.code)
+      const points = generated.mappingPoints ?? generated.rawMappings.filter(item => item.original).map(item => [
+        outputStarts[item.generated.line - 1] + item.generated.column,
+        inputStarts[item.original.line - 1] + item.original.column,
+      ])
+      const origins = new Map(points)
+      outputSlots = []
+      t.traverseFast(output.selected, node => {
+        if (node.type !== 'BlockStatement' || node.body.length || node.directives.length) return
+        const start = node.start - output.prefix.length, end = node.end - output.prefix.length
+        const first = starts.get(origins.get(start)), last = ends.get(origins.get(end - 1))
+        if (first && last && first !== last) throw new Error('compiler changed a typed source-region boundary')
+        const slot = first ?? last
+        if (slot) outputSlots.push({ sourceStart: slot.start, start, end })
+      })
+    }
+    for (const fact of outputSlots ?? []) {
+      const slot = starts.get(fact.sourceStart)
+      if (slot) {
+        if (slot.generatedStart !== undefined) throw new Error('compiler duplicated a typed source-region slot')
+        Object.assign(slot, { generatedStart: fact.start, generatedEnd: fact.end, prefix: fact.prefix })
+      }
+    }
+    const slots = input.slots, emittedCallables = inspectOutput === undefined
+      ? generated.callableRanges ?? [] : inspectOutput(output)
+    input = undefined
+    generated = undefined
+    output = undefined
+    const replacements = slots.map(slot => {
+      if (slot.generatedStart === undefined || slot.generatedEnd === undefined) throw new Error('compiler lost a typed source-region slot')
+      let output = visit(slot.child)
+      if (slot.prefix) {
+        output = { ...output, ...applySourceEdits(output.code, output.sourceMap, [{ start: 0, end: 0, text: slot.prefix }]),
+          regions: output.regions.map(fact => ({ ...fact, start: fact.start + slot.prefix.length, end: fact.end + slot.prefix.length })),
+          callableRanges: output.callableRanges.map(fact => ({ ...fact, start: fact.start + slot.prefix.length, end: fact.end + slot.prefix.length })),
+        }
+      }
+      return { start: slot.generatedStart, end: slot.generatedEnd, output, fact: slot.child }
+    }).sort((a, b) => a.start - b.start)
+    const code = [], sourceMap = createSourceMapBuilder(), regions = [], callableRanges = []
+    let cursor = 0, offset = 0
+    const append = (text, mappings, from = 0, to = text.length) => {
+      code.push(text.slice(from, to))
+      for (const item of mappings) {
+        if (item.generatedEnd <= from) continue
+        if (item.generatedStart >= to) break
+        const left = Math.max(from, item.generatedStart), right = Math.min(to, item.generatedEnd)
+        const linear = item.generatedEnd - item.generatedStart === item.originalEnd - item.originalStart
+        sourceMap.push({ generatedStart: offset + left - from, generatedEnd: offset + right - from,
+          originalStart: item.originalStart + (linear ? left - item.generatedStart : 0),
+          originalEnd: linear ? item.originalStart + right - item.generatedStart : item.originalEnd })
+      }
+      offset += to - from
+    }
+    for (const replacement of replacements) {
+      append(emission.code, emission.sourceMap, cursor, replacement.start)
+      const start = offset
+      for (const fact of replacement.output.regions) regions.push({ ...fact, start: fact.start + start, end: fact.end + start })
+      for (const fact of replacement.output.callableRanges) callableRanges.push({ ...fact, start: fact.start + start, end: fact.end + start })
+      append(replacement.output.code, replacement.output.sourceMap)
+      const { children, ...fact } = replacement.fact
+      regions.push({ ...fact, start, end: offset })
+      cursor = replacement.end
+    }
+    append(emission.code, emission.sourceMap, cursor)
+    const position = value => {
+      let delta = 0
+      for (const item of replacements) {
+        if (value < item.end) break
+        delta += item.output.code.length - (item.end - item.start)
+      }
+      return value + delta
+    }
+    for (const fact of emittedCallables) callableRanges.push({ ...fact,
+      start: position(fact.start), end: position(fact.end) })
+    return { code: code.join(''), sourceMap: sourceMap.finish(true), regions, callableRanges }
+  }
+  const output = visit(root)
+  return { code: output.code, sourceMap: output.sourceMap, callableRanges: output.callableRanges,
+    sourceRegions: { ...mapped.sourceRegions, regions: output.regions } }
+}
+
+/** Validate each emitted grammar region without reparsing expanded whole output. */
+export function validateRegionSource(mapped, options) {
+  visitRegionSource(mapped, options, () => {})
+}

package/internal/compiler-resource-lowering.js

@@ -0,0 +1,103 @@
+import { template, types as t } from '@babel/core'
+
+// Babel owns lexical lifetimes and abrupt-completion routing. This context
+// stores only private state: GetMethod, Call and Await belong to the emitter.
+const contextFactory = template.statement(`function HELPER() {
+  const empty = {__proto__: null}, stack = [];
+  return {
+    __proto__: null, e: empty, stack,
+    validate(value) {
+      if (value != null && INTRINSICS.Object(value) !== value) {
+        throw new INTRINSICS.TypeError('using declarations require an object, function, null, or undefined.');
+      }
+      return value;
+    },
+    add(value, dispose, asynchronous, fallback) {
+      if (value != null && typeof dispose !== 'function') throw new INTRINSICS.TypeError('Object is not disposable.');
+      if (value != null || asynchronous) stack.push({__proto__: null, v: value, d: dispose, a: asynchronous, f: fallback});
+      return value;
+    },
+    suppress(error) {
+      if (this.e !== empty) {
+        if (typeof INTRINSICS.SuppressedError === 'function') error = new INTRINSICS.SuppressedError(error, this.e);
+        else {
+          const suppressed = new INTRINSICS.Error();
+          INTRINSICS.Object.defineProperties(suppressed, {
+            name: {value: 'SuppressedError', writable: true, configurable: true},
+            error: {value: error, writable: true, configurable: true},
+            suppressed: {value: this.e, writable: true, configurable: true}
+          });
+          error = suppressed;
+        }
+      }
+      this.e = error;
+    },
+    finish() { if (this.e !== empty) throw this.e; }
+  };
+}`)
+
+const acquisition = template.expression(`(
+  VALUE = CONTEXT.validate(INITIALIZER),
+  METHOD = VALUE == null ? void 0 : ASYNC ? VALUE[INTRINSICS.Symbol.asyncDispose] : void 0,
+  FALLBACK = ASYNC && METHOD == null,
+  METHOD = VALUE != null && METHOD == null ? VALUE[INTRINSICS.Symbol.dispose] : METHOD,
+  CONTEXT.add(VALUE, METHOD, ASYNC, FALLBACK)
+)`)
+
+const disposal = asynchronous => template.statement(`{
+  let RESOURCE${asynchronous ? ', STATE = 0' : ''};
+  while (RESOURCE = CONTEXT.stack.pop()) {
+    try {
+      ${asynchronous ? 'if (!RESOURCE.a && STATE === 1) { STATE = 0; await void 0; }' : ''}
+      if (RESOURCE.d) {
+        let VALUE, FAILED = false;
+        try { VALUE = (0, INTRINSICS.Reflect.apply)(RESOURCE.d, RESOURCE.v, []); }
+        catch (ERROR) { VALUE = ERROR; FAILED = true; }
+        if (FAILED) {
+          ${asynchronous ? 'if (RESOURCE.f) { STATE |= 2; await void 0; }' : ''}
+          throw VALUE;
+        }
+        ${asynchronous ? 'if (RESOURCE.a) { STATE |= 2; await (RESOURCE.f ? void 0 : VALUE); }' : ''}
+      } ${asynchronous ? 'else { STATE |= 1; }' : ''}
+    } catch (ERROR) { CONTEXT.suppress(ERROR); }
+  }
+  ${asynchronous ? 'if (STATE === 1) await void 0;' : ''}
+  CONTEXT.finish();
+}`, { allowAwaitOutsideFunction: true })
+
+const disposalLoops = [disposal(false), disposal(true)]
+
+/** Replace the maintained lowerer's private protocol at its binding identity.
+ * Inline operations introduce blocks and temporaries, never a source callable
+ * activation. Acquisition completes before the original declaration initializes;
+ * the existing finally still controls return, break, continue and throw. */
+export function lowerResourceOperations(file, intrinsics, allocate) {
+  const helper = file.declarations.usingCtx
+  const intrinsic = t.identifier(intrinsics)
+  const contexts = new Map()
+  file.path.traverse({ VariableDeclarator(path) {
+    if (!t.isCallExpression(path.node.init) || !t.isIdentifier(path.node.init.callee, helper)) return
+    contexts.set(path.scope.getBinding(path.node.id.name), path.parentPath)
+  } })
+  const names = labels => Object.fromEntries(labels.map(label => [label, t.identifier(allocate(`resource_${label.toLowerCase()}`))]))
+  file.path.traverse({ CallExpression: { exit(path) {
+    const callee = path.node.callee
+    if (path.node.loc || !t.isMemberExpression(callee) || callee.computed || !t.isIdentifier(callee.object)) return
+    const declaration = contexts.get(path.scope.getBinding(callee.object.name))
+    if (!declaration) return
+    const common = { CONTEXT: callee.object, INTRINSICS: intrinsic }
+    if (callee.property.name === 'u' || callee.property.name === 'a') {
+      const temporaries = names(['VALUE', 'METHOD', 'FALLBACK'])
+      declaration.insertBefore(t.variableDeclaration('let', Object.values(temporaries).map(name => t.variableDeclarator(t.cloneNode(name)))))
+      path.replaceWith(acquisition({ ...common, ...temporaries,
+        INITIALIZER: path.node.arguments[0], ASYNC: t.booleanLiteral(callee.property.name === 'a') }))
+    } else if (callee.property.name === 'd') {
+      const asynchronous = path.parentPath.isAwaitExpression()
+      const statement = asynchronous ? path.parentPath.parentPath : path.parentPath
+      statement.replaceWith(disposalLoops[Number(asynchronous)]({ ...common,
+        ...names(asynchronous ? ['RESOURCE', 'STATE', 'VALUE', 'FAILED', 'ERROR'] : ['RESOURCE', 'VALUE', 'FAILED', 'ERROR']) }))
+    }
+  } } })
+  file.scope.getBinding(helper.name).path.replaceWith(contextFactory({ HELPER: helper, INTRINSICS: intrinsic }))
+  file.scope.crawl()
+}

package/internal/compiler-scope-facts.js

@@ -0,0 +1,115 @@
+import traverseModule from '@babel/traverse'
+import { types as t } from '@babel/core'
+import { indexSource } from './compiler-source-regions.js'
+import { sourceScopePath, sourceInParameters } from './dynamic-scope-analysis.js'
+
+const traverse = traverseModule.default ?? traverseModule
+
+/** Node supplies these parameters to the CommonJS source activation. */
+export const COMMONJS_PARAMETERS = Object.freeze(['exports', 'require', 'module', '__filename', '__dirname'])
+
+/** Resolve original names against complete declaration ownership, including
+ * parameter/body separation and immutable callable/class self environments. */
+export function resolveSourceBinding(facts, path, name) {
+  for (const scope of sourceScopePath(path)) {
+    const parameterEnvironment = sourceInParameters(path, scope)
+    const bodyScope = facts.functionBodyScopes.get(scope)
+    const body = facts.scopes.get(bodyScope)?.get(name)
+    if (body !== undefined && !parameterEnvironment) return body
+    const own = facts.scopes.get(scope)?.get(name)
+    if (own !== undefined && !(parameterEnvironment && !own.occurrences.some(item => item.role === 'parameter' || item.role === 'self'))) return own
+    const self = facts.scopes.get(facts.functionSelfScopes.get(scope))?.get(name)
+    if (self !== undefined) return self
+    if (t.isClass(scope.block) && facts.names.get(scope.block.id) === name) return undefined
+  }
+  return undefined
+}
+
+/** Retain the grammar's scope edges while omitting unrelated expression work. */
+function shell(node, originals) {
+  const result = { ...node }
+  originals.set(result, node)
+  for (const key of t.VISITOR_KEYS[node.type] ?? []) result[key] = Array.isArray(node[key]) ? [] : null
+  if (t.isFunction(node)) { result.params = []; result.body = t.blockStatement([]) }
+  if (t.isClass(node)) result.body = t.classBody([])
+  if (t.isLabeledStatement(node)) result.label = { ...node.label }
+  if (t.isMethod(node) || t.isObjectProperty(node) || t.isClassProperty(node) || t.isClassPrivateProperty(node)) {
+    result.key = t.isPrivateName(node.key) ? t.privateName(t.identifier(node.key.id.name)) : t.numericLiteral(0)
+  }
+  return result
+}
+
+function pattern(node, copy) {
+  if (node === null) return null
+  const result = copy(node)
+  if (t.isIdentifier(node)) return result
+  if (t.isAssignmentPattern(node)) { result.left = pattern(node.left, copy); result.right ??= t.numericLiteral(0) }
+  else if (t.isRestElement(node)) result.argument = pattern(node.argument, copy)
+  else if (t.isArrayPattern(node)) result.elements = node.elements.map(item => pattern(item, copy))
+  else if (t.isObjectPattern(node)) result.properties = node.properties.map(item => {
+    if (t.isRestElement(item)) return pattern(item, copy)
+    const property = copy(item)
+    property.value = pattern(item.value, copy)
+    return property
+  })
+  return result
+}
+
+/** Unique occurrence names let bounded groups share their ancestry witness.
+ * Babel still owns declaration placement; unrelated expressions stay absent. */
+export function analyzeSourceDeclarations(tree, declarations) {
+  const paths = indexSource(tree)
+  const owners = new Map()
+  const entries = [...declarations]
+  for (let offset = 0; offset < entries.length; offset += 64) {
+    const batch = entries.slice(offset, offset + 64)
+    const originals = new Map(), copies = new Map(), linked = new Set()
+    const copy = node => {
+      let result = copies.get(node)
+      if (result === undefined) { result = shell(node, originals); copies.set(node, result) }
+      return result
+    }
+    for (const [declaration] of batch) {
+      let selected = copy(declaration)
+      if (t.isVariableDeclaration(declaration)) {
+        selected.declarations = declaration.declarations.map(item => {
+          const declarator = copy(item)
+          declarator.id = pattern(item.id, copy)
+          return declarator
+        })
+      } else if (t.isFunction(declaration)) {
+        selected.id = declaration.id && pattern(declaration.id, copy)
+        selected.params = declaration.params.map(item => pattern(item, copy))
+      } else if (t.isClass(declaration)) selected.id = declaration.id && pattern(declaration.id, copy)
+      else if (t.isCatchClause(declaration)) {
+        selected.param = declaration.param && pattern(declaration.param, copy)
+        selected.body ??= t.blockStatement([])
+      } else if (t.isImportDeclaration(declaration)) {
+        selected.source = declaration.source
+        selected.specifiers = declaration.specifiers.map(item => ({ ...item, local: pattern(item.local, copy) }))
+      }
+      let path = paths.get(declaration)
+      while (path.parentPath && !linked.has(path.node)) {
+        linked.add(path.node)
+        const parent = copy(path.parent)
+        if (path.listKey !== null) {
+          if (!parent[path.listKey].includes(selected)) parent[path.listKey].push(selected)
+        }
+        else parent[path.key] = selected
+        selected = parent
+        path = path.parentPath
+      }
+    }
+    const witness = t.file(copies.get(tree.program))
+    const byName = new Map(batch.flatMap(([declaration, occurrences]) => occurrences
+      .map(occurrence => [occurrence.node.name, { occurrence, declaration }])))
+    traverse(witness, { Identifier(path) {
+      const { occurrence, declaration } = byName.get(path.node.name) ?? {}
+      if (occurrence === undefined || originals.get(path.node) !== occurrence.node) return
+      const binding = path.scope.getBinding(path.node.name)
+      const owner = occurrence.role === 'catch' ? declaration : originals.get(binding.scope.block)
+      owners.set(occurrence.node, paths.scopeFor(owner))
+    } })
+  }
+  return { paths, owners }
+}