dsh-ptc-plus 0.3.1 → 0.4.1

package/internal/cell-analysis.js

@@ -1,10 +1,10 @@
-import { stripTypeScriptTypes } from 'node:module'
+import { ModuleRewriteError } from './cell-rewriter.js'
+import { declarationSpan, PreflightError } from './cell-analysis-contract.js'
+export { declarationSpan, PreflightError } from './cell-analysis-contract.js'
 import { parse } from 'acorn'
-import {
-  STRIP_PREFIX,
-  STRIP_SUFFIX,
-  rewriteModuleImportsExports,
-} from './cell-rewriter.js'
+import { parse as parseSource } from '@babel/parser'
+import { parseExecutableCell } from './cell-parser.js'
+import { redeclarationCommitTarget } from './repl-rewrite-contract.js'
 import {
   bindingNodes,
   createGeneratedNameAllocator,
@@ -17,9 +17,15 @@ import {
   renderDurabilityReason,
   renderDurabilityReasons,
 } from './module-policy.js'
-import { rewriteLooseRedeclarations } from './repl-convenience.js'
-import { applySourceEdits, mapSourceSpan } from './source-position-map.js'
+import { applySourceEdits, mapSourcePosition, mapSourceSpan } from './source-position-map.js'
 import { SKIP_AST_CHILDREN, walkAst } from './ast-traversal.js'
+import { compileStatefulRoot } from './stateful-root-compiler.js'
+import { CELL_PARSER_PLUGINS, bindCompilerIntrinsics, lowerStatefulDecorators, lowerStatefulResources, lowerNativeLanguageSource, normalizeStatefulScopes } from './repl-scope-normalizer.js'
+import { markCallableSources, collectCallableSources } from './callable-source-facts.js'
+import { LegacyPreflightError, prepareLegacyProgram } from './legacy-cell-analysis.js'
+import { adaptLegacyModuleImports } from './managed-module-operations.js'
+import { adaptNativeRootDynamic } from './native-root-compilation.js'
+import { sourceRegionData } from './compiler-region-output.js'
 
 /**
  * Pure AST analysis for PTC cells: binding inventory, durability classification,
@@ -27,35 +33,18 @@ import { SKIP_AST_CHILDREN, walkAst } from './ast-traversal.js'
  * or session state so its behavior is fully testable in isolation.
  */
 
-export function declarationSpan(node) {
-  const start = node.loc?.start
-  /* c8 ignore next */
-  const end = node.loc?.end ?? start
-  /* c8 ignore next */
-  if (start === undefined) return undefined
-  return {
-    line: Math.max(1, start.line - 1),
-    column: start.column + 1,
-    /* c8 ignore next */
-    ...(end === undefined ? {} : {
-      end: {
-        line: Math.max(1, end.line - 1),
-        column: end.column + 1,
-      },
-    }),
-  }
-}
 
 function addPatternBindings(pattern, names) {
   walkPattern(pattern, node => names.add(node.name))
 }
 
-function addPatternDeclarations(pattern, declarations, kind = 'variable', definitionSpan = undefined) {
+function addPatternDeclarations(pattern, declarations, kind = 'variable', definitionSpan = undefined, writable = false) {
   bindingNodes(pattern).forEach(node => declarations.push({
     name: node.name,
     kind,
     span: declarationSpan(node),
     definitionSpan,
+    writable,
   }))
 }
 
@@ -63,13 +52,35 @@ function topLevelBindings(body) {
   return new Set(topLevelDeclarations(body).map(declaration => declaration.name))
 }
 
-function topLevelDeclarations(body) {
+function rootVarDeclarations(body, declarations, seen) {
+  walkAst({ type: 'Program', body }, node => {
+    if (node.type === 'VariableDeclaration' && node.kind === 'var' && !seen.has(node)) {
+      seen.add(node)
+      const definitionSpan = declarationSpan(node)
+      for (const declaration of node.declarations) {
+        addPatternDeclarations(declaration.id, declarations, 'variable', definitionSpan, true)
+      }
+    }
+    if (isFunction(node) || node.type === 'ClassDeclaration' || node.type === 'ClassExpression'
+      || node.type === 'StaticBlock') return SKIP_AST_CHILDREN
+  })
+}
+
+function topLevelDeclarations(body, variableRedeclarations = false) {
   const declarations = []
+  const seen = new Set()
   for (const statement of body) {
     if (statement.type === 'VariableDeclaration') {
+      seen.add(statement)
       const definitionSpan = declarationSpan(statement)
       for (const declaration of statement.declarations) {
-        addPatternDeclarations(declaration.id, declarations, 'variable', definitionSpan)
+        addPatternDeclarations(
+          declaration.id,
+          declarations,
+          'variable',
+          definitionSpan,
+          statement.kind !== 'const' || variableRedeclarations,
+        )
       }
     } else if ((statement.type === 'FunctionDeclaration' || statement.type === 'ClassDeclaration')
       && statement.id !== null) {
@@ -78,9 +89,12 @@ function topLevelDeclarations(body) {
         kind: statement.type === 'ClassDeclaration' ? 'class' : 'function',
         span: declarationSpan(statement.id),
         definitionSpan: declarationSpan(statement),
+        commitDependency: redeclarationCommitTarget(statement.id.name, statement.start),
+        writable: true,
       })
     }
   }
+  rootVarDeclarations(body, declarations, seen)
   return declarations
 }
 
@@ -97,21 +111,56 @@ function directBlockBindings(body) {
   return names
 }
 
-function functionBindings(node) {
+function functionParameterBindings(node) {
   const names = new Set()
   if (node.id !== null && node.id !== undefined) names.add(node.id.name)
   /* c8 ignore next */
   for (const param of node.params ?? []) addPatternBindings(param, names)
-  walkAst(node.body, (current) => {
-    if (current !== node && isFunction(current)) {
-      if (current.type === 'FunctionDeclaration' && current.id !== null) names.add(current.id.name)
+  return names
+}
+
+function hasStrictDirective(body) {
+  if (body.type !== 'BlockStatement') return false
+  for (const statement of body.body) {
+    if (statement.directive === undefined) break
+    if (statement.directive === 'use strict') return true
+  }
+  return false
+}
+
+function addFunctionVariables(body, names, strict) {
+  const addBlockFunction = (node, blocked) => {
+    if (!strict && node.type === 'FunctionDeclaration' && !node.async && !node.generator
+      && !blocked.has(node.id.name)) names.add(node.id.name)
+  }
+  walkAst(body, (current, parent, key, blocked) => {
+    if (isFunction(current)) {
+      addBlockFunction(current, blocked)
       return SKIP_AST_CHILDREN
     }
+    if (current.type === 'StaticBlock') return SKIP_AST_CHILDREN
     if (current.type === 'VariableDeclaration' && current.kind === 'var') {
       for (const declaration of current.declarations) addPatternBindings(declaration.id, names)
     }
-  })
-  return names
+    const statements = current.type === 'BlockStatement' ? current.body
+      : current.type === 'SwitchCase' ? parent.cases.flatMap(branch => branch.consequent) : undefined
+    if (statements !== undefined) {
+      // Annex B creates a function-scope var only when intervening lexical
+      // declarations permit it. The declaration's own block binding is excluded.
+      for (const statement of statements) addBlockFunction(statement, blocked)
+      return new Set([...blocked, ...directBlockBindings(statements)])
+    }
+    if (['ForStatement', 'ForInStatement', 'ForOfStatement'].includes(current.type)) {
+      return new Set([...blocked, ...loopBindings(current)])
+    }
+    if (current.type === 'CatchClause' && current.param !== null && current.param.type !== 'Identifier') {
+      // The Annex B catch exception admits var names through a simple parameter,
+      // but a destructured catch binding still blocks function-scope promotion.
+      const nested = new Set(blocked)
+      addPatternBindings(current.param, nested)
+      return nested
+    }
+  }, undefined, new Set())
 }
 
 function loopBindings(node) {
@@ -157,10 +206,10 @@ function staticMemberName(node) {
   return undefined
 }
 
-function globalThisMember(node) {
+function globalObjectMember(node) {
   return node?.type === 'MemberExpression'
     && node.object?.type === 'Identifier'
-    && node.object.name === 'globalThis'
+    && ['global', 'globalThis'].includes(node.object.name)
     ? staticMemberName(node)
     : undefined
 }
@@ -171,12 +220,6 @@ function isFunction(node) {
     || node.type === 'ArrowFunctionExpression'
 }
 
-export class PreflightError extends Error {
-  constructor(message, node, span = undefined) {
-    super(message)
-    this.span = span ?? declarationSpan(node)
-  }
-}
 
 function staticModuleClassification(moduleLoads) {
   const reasons = new Map()
@@ -197,15 +240,46 @@ function staticModuleClassification(moduleLoads) {
 }
 
 /** Conservatively classify a cell before giving it non-journalable capability. */
-export function classifyDurability(code, knownBindings = new Set()) {
-  const tree = parse(`${STRIP_PREFIX}${code}${STRIP_SUFFIX}`, { ecmaVersion: 'latest', sourceType: 'script', locations: true })
-  const outer = tree.body[0]
-  /* c8 ignore next */
-  if (outer?.type !== 'FunctionDeclaration') throw new Error('ptc-plus: failed to parse cell wrapper')
-  const declared = topLevelBindings(outer.body.body)
+export function classifyDurability(code, knownBindings = new Set(), { sourceType = 'script', internalModules = new Set() } = {}) {
+  let body
+  let moduleLoads = []
+  if (sourceType === 'module') {
+    const program = parse(code, { ecmaVersion: 'latest', sourceType: 'module', locations: true })
+    knownBindings = new Set(knownBindings)
+    moduleLoads = program.body.filter(statement => statement.source != null
+      && ['ImportDeclaration', 'ExportNamedDeclaration', 'ExportAllDeclaration'].includes(statement.type)
+      && !internalModules.has(statement.source.value)).map(statement => ({
+      source: statement.source.value, position: declarationSpan(statement.source),
+    }))
+    body = { type: 'BlockStatement', body: program.body.flatMap(statement => {
+      if (statement.type === 'ImportDeclaration') {
+        for (const specifier of statement.specifiers) knownBindings.add(specifier.local.name)
+        return []
+      }
+      if (statement.type === 'ExportAllDeclaration') return []
+      if (statement.type === 'ExportNamedDeclaration') return statement.declaration === null ? [] : [statement.declaration]
+      if (statement.type === 'ExportDefaultDeclaration') return [statement.declaration]
+      return [statement]
+    }) }
+  } else ({ body } = parseExecutableCell(code))
+  const declared = topLevelBindings(body.body)
   const rootBindings = new Set([...knownBindings, ...declared])
+  const rootStrict = sourceType === 'module' || hasStrictDirective(body)
+  addFunctionVariables(body, rootBindings, rootStrict)
+  // A `var` is instantiated with the cell even on the path that never runs its
+  // initializer, so it occupies the shared environment but does not by itself
+  // replace a name an earlier cell bound.
+  const hoistedVars = new Set()
+  walkAst(body, (node) => {
+    if (isFunction(node)) return SKIP_AST_CHILDREN
+    if (node.type === 'StaticBlock') return SKIP_AST_CHILDREN
+    if (node.type === 'VariableDeclaration' && node.kind === 'var') {
+      for (const declaration of node.declarations) addPatternBindings(declaration.id, hoistedVars)
+    }
+  })
   const reasons = new Map()
   const addReason = reason => reasons.set(renderDurabilityReason(reason), reason)
+  for (const reason of staticModuleClassification(moduleLoads)) addReason(reason)
   const classifyModule = (source) => {
     if (source?.type !== 'Literal' || typeof source.value !== 'string') {
       addReason(DYNAMIC_MODULE_REASON)
@@ -223,12 +297,25 @@ export function classifyDurability(code, knownBindings = new Set()) {
     }
     return false
   }
-  walkAst(outer.body, (node, parent, parentKey, scopes) => {
+  walkAst(body, (node, parent, parentKey, { scopes, strict }) => {
     let nestedScopes = scopes
     if (isFunction(node)) {
-      nestedScopes = [...scopes, functionBindings(node)]
-    } else if (node.type === 'BlockStatement' && node !== outer.body) {
-      nestedScopes = [...scopes, directBlockBindings(node.body)]
+      strict ||= hasStrictDirective(node.body)
+      nestedScopes = [...scopes, functionParameterBindings(node)]
+    } else if (node.type === 'BlockStatement' && node !== body) {
+      const names = directBlockBindings(node.body)
+      if (isFunction(parent)) addFunctionVariables(node, names, strict)
+      nestedScopes = [...scopes, names]
+    } else if (node.type === 'StaticBlock') {
+      const names = directBlockBindings(node.body)
+      for (const statement of node.body) addFunctionVariables(statement, names, true)
+      strict = true
+      nestedScopes = [...scopes, names]
+    } else if (node.type === 'ClassDeclaration' || node.type === 'ClassExpression') {
+      strict = true
+      nestedScopes = [...scopes, new Set(node.id === null ? [] : [node.id.name])]
+    } else if (node.type === 'SwitchCase') {
+      nestedScopes = [...scopes, directBlockBindings(parent.cases.flatMap(branch => branch.consequent))]
     } else if (node.type === 'CatchClause') {
       const names = new Set()
       addPatternBindings(node.param, names)
@@ -252,233 +339,156 @@ export function classifyDurability(code, knownBindings = new Set()) {
       && !isBound('process', nestedScopes) && node.name === 'process' && !isStableProcessMember(node, parent)) {
       addReason(Object.freeze({ kind: 'ambient', name: 'process' }))
     }
+    if (node.type === 'Identifier' && ['global', 'globalThis'].includes(node.name)
+      && isReferenceIdentifier(node, parent, parentKey) && !isBound(node.name, nestedScopes)
+      && !(parent?.type === 'MemberExpression' && parent.object === node)) {
+      addReason(Object.freeze({ kind: 'ambient', name: node.name }))
+    }
+    if (node.type === 'Identifier' && node.name === 'Math'
+      && isReferenceIdentifier(node, parent, parentKey) && !isBound('Math', nestedScopes)
+      && !(parent?.type === 'MemberExpression' && parent.object === node && staticMemberName(parent) !== undefined)) {
+      addReason(Object.freeze({ kind: 'ambient', name: 'Math' }))
+    }
     if (node.type === 'MemberExpression'
       && ((node.object?.type === 'Identifier' && node.object.name === 'Math' && !isBound('Math', nestedScopes))
-        || (globalThisMember(node.object) === 'Math' && !isBound('globalThis', nestedScopes)))
+        || (globalObjectMember(node.object) === 'Math' && !isBound(node.object.object.name, nestedScopes)))
       && staticMemberName(node) === 'random') {
       addReason(Object.freeze({ kind: 'math-random' }))
     }
     if (node.type === 'MemberExpression' && node.object?.type === 'Identifier'
-      && node.object.name === 'globalThis' && !isBound('globalThis', nestedScopes)) {
+      && ['global', 'globalThis'].includes(node.object.name) && !isBound(node.object.name, nestedScopes)) {
       const member = staticMemberName(node)
       if (member === undefined) addReason(Object.freeze({ kind: 'computed-global-access' }))
       else if (member === 'process') addReason(Object.freeze({ kind: 'ambient', name: 'process' }))
       else if (AMBIENT_GLOBALS.has(member)) addReason(Object.freeze({ kind: 'ambient', name: member }))
+      else if (member === 'global' || member === 'globalThis') addReason(Object.freeze({ kind: 'ambient', name: member }))
+      else if (member === 'Math' && !(parent?.type === 'MemberExpression' && parent.object === node
+        && staticMemberName(parent) !== undefined)) {
+        addReason(Object.freeze({ kind: 'ambient', name: 'Math' }))
+      }
     }
-    return nestedScopes
-  }, undefined, [rootBindings], outer, 'body')
+    return { scopes: nestedScopes, strict }
+  }, undefined, { scopes: [rootBindings], strict: rootStrict })
   return {
     durability: reasons.size === 0 ? 'durable' : 'volatile',
     reasons: Object.freeze([...reasons.values()]),
     declared,
+    hoistedVars,
   }
 }
 
 function rewriteCellReturns(code, sourceMap, unavailableNames) {
-  const wrapped = STRIP_PREFIX + code + STRIP_SUFFIX
-  const tree = parse(wrapped, { ecmaVersion: 'latest', sourceType: 'script' })
-  const outer = tree.body[0]
-  /* c8 ignore next */
-  if (outer?.type !== 'FunctionDeclaration') throw new Error('ptc-plus: failed to parse cell wrapper')
-  const offset = STRIP_PREFIX.length
+  const { body } = parseExecutableCell(code)
   const edits = []
-  const allocateName = createGeneratedNameAllocator(tree, unavailableNames)
+  const allocateName = createGeneratedNameAllocator(body, unavailableNames)
   const returnSignal = allocateName('return_signal')
   const signalReference = `this[${JSON.stringify(returnSignal)}]`
+  const completion = allocateName('cell_completion')
+  const exit = allocateName('cell_exit')
+  const ignored = allocateName('completion_effect')
+  let asyncCompletion = false
 
-  walkAst(outer.body, (node) => {
-    if (node !== outer.body && isFunction(node)) return SKIP_AST_CHILDREN
+  walkAst(body, (node) => {
+    if (node !== body && isFunction(node)) return SKIP_AST_CHILDREN
+    if (node.type === 'AwaitExpression' || node.await === true
+      || node.type === 'VariableDeclaration' && node.kind === 'await using') asyncCompletion = true
     if (node.type === 'ReturnStatement') {
-      const start = node.start - offset
-      const end = node.end - offset
+      const start = node.start
+      const end = node.end
       const argument = node.argument === null
         ? ''
-        : code.slice(node.argument.start - offset, node.argument.end - offset)
-      // A ReturnStatement may be the last clause body in a switch case. The
-      // generated throw must terminate explicitly because the original return
-      // statement's semicolon is part of the replaced AST range.
-      edits.push({ start, end, text: `throw new ${signalReference}(${argument});` })
-      return SKIP_AST_CHILDREN
-    }
-    if (node.type === 'CatchClause') {
-      const bodyStart = node.body.start - offset + 1
-      const temporary = allocateName('caught')
-      if (node.param === null) {
-        edits.push({ start: node.start - offset + 5, end: node.start - offset + 5, text: ` (${temporary})` })
-        edits.push({ start: bodyStart, end: bodyStart, text: `\nif (${temporary} instanceof ${signalReference}) throw ${temporary};` })
-      } else if (node.param.type === 'Identifier') {
-        edits.push({
-          start: bodyStart,
-          end: bodyStart,
-          text: `\nif (${node.param.name} instanceof ${signalReference}) throw ${node.param.name};`,
-        })
-      } else {
-        const pattern = code.slice(node.param.start - offset, node.param.end - offset)
-        edits.push({ start: node.param.start - offset, end: node.param.end - offset, text: temporary })
-        edits.push({
-          start: bodyStart,
-          end: bodyStart,
-          text: `\nif (${temporary} instanceof ${signalReference}) throw ${temporary};\nconst ${pattern} = ${temporary};`,
-        })
-      }
+        : code.slice(node.argument.start, node.argument.end)
+      // Break leaves resource and finally scopes without making disposal
+      // suppress a private error for an otherwise successful return.
+      edits.push({ start, end, text: `{let ${ignored}=(${completion}=new ${signalReference}(${argument}));break ${exit};}` })
     }
   })
 
-  /* c8 ignore next */
-  edits.sort((left, right) => right.start - left.start || right.end - left.end)
-  return { ...applySourceEdits(code, sourceMap, edits), returnSignal }
+  const directiveEnd = body.body.findLast(node => node.directive !== undefined)?.end ?? 0
+  // Fallthrough cancels a return overridden by finally break/continue. Empty
+  // declaration completions preserve the source's ordinary expression value.
+  edits.push({ start: directiveEnd, end: directiveEnd,
+    text: `\n{let ${completion};${exit}:{\n` })
+  edits.push({ start: code.length, end: code.length,
+    text: `\n;{let ${ignored}=(${completion}=void 0);}}{let ${ignored}=${completion}&&(()=>{throw ${completion}})();}}\n` })
+  let lowered = applySourceEdits(code, sourceMap, edits)
+  if (asyncCompletion) {
+    // The frame result is compiler-owned transport. Letting Node create it
+    // would hide the promise from our observer and re-enter source protocols
+    // when the host REPL awaits this realm's completion.
+    lowered = applySourceEdits(lowered.code, lowered.sourceMap, [
+      { start: 0, end: 0, text: '(async()=>{' },
+      { start: lowered.code.length, end: lowered.code.length, text: '\n})()' },
+    ])
+  }
+  return { ...lowered, returnSignal, asyncCompletion }
+}
+
+/** Workbench completion uses the same source grammar and compilation boundary. */
+export function prepareConsoleProgram(source, options) {
+  const program = parseSource(source, { sourceType: 'script', errorRecovery: true,
+    allowImportExportEverywhere: true, allowUndeclaredExports: true,
+    allowAwaitOutsideFunction: true, allowReturnOutsideFunction: true, plugins: CELL_PARSER_PLUGINS }).program
+  const last = program.body.at(-1)
+  const input = last?.type !== 'ExpressionStatement' ? source
+    : `${source.slice(0, last.start)}return (${source.slice(last.expression.start, last.expression.end)});${source.slice(last.end)}`
+  return prepareProgram(input, options)
 }
 
-export function prepareProgram(program, knownBindings, looseTopLevelRedeclarations, reservedBindings = new Set(), rewritesEnabled, importBindings = new Map(), importNamespaces = new Set()) {
+export function prepareProgram(program, options = {}) {
   if (typeof program !== 'string') throw new TypeError('ptc-plus: program must be a string')
-  if (rewritesEnabled === null || typeof rewritesEnabled !== 'object' || Array.isArray(rewritesEnabled)
-    || typeof rewritesEnabled.autoRewriteImports !== 'boolean'
-    || typeof rewritesEnabled.autoStripExports !== 'boolean'
-    || typeof rewritesEnabled.autoSplitRedeclarations !== 'boolean') {
-    throw new TypeError('ptc-plus: rewrite policy must define autoRewriteImports, autoStripExports, and autoSplitRedeclarations booleans')
-  }
-  const unavailableGeneratedNames = new Set([
-    ...knownBindings,
-    ...reservedBindings,
-    ...importBindings.keys(),
-    ...importNamespaces,
-  ])
-  const moduleRewrite = rewriteModuleImportsExports(
-    program,
-    rewritesEnabled,
-    importBindings,
-    importNamespaces,
-    unavailableGeneratedNames,
-  )
-  const staticModuleReasons = staticModuleClassification(moduleRewrite.moduleLoads)
-  const wrapped = STRIP_PREFIX + moduleRewrite.code + STRIP_SUFFIX
-  let stripped = wrapped
-  let tree
-  try {
-    tree = parse(wrapped, { ecmaVersion: 'latest', sourceType: 'script', locations: true })
-  } catch (javascriptError) {
+  if (options.languageSemantics === undefined || options.languageSemantics === 'legacy-v1') {
     try {
-      stripped = stripTypeScriptTypes(wrapped)
-      tree = parse(stripped, { ecmaVersion: 'latest', sourceType: 'script', locations: true })
-    } catch {
-      throw javascriptError
-    }
-  }
-  const code = stripped.slice(STRIP_PREFIX.length, stripped.length - STRIP_SUFFIX.length)
-  const sourceMap = moduleRewrite.sourceMap
-  const outer = tree.body[0]
-  /* c8 ignore next */
-  const generatedDeclarations = outer?.type === 'FunctionDeclaration' ? topLevelDeclarations(outer.body.body) : []
-  const collisionFor = (declaration) => {
-    /* c8 ignore next */
-    const mapped = declaration.original === true ? declaration.span : declaration.span === undefined
-      ? { line: 1, column: 1 }
-      : mapSourceSpan(declaration.span, code, program, sourceMap)
-    return {
-      name: declaration.name,
-      start: { line: mapped.line, column: mapped.column },
-      /* c8 ignore next */
-      ...(mapped.end === undefined ? {} : { end: mapped.end }),
-    }
-  }
-  const classifyPrepared = (preparedCode, preparedSourceMap) => {
-    try {
-      const classification = classifyDurability(preparedCode, knownBindings)
-      const reasons = new Map()
-      for (const reason of [...staticModuleReasons, ...classification.reasons]) {
-        reasons.set(renderDurabilityReason(reason), reason)
-      }
-      return {
-        ...classification,
-        durability: reasons.size === 0 ? 'durable' : 'volatile',
-        reasons: Object.freeze([...reasons.values()]),
-        reason: renderDurabilityReasons([...reasons.values()]),
-      }
+      // Logical imports have no persistent native namespace slot. Their proved
+      // identity enters the native execution environment with the other roots.
+      const nativeOptions = { ...options, importBindings: new Map([...options.importBindings ?? []]
+        .filter(([name]) => !options.establishedRoots?.has(name) || options.nativeBindings?.has(name))) }
+      const prepared = adaptNativeRootDynamic(adaptLegacyModuleImports(prepareLegacyProgram(program, nativeOptions), nativeOptions), options, program)
+      return { ...prepared, sourceRegions: sourceRegionData(prepared.sourceRegions), languageSemantics: 'legacy-v1' }
     } catch (error) {
-      if (error instanceof PreflightError && error.span !== undefined) {
-        error.span = mapSourceSpan(error.span, preparedCode, program, preparedSourceMap)
-      }
+      if (error instanceof LegacyPreflightError) throw new PreflightError(error.message, undefined, error.span)
       throw error
     }
   }
-  const importedNames = new Set(moduleRewrite.imports.keys())
-  const originalDeclarationNames = new Set(moduleRewrite.exportDeclarations.map(declaration => declaration.name))
-  const declarations = [
-    ...moduleRewrite.importDeclarations,
-    ...moduleRewrite.exportDeclarations,
-    ...generatedDeclarations
-      .filter(declaration => !moduleRewrite.generatedNamespaces.has(declaration.name)
-        && !originalDeclarationNames.has(declaration.name))
-      .map(declaration => ({
-        ...declaration,
-        ...(declaration.definitionSpan === undefined ? {} : {
-          definitionSpan: mapSourceSpan(declaration.definitionSpan, code, program, sourceMap),
-        }),
-      })),
-  ]
-  const normalizeClassification = classification => {
-    const imports = new Map(moduleRewrite.imports)
-    for (const name of classification.declared) {
-      if (!moduleRewrite.generatedNamespaces.has(name)) imports.delete(name)
-    }
-    return {
-      ...classification,
-      imports,
-      declared: new Set([...classification.declared, ...importedNames]),
+  if (options.languageSemantics === 'stateful-v1' || options.languageSemantics === 'protected-v1') {
+    let normalized
+    let prepared
+    let callableSources
+    const intrinsicContext = { bindings: new Set() }
+    try {
+      const marked = markCallableSources(program, undefined, { plugins: CELL_PARSER_PLUGINS, allowImportExportEverywhere: true, allowUndeclaredExports: true },
+        { lowerNativeSource: lowerNativeLanguageSource, nativeUsing: options.nativeUsing })
+      callableSources = marked.callableSources
+      normalized = normalizeStatefulScopes(marked.code, marked.sourceMap, { mode: options.languageSemantics,
+        nativeJavaScript: marked.nativeJavaScript, deferDecorators: true, deferResources: true, intrinsicContext })
+      prepared = compileStatefulRoot(normalized.code, { ...options, sourceMap: normalized.sourceMap,
+        internalBindings: normalized.internalBindings, dynamicBindings: normalized.dynamicBindings,
+        privateBindings: normalized.privateBindings, originalSource: program })
+    } catch (error) {
+      if (error instanceof ModuleRewriteError) throw error
+      const position = error.loc === undefined ? undefined : { line: error.loc.line, column: error.loc.column + 1 }
+      throw new ModuleRewriteError(error.message, normalized === undefined ? position
+        : mapSourcePosition(position, normalized.code, program, normalized.sourceMap))
     }
-  }
-  const reserved = declarations.filter(declaration => (
-    reservedBindings.has(declaration.name) || moduleRewrite.importNamespaces.has(declaration.name)
-  ))
-  if (reserved.length > 0) {
-    const classification = normalizeClassification(classifyPrepared(code, sourceMap))
-    return {
-      code,
-      ...classification,
-      declarations,
-      imports: classification.imports,
-      importNamespaces: moduleRewrite.importNamespaces,
-      collisions: reserved.map(collisionFor),
-      redeclared: [],
-      rewrites: moduleRewrite.rewrites,
-      moduleLoads: moduleRewrite.moduleLoads,
+    prepared = { ...prepared, deferredHelpers: normalized.deferredHelpers }
+    intrinsicContext.expression = `this[${JSON.stringify(prepared.rootRuntimeName)}].intrinsics`
+    const classificationSource = bindCompilerIntrinsics(lowerStatefulDecorators(
+      { ...prepared, code: prepared.classificationCode }, undefined, intrinsicContext), intrinsicContext).code
+    prepared = bindCompilerIntrinsics(lowerStatefulDecorators(prepared, undefined, intrinsicContext), intrinsicContext)
+    prepared = lowerStatefulResources(prepared, { intrinsicContext, nativeUsing: options.nativeUsing })
+    const parsed = parseExecutableCell(prepared.code, { eraseTypes: true })
+    const classification = classifyDurability(parseExecutableCell(classificationSource, { eraseTypes: true }).code,
+      new Set([...(options.knownBindings ?? []), ...prepared.declared]))
+    const reasons = [...staticModuleClassification(prepared.moduleLoads), ...classification.reasons]
+    const lowered = rewriteCellReturns(parsed.code, prepared.sourceMap,
+      new Set([...prepared.declared, ...(options.knownBindings ?? [])]))
+    prepared.rootBindings.callableSources = collectCallableSources(lowered.code, callableSources)
+    return { ...prepared, ...lowered,
+      sourceRegions: sourceRegionData(prepared.sourceRegions),
+      returnSignal: lowered.returnSignal,
+      durability: reasons.length === 0 ? 'durable' : 'volatile', reasons: Object.freeze(reasons),
+      reason: renderDurabilityReasons(reasons),
     }
   }
-  const convenience = rewriteLooseRedeclarations({
-    code,
-    sourceMap,
-    body: looseTopLevelRedeclarations && outer?.type === 'FunctionDeclaration' ? outer.body.body : undefined,
-    offset: STRIP_PREFIX.length,
-    knownBindings: new Set([...knownBindings].filter(name => !importBindings.has(name))),
-    declarations,
-    declarationSpan,
-    collisionFor,
-    autoSplitRedeclarations: rewritesEnabled.autoSplitRedeclarations,
-  })
-  const { executableCode, executableSourceMap, collisions, redeclared, rewrites } = convenience
-  // Classification sees the rewritten program so declared bindings reflect the
-  // split form; it must never see the return rewrite, whose computed
-  // globalThis access would mark every returning cell volatile.
-  const classification = normalizeClassification(classifyPrepared(executableCode, executableSourceMap))
-  let lowered = { code, sourceMap }
-  if (collisions.length === 0) {
-    lowered = rewriteCellReturns(
-      executableCode,
-      executableSourceMap,
-      unavailableGeneratedNames,
-    )
-  }
-  return {
-    code: lowered.code,
-    sourceMap: lowered.sourceMap,
-    ...(lowered.returnSignal === undefined ? {} : { returnSignal: lowered.returnSignal }),
-    ...classification,
-    declarations,
-    imports: classification.imports,
-    importNamespaces: moduleRewrite.importNamespaces,
-    collisions,
-    redeclared,
-    rewrites: [...moduleRewrite.rewrites, ...rewrites],
-    moduleLoads: moduleRewrite.moduleLoads,
-  }
+  throw new TypeError('ptc-plus: unsupported language semantics')
 }

package/internal/cell-completion.js

@@ -0,0 +1,15 @@
+import { captureCompilerIntrinsics } from './compiler-intrinsics.js'
+
+/** Execution owns its frame promise; the returned source value still uses
+ * Await in the source realm. Neither consumer performs host-realm assimilation
+ * of an unexamined source promise. */
+export function createCellCompletionObserver(realmFunction) {
+  const intrinsics = captureCompilerIntrinsics(realmFunction)
+  return {
+    observe: intrinsics.observeOwnedPromise,
+    settle(value, fulfilled, rejected) {
+      const completion = intrinsics.awaitValue(value, value => ({ value }))
+      intrinsics.observeOwnedPromise(completion, result => fulfilled(result.value), rejected)
+    },
+  }
+}