dsh-ptc-plus 0.3.2 → 0.4.1

package/internal/ast-traversal.js

@@ -8,10 +8,13 @@ export function walkAst(node, enter, leave = undefined, context = undefined, par
   const entered = enter(node, parent, parentKey, context)
   if (entered === SKIP_AST_CHILDREN) return
   const childContext = entered === undefined ? context : entered
-  for (const [key, value] of Object.entries(node)) {
+  const keys = Object.keys(node)
+  for (let index = 0; index < keys.length; index++) {
+    const key = keys[index]
     if (AST_METADATA_KEYS.has(key)) continue
+    const value = node[key]
     if (Array.isArray(value)) {
-      for (const child of value) walkAst(child, enter, leave, childContext, node, key)
+      for (let child = 0; child < value.length; child++) walkAst(value[child], enter, leave, childContext, node, key)
     } else {
       walkAst(value, enter, leave, childContext, node, key)
     }

package/internal/binding-descriptors.js

@@ -86,6 +86,7 @@ export function normalizeBindingDescriptors(bindings) {
     workerDescriptors: Object.freeze(namespaces.map(namespace => Object.freeze({
       global: namespace.global,
       members: namespace.members,
+      ...(reservedNames.has(namespace.global) ? {} : { shadowable: true }),
       ...(namespace.emptyObjectMembers === undefined
         ? {}
         : { emptyObjectMembers: namespace.emptyObjectMembers }),

package/internal/binding-pattern-traversal.js

@@ -0,0 +1,25 @@
+/** Read binding names from Acorn or Babel patterns without compiler dependencies. */
+export function walkBindingPattern(pattern, visit) {
+  if (pattern === null || typeof pattern !== 'object') return
+  if (pattern.type === 'Identifier') {
+    visit(pattern)
+    return
+  }
+  if (pattern.type === 'RestElement') return walkBindingPattern(pattern.argument, visit)
+  if (pattern.type === 'AssignmentPattern') return walkBindingPattern(pattern.left, visit)
+  if (pattern.type === 'ArrayPattern') {
+    for (const element of pattern.elements) walkBindingPattern(element, visit)
+    return
+  }
+  if (pattern.type === 'ObjectPattern') {
+    for (const property of pattern.properties) {
+      walkBindingPattern(property.type === 'RestElement' ? property.argument : property.value, visit)
+    }
+  }
+}
+
+export function bindingNodes(pattern) {
+  const nodes = []
+  walkBindingPattern(pattern, node => nodes.push(node))
+  return nodes
+}

package/internal/binding-pattern.js

@@ -1,51 +1,48 @@
 /** Shared binding-pattern traversal used by cell analysis and REPL policy code. */
+import { types as t } from '@babel/core'
 
-export function walkBindingPattern(pattern, visit) {
-  if (pattern === null || typeof pattern !== 'object') return
-  if (pattern.type === 'Identifier') {
-    visit(pattern)
-    return
-  }
-  if (pattern.type === 'RestElement') return walkBindingPattern(pattern.argument, visit)
-  if (pattern.type === 'AssignmentPattern') return walkBindingPattern(pattern.left, visit)
-  if (pattern.type === 'ArrayPattern') {
-    for (const element of pattern.elements) walkBindingPattern(element, visit)
-    return
-  }
-  if (pattern.type === 'ObjectPattern') {
-    for (const property of pattern.properties) {
-      walkBindingPattern(property.type === 'RestElement' ? property.argument : property.value, visit)
-    }
-  }
-}
+export { walkBindingPattern, bindingNodes } from './binding-pattern-traversal.js'
 
-export function bindingNodes(pattern) {
-  const nodes = []
-  walkBindingPattern(pattern, node => nodes.push(node))
-  return nodes
+/** Recognize an actual assignment target through erased expression syntax. */
+export function isWriteIdentifier(path) {
+  let selected = path
+  while (selected.parentPath?.isObjectProperty() && selected.key === 'value'
+    || selected.parentPath?.isObjectPattern() || selected.parentPath?.isArrayPattern()
+    || selected.parentPath?.isRestElement() && selected.key === 'argument'
+    || selected.parentPath?.isAssignmentPattern() && selected.key === 'left'
+    || selected.parent?.type.startsWith('TS') && selected.key === 'expression'
+    || selected.parentPath?.isParenthesizedExpression() && selected.key === 'expression') selected = selected.parentPath
+  const parent = selected.parentPath
+  return parent?.isAssignmentExpression() && selected.key === 'left'
+    || parent?.isUpdateExpression() && selected.key === 'argument'
+    || (parent?.isForOfStatement() || parent?.isForInStatement()) && selected.key === 'left'
 }
 
 /** Allocate private identifiers outside both source and caller-owned name sets. */
-export function createGeneratedNameAllocator(root, unavailableNames = []) {
+export function createGeneratedNameAllocator(root, unavailableNames = [], { compact = false } = {}) {
   const used = new Set(unavailableNames)
-  const seen = new Set()
   const pending = [root]
   while (pending.length > 0) {
     const value = pending.pop()
-    if (value === null || typeof value !== 'object' || seen.has(value)) continue
-    seen.add(value)
+    if (value === null || typeof value !== 'object') continue
+    if (Array.isArray(value)) {
+      for (const item of value) pending.push(item)
+      continue
+    }
     if (value.type === 'Identifier') used.add(value.name)
-    for (const child of Object.values(value)) {
-      if (Array.isArray(child)) pending.push(...child)
+    for (const key of t.VISITOR_KEYS[value.type] ?? Object.keys(value)) {
+      const child = value[key]
+      if (Array.isArray(child)) for (const item of child) pending.push(item)
       else if (child !== null && typeof child === 'object') pending.push(child)
     }
   }
   const sequences = new Map()
+  let nextCompact = 0
   return (purpose) => {
     let sequence = sequences.get(purpose) ?? 0
     let name
     do {
-      name = `__dsh_ptc_${purpose}_${sequence++}__`
+      name = compact ? `__ptc$${(nextCompact++).toString(36)}` : `__dsh_ptc_${purpose}_${sequence++}__`
     } while (used.has(name))
     sequences.set(purpose, sequence)
     used.add(name)

package/internal/binding-source-analysis.js

@@ -0,0 +1,391 @@
+import { parse } from '@babel/parser'
+import { AMBIENT_GLOBALS, renderDurabilityReasons } from './module-policy.js'
+import { CELL_PARSER_PLUGINS, normalizeTypeScriptValues } from './repl-scope-normalizer.js'
+import { identitySourceMap } from './source-position-map.js'
+import { LEGACY_USER_BINDING_TRANSFORM, transformTypeScriptSource } from './typescript-transform.js'
+import { compileStatefulModule } from './module-compilation.js'
+import { prepareProgram, classifyDurability } from './cell-analysis.js'
+import { createCompilerSourceCache } from './compiler-source-cache.js'
+
+const MAX_NAME_LENGTH = 128
+const GLOBAL_TYPE_NAMES = new Set([
+  'Array', 'ArrayBuffer', 'ArrayBufferView', 'AsyncIterable', 'AsyncIterableIterator',
+  'AsyncIterator', 'Awaited', 'BigInt', 'BigInt64Array', 'BigUint64Array', 'Boolean',
+  'Buffer', 'ConstructorParameters', 'DataView', 'Date', 'Error', 'EvalError', 'Exclude',
+  'Extract', 'Float32Array', 'Float64Array', 'Function', 'Generator', 'GeneratorFunction',
+  'InstanceType', 'Int8Array', 'Int16Array', 'Int32Array', 'Iterable', 'IterableIterator',
+  'Iterator', 'Map', 'NonNullable', 'Number', 'Object', 'Omit', 'OmitThisParameter',
+  'Parameters', 'Partial', 'Pick', 'Promise', 'PromiseLike', 'RangeError', 'Readonly',
+  'ReadonlyArray', 'ReadonlyMap', 'ReadonlySet', 'Record', 'ReferenceError', 'RegExp',
+  'Required', 'ReturnType', 'Set', 'SharedArrayBuffer', 'String', 'Symbol', 'SyntaxError',
+  'ThisParameterType', 'ThisType', 'TypeError', 'URIError', 'Uint8Array', 'Uint8ClampedArray',
+  'Uint16Array', 'Uint32Array', 'Uppercase', 'Lowercase', 'Capitalize', 'Uncapitalize',
+  'WeakMap', 'WeakSet',
+])
+const RESERVED_BINDINGS = new Set([
+  ...AMBIENT_GLOBALS,
+  'capabilities',
+  'code',
+  'repl',
+  'tools',
+  'CapabilityExplorationError',
+  'CodeExecutionError',
+  'ToolCallError',
+  'Buffer',
+  'console',
+  'global',
+  'globalThis',
+  'module',
+  'process',
+])
+
+export function identifier(value, subject, reserved = false) {
+  if (typeof value !== 'string' || value.length === 0 || value.length > MAX_NAME_LENGTH) {
+    throw new TypeError(`${subject} must be a non-empty identifier of at most ${MAX_NAME_LENGTH} characters`)
+  }
+  try {
+    const { program } = parse(`const ${value} = 0`, { sourceType: 'module' })
+    const declaration = program.body[0]
+    const binding = declaration.declarations[0].id
+    if (program.body.length !== 1 || declaration.declarations.length !== 1
+      || binding.type !== 'Identifier' || binding.name !== value) {
+      throw new TypeError('identifier spelling must match the complete binding name')
+    }
+  } catch {
+    throw new TypeError(`${subject} must be a valid JavaScript identifier`)
+  }
+  if (reserved && RESERVED_BINDINGS.has(value)) {
+    throw new TypeError(`${subject} conflicts with reserved REPL binding ${JSON.stringify(value)}`)
+  }
+  return value
+}
+
+function sourceSlice(source, node) {
+  return Number.isSafeInteger(node?.start) && Number.isSafeInteger(node?.end)
+    ? source.slice(node.start, node.end)
+    : ''
+}
+
+function bindingNames(pattern, names = []) {
+  if (pattern?.type === 'Identifier') names.push(pattern.name)
+  else if (pattern?.type === 'RestElement') bindingNames(pattern.argument, names)
+  else if (pattern?.type === 'AssignmentPattern') bindingNames(pattern.left, names)
+  else if (pattern?.type === 'ArrayPattern') {
+    for (const element of pattern.elements) bindingNames(element, names)
+  } else if (pattern?.type === 'ObjectPattern') {
+    for (const property of pattern.properties) {
+      bindingNames(property.type === 'RestElement' ? property.argument : property.value, names)
+    }
+  }
+  return names
+}
+
+function typeParameterNames(node) {
+  return (node?.params ?? [])
+    .map(parameter => parameter?.name)
+    .filter(name => typeof name === 'string')
+}
+
+function typeReferenceRoot(node) {
+  let current = node
+  while (current?.type === 'TSQualifiedName') current = current.left
+  return current?.type === 'Identifier' ? current.name : undefined
+}
+
+function projectedType(source, node, outerTypeNames = new Set(), sourceTypeNames = new Set()) {
+  const replacements = []
+  const commentRanges = new Set()
+  const visit = (current, inheritedNames) => {
+    if (current === null || typeof current !== 'object') return
+    if (current.type === 'CommentBlock' || current.type === 'CommentLine') {
+      if (Number.isSafeInteger(current.start) && Number.isSafeInteger(current.end)
+        && current.start >= node.start && current.end <= node.end) {
+        const key = `${current.start}:${current.end}`
+        if (!commentRanges.has(key)) {
+          commentRanges.add(key)
+          replacements.push({ start: current.start, end: current.end, text: ' ' })
+        }
+      }
+      return
+    }
+    let typeNames = inheritedNames
+    if (current.typeParameters?.type === 'TSTypeParameterDeclaration') {
+      typeNames = new Set([...inheritedNames, ...typeParameterNames(current.typeParameters)])
+    }
+    if (current.type === 'TSMappedType' && typeof current.typeParameter?.name === 'string') {
+      typeNames = new Set([...typeNames, current.typeParameter.name])
+    }
+    if (current.type === 'TSImportType' || current.type === 'TSTypeQuery') {
+      replacements.push({ start: current.start, end: current.end, text: 'unknown' })
+      return
+    }
+    if (current.type === 'TSTypeReference' || current.type === 'TSExpressionWithTypeArguments') {
+      const name = typeReferenceRoot(current.typeName ?? current.expression)
+      if (name === undefined || (!typeNames.has(name)
+        && (sourceTypeNames.has(name) || !GLOBAL_TYPE_NAMES.has(name)))) {
+        replacements.push({ start: current.start, end: current.end, text: 'unknown' })
+        return
+      }
+    }
+    for (const [key, value] of Object.entries(current)) {
+      if (key === 'loc' || key === 'start' || key === 'end'
+        || key === 'typeParameters' || key === 'typeName' || key === 'expression') continue
+      if (Array.isArray(value)) value.forEach(item => visit(item, typeNames))
+      else visit(value, typeNames)
+    }
+    if (current.typeParameters !== undefined) visit(current.typeParameters, typeNames)
+  }
+  visit(node, outerTypeNames)
+  let text = sourceSlice(source, node) || 'unknown'
+  const start = node.start ?? 0
+  for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+    text = text.slice(0, replacement.start - start)
+      + replacement.text
+      + text.slice(replacement.end - start)
+  }
+  return text
+}
+
+function typeParameters(source, node, outerTypeNames = new Set(), sourceTypeNames = new Set()) {
+  const declaration = node?.typeParameters
+  if (declaration?.type !== 'TSTypeParameterDeclaration') {
+    return { text: '', names: outerTypeNames }
+  }
+  const names = new Set([...outerTypeNames, ...typeParameterNames(declaration)])
+  return { text: projectedType(source, declaration, names, sourceTypeNames), names }
+}
+
+function annotation(source, node, typeNames = new Set(), sourceTypeNames = new Set()) {
+  const type = node?.typeAnnotation?.typeAnnotation
+  return type === undefined ? 'unknown' : projectedType(source, type, typeNames, sourceTypeNames)
+}
+
+function parameter(source, node, index, typeNames = new Set(), sourceTypeNames = new Set()) {
+  if (node?.type === 'TSParameterProperty') {
+    return parameter(source, node.parameter, index, typeNames, sourceTypeNames)
+  }
+  if (node?.type === 'RestElement') {
+    const argument = node.argument
+    return argument?.type === 'Identifier'
+      ? `...${argument.name}: ${node.typeAnnotation === undefined ? 'unknown[]' : annotation(source, node, typeNames, sourceTypeNames)}`
+      : `...args${index}: unknown[]`
+  }
+  const optional = node?.type === 'AssignmentPattern'
+  const target = optional ? node.left : node
+  if (target?.type !== 'Identifier') return `arg${index}: unknown`
+  return `${target.name}${optional || target.optional === true ? '?' : ''}: ${annotation(source, target, typeNames, sourceTypeNames)}`
+}
+
+function returnType(source, node, typeNames = new Set(), sourceTypeNames = new Set()) {
+  const explicit = node?.returnType?.typeAnnotation
+  if (explicit !== undefined) return projectedType(source, explicit, typeNames, sourceTypeNames)
+  return node?.async === true ? 'Promise<unknown>' : 'unknown'
+}
+
+function functionType(source, node, outerTypeNames = new Set(), sourceTypeNames = new Set()) {
+  const generics = typeParameters(source, node, outerTypeNames, sourceTypeNames)
+  const parameters = (node.params ?? [])
+    .map((item, index) => parameter(source, item, index, generics.names, sourceTypeNames)).join(', ')
+  return `${generics.text}(${parameters}) => ${returnType(source, node, generics.names, sourceTypeNames)}`
+}
+
+function inferredType(source, node, depth = 0, sourceTypeNames = new Set()) {
+  if (depth > 2 || node === null || node === undefined) return 'unknown'
+  if (node.type === 'StringLiteral' || node.type === 'TemplateLiteral') return 'string'
+  if (node.type === 'NumericLiteral') return 'number'
+  if (node.type === 'BooleanLiteral') return 'boolean'
+  if (node.type === 'BigIntLiteral') return 'bigint'
+  if (node.type === 'NullLiteral') return 'null'
+  if (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression') {
+    return functionType(source, node, new Set(), sourceTypeNames)
+  }
+  if (node.type === 'ArrayExpression') return 'unknown[]'
+  if (node.type === 'ObjectExpression') {
+    const members = []
+    for (const property of node.properties) {
+      if (property.type !== 'ObjectProperty' || property.computed || property.method) return 'Record<string, unknown>'
+      const name = property.key.type === 'Identifier'
+        ? property.key.name
+        : property.key.type === 'StringLiteral' ? JSON.stringify(property.key.value) : undefined
+      if (name === undefined) return 'Record<string, unknown>'
+      members.push(`${name}: ${inferredType(source, property.value, depth + 1, sourceTypeNames)}`)
+    }
+    return `{ ${members.join('; ')} }`
+  }
+  return 'unknown'
+}
+
+function classMembers(source, node, classTypeNames, sourceTypeNames) {
+  const members = []
+  let constructorParameters = '...args: unknown[]'
+  for (const member of node.body?.body ?? []) {
+    if (member.type !== 'ClassMethod' || member.static || member.computed
+      || member.accessibility === 'private' || member.key?.type === 'PrivateName') continue
+    const name = member.key?.type === 'Identifier'
+      ? member.key.name
+      : member.key?.type === 'StringLiteral' ? JSON.stringify(member.key.value) : undefined
+    if (name === undefined) continue
+    const generics = typeParameters(source, member, classTypeNames, sourceTypeNames)
+    const parameters = (member.params ?? [])
+      .map((item, index) => parameter(source, item, index, generics.names, sourceTypeNames)).join(', ')
+    if (member.kind === 'constructor') constructorParameters = parameters
+    else if (member.kind === 'method') {
+      members.push(`${name}${generics.text}(${parameters}): ${returnType(source, member, generics.names, sourceTypeNames)}`)
+    }
+  }
+  return { constructorParameters, members, instance: `{ ${members.join('; ')} }` }
+}
+
+function jsdocPurpose(...nodes) {
+  const comment = nodes.flatMap(node => node?.leadingComments ?? [])
+    .find(item => item.type === 'CommentBlock' && item.value.startsWith('*'))
+  if (comment === undefined) return ''
+  return comment.value.slice(1).split(/\r?\n/)
+    .map(line => line.replace(/^\s*\*?\s?/, '').trim())
+    .find(line => line !== '' && !line.startsWith('@')) ?? ''
+}
+
+function symbolDescriptor(source, name, node, exportNode = node, sourceTypeNames = new Set()) {
+  if (node?.type === 'FunctionDeclaration') {
+    const generics = typeParameters(source, node, new Set(), sourceTypeNames)
+    const parameters = (node.params ?? [])
+      .map((item, index) => parameter(source, item, index, generics.names, sourceTypeNames)).join(', ')
+    return {
+      name,
+      kind: 'function',
+      purpose: jsdocPurpose(exportNode, node),
+      declaration: `function ${name}${generics.text}(${parameters}): ${returnType(source, node, generics.names, sourceTypeNames)}`,
+      member: `${name}${generics.text}(${parameters}): ${returnType(source, node, generics.names, sourceTypeNames)}`,
+    }
+  }
+  if (node?.type === 'ClassDeclaration') {
+    const generics = typeParameters(source, node, new Set(), sourceTypeNames)
+    const shape = classMembers(source, node, generics.names, sourceTypeNames)
+    return {
+      name,
+      kind: 'class',
+      purpose: jsdocPurpose(exportNode, node),
+      declaration: `class ${name}${generics.text} { constructor(${shape.constructorParameters});${shape.members.length === 0 ? '' : ` ${shape.members.join('; ')};`} }`,
+      member: `${name}: { new${generics.text}(${shape.constructorParameters}): ${shape.instance} }`,
+    }
+  }
+  const declarator = node?.type === 'VariableDeclarator' ? node : undefined
+  const type = declarator?.id?.type !== 'Identifier'
+    ? 'unknown'
+    : declarator.id.typeAnnotation !== undefined
+      ? annotation(source, declarator.id, new Set(), sourceTypeNames)
+      : inferredType(source, declarator.init, 0, sourceTypeNames)
+  return {
+    name,
+    kind: 'variable',
+    purpose: jsdocPurpose(exportNode, node),
+    declaration: `const ${name}: ${type}`,
+    member: `${name}: ${type}`,
+  }
+}
+
+export const exportedSymbols = createCompilerSourceCache(analyzeExportedSymbols)
+
+function analyzeExportedSymbols(source, transform) {
+  let ast
+  try {
+    ast = parse(source, {
+      sourceType: 'module',
+      plugins: transform === LEGACY_USER_BINDING_TRANSFORM
+        ? ['typescript', 'topLevelAwait', 'importAttributes'] : CELL_PARSER_PLUGINS,
+      errorRecovery: transform !== LEGACY_USER_BINDING_TRANSFORM,
+    })
+  } catch (error) {
+    throw new SyntaxError(`binding source could not be parsed: ${error.message}`)
+  }
+  const sourceTypeNames = new Set()
+  for (const statement of ast.program.body) {
+    const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement
+    if (statement.type === 'ImportDeclaration') {
+      for (const specifier of statement.specifiers) sourceTypeNames.add(specifier.local.name)
+    }
+    if (declaration?.type === 'TSTypeAliasDeclaration'
+      || declaration?.type === 'TSInterfaceDeclaration'
+      || declaration?.type === 'TSEnumDeclaration'
+      || declaration?.type === 'TSModuleDeclaration'
+      || declaration?.type === 'ClassDeclaration') {
+      if (declaration.id?.type === 'Identifier') sourceTypeNames.add(declaration.id.name)
+    }
+  }
+  if (transform !== LEGACY_USER_BINDING_TRANSFORM) {
+    source = normalizeTypeScriptValues(source, identitySourceMap(source.length), 'module').code
+    ast = parse(source, { sourceType: 'module', plugins: CELL_PARSER_PLUGINS, errorRecovery: true })
+  }
+  const locals = new Map()
+  for (const statement of ast.program.body) {
+    const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement
+    if (declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration') {
+      if (declaration.id !== null) locals.set(declaration.id.name, declaration)
+    } else if (declaration?.type === 'VariableDeclaration') {
+      for (const item of declaration.declarations) {
+        for (const name of bindingNames(item.id)) locals.set(name, item)
+      }
+    }
+  }
+  const exports = new Map()
+  for (const statement of ast.program.body) {
+    if (statement.type === 'ExportDefaultDeclaration' || statement.type === 'ExportAllDeclaration') {
+      throw new TypeError('binding source supports named exports only')
+    }
+    if (statement.type !== 'ExportNamedDeclaration' || statement.exportKind === 'type') continue
+    if (statement.source !== null && statement.source !== undefined) {
+      throw new TypeError('binding source cannot re-export from another module')
+    }
+    const declaration = statement.declaration
+    if (declaration?.type === 'FunctionDeclaration' || declaration?.type === 'ClassDeclaration') {
+      if (declaration.id === null) throw new TypeError('binding source exports must be named')
+      exports.set(declaration.id.name, symbolDescriptor(
+        source, declaration.id.name, declaration, statement, sourceTypeNames,
+      ))
+      continue
+    }
+    if (declaration?.type === 'VariableDeclaration') {
+      for (const item of declaration.declarations) {
+        for (const name of bindingNames(item.id)) {
+          exports.set(name, symbolDescriptor(source, name, item, statement, sourceTypeNames))
+        }
+      }
+      continue
+    }
+    for (const specifier of statement.specifiers) {
+      if (specifier.exportKind === 'type' || specifier.type !== 'ExportSpecifier') continue
+      const exported = specifier.exported.type === 'Identifier' ? specifier.exported.name : specifier.exported.value
+      const local = specifier.local.type === 'Identifier' ? specifier.local.name : specifier.local.value
+      identifier(exported, 'exported binding name')
+      const target = locals.get(local)
+      if (target === undefined) throw new TypeError(`export ${JSON.stringify(exported)} has no local value declaration`)
+      exports.set(exported, symbolDescriptor(source, exported, target, target, sourceTypeNames))
+    }
+  }
+  if (exports.size === 0) throw new TypeError('binding source must contain at least one named value export')
+  return exports
+}
+
+export const sourceDurability = createCompilerSourceCache(analyzeSourceDurability)
+
+function analyzeSourceDurability(source, transform) {
+  const compiled = compileStatefulModule(source, { transform })
+  // Keep source imports visible to durability analysis after runtime adaptation.
+  const javascript = transformTypeScriptSource(compiled.classificationCode,
+    transform === LEGACY_USER_BINDING_TRANSFORM ? {} : { module: true, transform: { tsEnumIsMutable: true } }).code
+  const prepared = transform !== LEGACY_USER_BINDING_TRANSFORM
+    ? classifyDurability(javascript, new Set(), { sourceType: 'module',
+      internalModules: new Set([new URL('./stateful-module-runtime.js', import.meta.url).href]) })
+    : prepareProgram(javascript, {
+    languageSemantics: 'legacy-v1',
+    knownBindings: new Set(),
+    bindingPolicy: { variableRedeclarations: true, functionClassRedeclarations: true },
+    reservedBindings: new Set(),
+    rewritesEnabled: { autoRewriteImports: true, autoStripExports: true, autoSplitRedeclarations: true },
+  })
+  const reason = prepared.reason ?? renderDurabilityReasons(prepared.reasons)
+  return {
+    durability: prepared.durability,
+    ...(reason === '' ? {} : { volatileReason: reason }),
+  }
+}

package/internal/binding-update-policy.js

@@ -0,0 +1,66 @@
+import { LIVE_MODULE_SEMANTICS } from './repl-rewrite-contract.js'
+import { LEGACY_LANGUAGE_SEMANTICS, STATEFUL_LANGUAGE_SEMANTICS,
+  PROTECTED_LANGUAGE_SEMANTICS, normalizeLanguageSemantics } from './language-semantics.js'
+
+/**
+ * Translate the public compatibility settings into the execution policy used
+ * by the compiler and journal.  Keeping this mapping in one owner prevents
+ * individual lowering paths from combining legacy switches differently.
+ */
+export function executionPolicies(config, replayRecord = undefined) {
+  if (config.bindingUpdates !== undefined && !['stateful', 'protected'].includes(config.bindingUpdates)) {
+    throw new TypeError('ptc-plus: bindingUpdates must be stateful or protected')
+  }
+  if (replayRecord !== undefined) {
+    const bindingPolicy = Object.freeze({ ...replayRecord.bindingPolicy })
+    const rewritesEnabled = Object.freeze({ ...replayRecord.rewritePolicy })
+    const moduleSemantics = Object.freeze({ ...replayRecord.moduleSemantics })
+    return Object.freeze({
+      languageSemantics: normalizeLanguageSemantics(replayRecord.languageSemantics ?? LEGACY_LANGUAGE_SEMANTICS),
+      bindingPolicy,
+      rewritesEnabled,
+      moduleSemantics,
+    })
+  }
+  if (config.bindingUpdates === 'stateful' && config.legacyBindingSettings !== true) {
+    return Object.freeze({
+      languageSemantics: STATEFUL_LANGUAGE_SEMANTICS,
+      bindingPolicy: Object.freeze({ variableRedeclarations: true, functionClassRedeclarations: true }),
+      rewritesEnabled: Object.freeze({ autoRewriteImports: true, autoStripExports: true, autoSplitRedeclarations: true }),
+      moduleSemantics: LIVE_MODULE_SEMANTICS,
+    })
+  }
+  if (config.bindingUpdates === 'protected' && config.legacyBindingSettings !== true) {
+    return Object.freeze({
+      languageSemantics: PROTECTED_LANGUAGE_SEMANTICS,
+      bindingPolicy: Object.freeze({ variableRedeclarations: false, functionClassRedeclarations: false }),
+      // Module syntax is part of the language in protected mode too.  The
+      // policy protects existing names; it does not remove valid syntax.
+      rewritesEnabled: Object.freeze({ autoRewriteImports: true, autoStripExports: true, autoSplitRedeclarations: true }),
+      moduleSemantics: LIVE_MODULE_SEMANTICS,
+    })
+  }
+  return Object.freeze({
+    languageSemantics: LEGACY_LANGUAGE_SEMANTICS,
+    bindingPolicy: Object.freeze({
+      variableRedeclarations: config.looseTopLevelRedeclarations === true,
+      functionClassRedeclarations: config.looseTopLevelFunctionClassRedeclarations === true,
+    }),
+    rewritesEnabled: Object.freeze({
+      autoRewriteImports: config.autoRewriteImports === true,
+      autoStripExports: config.autoStripExports === true,
+      autoSplitRedeclarations: config.autoSplitRedeclarations === true,
+    }),
+    moduleSemantics: LIVE_MODULE_SEMANTICS,
+  })
+}
+
+/** Stable prose inputs for the model-visible REPL guidance. */
+export function guidancePolicies(config) {
+  const policies = executionPolicies(config)
+  return Object.freeze({
+    ...policies,
+    durableReplay: config.durableReplay === true,
+    cordisToolsEnabled: config.cordisToolsEnabled === true,
+  })
+}

package/internal/bounded-worker-round.js

@@ -0,0 +1,56 @@
+/** How a bounded worker round ended without a result. */
+export const ROUND_TIMEOUT = 'timeout'
+export const ROUND_CANCELLED = 'cancelled'
+export const ROUND_OUTPUT_LIMIT = 'output-limit'
+
+/**
+ * Own one bounded worker round: captured output bytes, the wall-clock deadline,
+ * cancellation and a single settlement. Worker creation, retention and
+ * termination stay with the caller, which is told exactly once how the round
+ * ended through `settle({ ok: true, result })` or `settle({ ok: false, reason })`.
+ */
+export function createBoundedWorkerRound({ maxOutputBytes, maxWallMs, signal, settle }) {
+  const logs = []
+  let capturedBytes = 0
+  let ended = false
+  const end = (outcome) => {
+    if (ended) return false
+    ended = true
+    clearTimeout(timer)
+    signal?.removeEventListener('abort', abort)
+    settle(outcome)
+    return true
+  }
+  const fail = reason => end({ ok: false, reason })
+  const abort = () => { fail(ROUND_CANCELLED) }
+  const timer = setTimeout(() => fail(ROUND_TIMEOUT), maxWallMs)
+  signal?.addEventListener('abort', abort, { once: true })
+  if (signal?.aborted === true) fail(ROUND_CANCELLED)
+  return Object.freeze({
+    logs,
+    /** Record one stream chunk; ends the round when the byte budget is exceeded. */
+    capture(channel, text) {
+      if (ended) return
+      capturedBytes += Buffer.byteLength(text, 'utf8')
+      if (capturedBytes > maxOutputBytes) { fail(ROUND_OUTPUT_LIMIT); return }
+      logs.push({ channel, text })
+    },
+    /**
+     * True when the byte budget is spent.
+     *
+     * `envelope` measures the object the caller returns with the captured `logs`
+     * included as a member, so log wrappers and JSON escaping count against the
+     * same budget; that is the candidate run's returned-envelope budget. Without
+     * it the raw captured bytes plus the serialized payload are measured, which is
+     * the workbench console's output budget.
+     */
+    exceeds(payload, { envelope = false } = {}) {
+      if (envelope) {
+        return Buffer.byteLength(JSON.stringify({ ...payload, logs }), 'utf8') > maxOutputBytes
+      }
+      return capturedBytes + Buffer.byteLength(JSON.stringify(payload), 'utf8') > maxOutputBytes
+    },
+    succeed(result) { return end({ ok: true, result }) },
+    fail,
+  })
+}