dsh-ptc-plus 0.3.1 → 0.3.2

package/internal/cell-rewriter.js

@@ -3,6 +3,10 @@ import { parse } from '@babel/parser'
 import traverseModule, { Hub, NodePath } from '@babel/traverse'
 import { bindingNodes, createGeneratedNameAllocator } from './binding-pattern.js'
 import { applySourceEdits, createMappedTextBuilder, identitySourceMap } from './source-position-map.js'
+import {
+  LEGACY_DEFAULT_EXPORT_BINDING,
+  LIVE_DEFAULT_EXPORT_BINDING,
+} from './repl-rewrite-contract.js'
 
 export const STRIP_PREFIX = 'async function __ptc_cell__(){\n'
 export const STRIP_SUFFIX = '\n}'
@@ -429,7 +433,96 @@ function exportAllEdits(node, code, edits, rewrites, moduleLoads) {
   rewrites.push(record('export', `converted the re-export of ${JSON.stringify(source)} into a side-effect import`, node, source))
 }
 
-function exportDefaultEdits(node, code, edits, rewrites, defaultNameAvailable, exportDeclarations) {
+function exportDefaultEdits({
+  node,
+  code,
+  edits,
+  rewrites,
+  defaultNameAvailable,
+  exportDeclarations,
+  imports,
+  allocateNamespace,
+  commitSignal,
+  commitTargets,
+}) {
+  const declaration = node.declaration
+  if (declaration.type === 'TSInterfaceDeclaration') {
+    editNode(edits, node, code)
+    rewrites.push(record('export', 'removed a type-only export declaration', node, 'interface'))
+    return
+  }
+  if (!defaultNameAvailable) {
+    throw new ModuleRewriteError(
+      'export default cannot be exposed as __default because that name is already declared',
+      { line: node.loc.start.line, column: node.loc.start.column + 1 },
+    )
+  }
+  const namedDeclaration = (declaration.type === 'FunctionDeclaration'
+    || declaration.type === 'ClassDeclaration') && declaration.id !== null
+  const retainedNamedDeclaration = namedDeclaration && declaration.id.name !== '__default'
+  const existingAlias = imports.get('__default')
+  const reuseAlias = existingAlias?.syntheticDefault === true
+  const namespace = reuseAlias ? existingAlias.namespace : allocateNamespace('default_namespace')
+  const member = importMember(namespace, 'default')
+  imports.set('__default', {
+    namespace,
+    imported: 'default',
+    syntheticDefault: true,
+    commitDependency: '__default',
+  })
+  commitTargets.add('__default')
+  if (declaration.type === 'ClassDeclaration' && declaration.id !== null) {
+    commitTargets.add(declaration.id.name)
+  }
+  exportDeclarations.push({
+    name: '__default',
+    kind: declaration.type === 'FunctionDeclaration'
+      ? 'function'
+      : declaration.type === 'ClassDeclaration' ? 'class' : 'variable',
+    commitDependency: '__default',
+    span: {
+      line: node.loc.start.line,
+      column: node.loc.start.column + 1,
+      end: {
+        line: node.loc.end.line,
+        column: node.loc.end.column + 1,
+      },
+    },
+    definitionSpan: {
+      line: node.loc.start.line,
+      column: node.loc.start.column + 1,
+      end: {
+        line: node.loc.end.line,
+        column: node.loc.end.column + 1,
+      },
+    },
+    original: true,
+  })
+  const rewrite = record('export', 'converted the default export into a local __default binding', node)
+  const commit = [...new Set([...(declaration.type === 'ClassDeclaration' && declaration.id !== null
+    ? [declaration.id.name]
+    : []), '__default'])]
+    .map(name => ` this[${JSON.stringify(commitSignal)}](${JSON.stringify(name)});`)
+    .join('')
+  const assignmentPrefix = reuseAlias ? `${member} = ` : `const ${namespace} = { default: `
+  const assignmentSuffix = reuseAlias ? '' : ' }'
+  if (retainedNamedDeclaration) {
+    edit(edits, node.start, declaration.start, preserveLines(code.slice(node.start, declaration.start)))
+    edit(edits, node.end, node.end,
+      `; ${assignmentPrefix}${declaration.id.name}${assignmentSuffix};${commit}`)
+  } else if (declaration.type === 'FunctionDeclaration' || declaration.type === 'ClassDeclaration') {
+    const prefix = code.slice(node.start, declaration.start)
+    edit(edits, node.start, declaration.start, preserveLines(prefix, assignmentPrefix))
+    edit(edits, node.end, node.end, `${assignmentSuffix};${commit}`)
+  } else {
+    const prefix = code.slice(node.start, declaration.start)
+    edit(edits, node.start, declaration.start, preserveLines(prefix, assignmentPrefix))
+    edit(edits, node.end, node.end, `${assignmentSuffix};${commit}`)
+  }
+  rewrites.push(rewrite)
+}
+
+function legacyExportDefaultEdits(node, code, edits, rewrites, defaultNameAvailable, exportDeclarations) {
   const declaration = node.declaration
   if (declaration.type === 'TSInterfaceDeclaration') {
     editNode(edits, node, code)
@@ -490,7 +583,11 @@ function exportDefaultEdits(node, code, edits, rewrites, defaultNameAvailable, e
 
 function ascending(left, right) { return left.at - right.at }
 
-export function rewriteModuleImportsExports(program, enabled, existingImports = new Map(), existingNamespaces = new Set(), unavailableNames = new Set()) {
+export function rewriteModuleImportsExports(program, enabled, existingImports = new Map(), existingNamespaces = new Set(), unavailableNames = new Set(), moduleSemantics = { defaultExportBinding: LIVE_DEFAULT_EXPORT_BINDING }) {
+  if (![LEGACY_DEFAULT_EXPORT_BINDING, LIVE_DEFAULT_EXPORT_BINDING]
+    .includes(moduleSemantics?.defaultExportBinding)) {
+    throw new TypeError('ptc-plus: unsupported default export binding semantics')
+  }
   const tree = parseCell(program)
   const edits = []
   const rewrites = []
@@ -500,6 +597,7 @@ export function rewriteModuleImportsExports(program, enabled, existingImports =
   const moduleLoads = []
   const importNamespaces = new Set(existingNamespaces)
   const allocateName = createGeneratedNameAllocator(tree, [...unavailableNames, ...importNamespaces])
+  const commitSignal = allocateName('redeclaration_commit')
   const generatedNamespaces = new Set()
   const allocateImportName = purpose => {
     const name = allocateName(purpose)
@@ -508,7 +606,8 @@ export function rewriteModuleImportsExports(program, enabled, existingImports =
     return name
   }
   const namespaceCaptures = []
-  const defaultNameAvailable = !tree.body.some((node) => {
+  const commitTargets = new Set()
+  const currentCellDefaultNameAvailable = !tree.body.some((node) => {
     const declaration = node.type === 'ExportNamedDeclaration' ? node.declaration : node
     if (declaration?.type === 'VariableDeclaration' && declaration.declare !== true) {
       return declaration.declarations.some(entry => bindingNodes(entry.id).some(binding => binding.name === '__default'))
@@ -520,6 +619,12 @@ export function rewriteModuleImportsExports(program, enabled, existingImports =
       specifier.importKind !== 'type' && specifier.local.name === '__default'
     ))
   })
+  const existingDefault = existingImports.get('__default')
+  const persistentDefaultNameAvailable = !unavailableNames.has('__default')
+    || existingDefault?.syntheticDefault === true
+  const defaultNameAvailable = currentCellDefaultNameAvailable
+    && (moduleSemantics.defaultExportBinding === LEGACY_DEFAULT_EXPORT_BINDING
+      || persistentDefaultNameAvailable)
   for (const node of tree.body) {
     if (node.type === 'ImportDeclaration' && enabled.autoRewriteImports) {
       importEdits(node, program, edits, rewrites, imports, importDeclarations,
@@ -532,7 +637,24 @@ export function rewriteModuleImportsExports(program, enabled, existingImports =
       exportAllEdits(node, program, edits, rewrites, moduleLoads)
     }
     else if (node.type === 'ExportDefaultDeclaration' && enabled.autoStripExports) {
-      exportDefaultEdits(node, program, edits, rewrites, defaultNameAvailable, exportDeclarations)
+      if (moduleSemantics.defaultExportBinding === LEGACY_DEFAULT_EXPORT_BINDING) {
+        legacyExportDefaultEdits(
+          node, program, edits, rewrites, defaultNameAvailable, exportDeclarations,
+        )
+      } else {
+        exportDefaultEdits({
+          node,
+          code: program,
+          edits,
+          rewrites,
+          defaultNameAvailable,
+          exportDeclarations,
+          imports,
+          allocateNamespace: allocateImportName,
+          commitSignal,
+          commitTargets,
+        })
+      }
     }
   }
   assertNoDynamicImportResolution(tree, imports)
@@ -549,6 +671,8 @@ export function rewriteModuleImportsExports(program, enabled, existingImports =
     importDeclarations,
     exportDeclarations,
     moduleLoads,
+    commitSignal,
+    commitTargets,
     rewrites: rewrites.map(({ at: _at, ...rest }) => rest),
   }
 }

package/internal/config-spec.js

@@ -65,6 +65,15 @@ export const CONFIG_FIELDS = Object.freeze([
     description: '允许顶层 const 或 let 声明替换已有变量；关闭后，重声明会在执行前被拒绝。',
     descriptionEn: 'Allows top-level const or let declarations to replace existing variables; disabling rejects redeclarations before execution.',
   },
+  {
+    key: 'looseTopLevelFunctionClassRedeclarations',
+    type: 'boolean',
+    default: false,
+    label: '允许顶层函数/类重声明',
+    labelEn: 'Allow top-level function/class redeclarations',
+    description: '允许顶层 function 或 class 声明替换已有的可写 binding；不可写或保留 binding 仍会在执行前被拒绝。',
+    descriptionEn: 'Allows top-level function or class declarations to replace existing writable bindings; immutable and reserved bindings are still rejected before execution.',
+  },
   {
     key: 'autoRewriteImports',
     type: 'boolean',
@@ -253,6 +262,7 @@ export const CONFIG_GROUPS = Object.freeze([
     labelEn: 'Advanced behavior',
     fields: Object.freeze([
       'looseTopLevelRedeclarations',
+      'looseTopLevelFunctionClassRedeclarations',
       'autoRewriteImports',
       'autoStripExports',
       'autoSplitRedeclarations',

package/internal/edit-transport-owner.js

@@ -147,7 +147,7 @@ export function createEditTransportOwner(ctx, {
     if (typeof ctx.tools.execute !== 'function') {
       throw new Error('ptc-plus: DSH tools.execute is required for derived edit execution')
     }
-    const persistedCallSeq = currentDurableReplay ? persistedTargetCallSeq : undefined
+    const persistedCallSeq = persistedTargetCallSeq
     const id = sessionId(agent)
     let claims = editClaims.get(id)
     if (claims === undefined) {

package/internal/kernel-worker.js

@@ -366,6 +366,7 @@ async function runCell(message) {
   pendingVolatileReason = undefined
   activeExecution = execution
   const cellGlobals = []
+  const committedRedeclarations = new Set()
 
   try {
     let completion
@@ -376,6 +377,13 @@ async function runCell(message) {
           value: CellReturn,
         })
         cellGlobals.push(message.returnSignal)
+        Object.defineProperty(context, message.commitSignal, {
+          configurable: true,
+          value(name) {
+            committedRedeclarations.add(name)
+          },
+        })
+        cellGlobals.push(message.commitSignal)
         for (const load of message.moduleLoads ?? []) {
           let namespace
           try {
@@ -421,6 +429,7 @@ async function runCell(message) {
         ...(position === undefined ? {} : { position }),
         ...(detail.cause === undefined ? {} : { cause: detail.cause }),
         ...completionDurability(execution),
+        committedRedeclarations: [...committedRedeclarations],
       })
       return
     }
@@ -437,6 +446,7 @@ async function runCell(message) {
         hasValue: completion.hasValue,
         ...(encodedValue === undefined ? {} : { value: encodedValue }),
         ...completionDurability(execution),
+        committedRedeclarations: [...committedRedeclarations],
       }
     } catch (error) {
       const detail = messageOf(error)
@@ -446,6 +456,7 @@ async function runCell(message) {
         logs: execution.logs,
         invalidOutput: detail,
         ...completionDurability(execution),
+        committedRedeclarations: [...committedRedeclarations],
       }
     }
     channel.postMessage(response)

package/internal/repl-convenience.js

@@ -1,4 +1,10 @@
 import { bindingNodes, createGeneratedNameAllocator } from './binding-pattern.js'
+import {
+  CLASS_REDECLARATION_REWRITE,
+  FUNCTION_REDECLARATION_REWRITE,
+  MIXED_REDECLARATION_REWRITE,
+  redeclarationCommitTarget,
+} from './repl-rewrite-contract.js'
 import { applySourceEdits, createMappedTextBuilder, identitySourceMap } from './source-position-map.js'
 import { SKIP_AST_CHILDREN, walkAst } from './ast-traversal.js'
 
@@ -88,16 +94,41 @@ function bindingEntries(pattern, declarationSpan) {
   }))
 }
 
-export function rewriteLooseRedeclarations({
+function existingFunctionText(statement, code, offset) {
+  const builder = createMappedTextBuilder(code, offset)
+  builder.append(';(')
+  builder.appendMapped(statement.id.name, statement.id.start, statement.id.end)
+  builder.append(' = ')
+  builder.appendSource(statement.start, statement.id.start)
+  builder.appendSource(statement.id.end, statement.end)
+  builder.append(');')
+  return builder.result()
+}
+
+function existingClassText(statement, code, offset) {
+  const builder = createMappedTextBuilder(code, offset)
+  builder.append(';(')
+  builder.appendMapped(statement.id.name, statement.id.start, statement.id.end)
+  builder.append(' = ')
+  builder.appendSource(statement.start, statement.end)
+  builder.append(');')
+  return builder.result()
+}
+
+export function rewriteReplRedeclarations({
   code,
   sourceMap = identitySourceMap(code.length),
   body,
   offset,
   knownBindings,
+  variableRedeclarationBindings = knownBindings,
+  writableBindings,
   declarations,
   declarationSpan,
   collisionFor,
+  bindingPolicy,
   autoSplitRedeclarations,
+  commitSignal,
 }) {
   const redeclared = []
   const rewrites = []
@@ -117,7 +148,47 @@ export function rewriteLooseRedeclarations({
     if (statement.type !== 'VariableDeclaration') {
       if ((statement.type === 'FunctionDeclaration' || statement.type === 'ClassDeclaration')
         && statement.id !== null && knownBindings.has(statement.id.name)) {
-        rejected.push({ name: statement.id.name, span: declarationSpan(statement.id) })
+        const kind = statement.type === 'ClassDeclaration' ? 'class' : 'function'
+        if (!writableBindings.has(statement.id.name)) {
+          rejected.push({
+            name: statement.id.name,
+            kind,
+            reason: 'binding-not-writable',
+            span: declarationSpan(statement.id),
+          })
+        } else if (!bindingPolicy.functionClassRedeclarations) {
+          rejected.push({
+            name: statement.id.name,
+            kind,
+            reason: 'function-class-redeclarations-disabled',
+            span: declarationSpan(statement.id),
+          })
+        } else {
+          const commitDependency = redeclarationCommitTarget(statement.id.name, statement.start)
+          const replacement = kind === 'class'
+            ? existingClassText(statement, code, offset)
+            : existingFunctionText(statement, code, offset)
+          replacement.text += ` void 0; this[${JSON.stringify(commitSignal)}](${JSON.stringify(commitDependency)});`
+          replacements.push({
+            start: statement.start - offset,
+            end: statement.end - offset,
+            text: replacement.text,
+            mappings: replacement.mappings,
+          })
+          redeclared.push(collisionFor({
+            name: statement.id.name,
+            kind,
+            commitDependency,
+            span: declarationSpan(statement.id),
+          }))
+          rewrites.push({
+            kind: 'redeclaration',
+            description: kind === 'class'
+              ? CLASS_REDECLARATION_REWRITE
+              : FUNCTION_REDECLARATION_REWRITE,
+            source: statement.id.name,
+          })
+        }
       }
       continue
     }
@@ -125,7 +196,24 @@ export function rewriteLooseRedeclarations({
     let statementRejected = false
     for (const declarator of statement.declarations) {
       const bindings = bindingEntries(declarator.id, declarationSpan)
-      const existing = bindings.filter(binding => knownBindings.has(binding.name))
+      const existing = bindings.filter(binding => variableRedeclarationBindings.has(binding.name))
+      const immutable = existing.filter(binding => !writableBindings.has(binding.name))
+      if (immutable.length > 0) {
+        rejected.push(...immutable.map(binding => ({
+          ...binding,
+          reason: 'binding-not-writable',
+        })))
+        statementRejected = true
+        continue
+      }
+      if (existing.length > 0 && !bindingPolicy.variableRedeclarations) {
+        rejected.push(...existing.map(binding => ({
+          ...binding,
+          reason: 'variable-redeclarations-disabled',
+        })))
+        statementRejected = true
+        continue
+      }
       if (existing.length > 0 && existing.length < bindings.length) {
         if (autoSplitRedeclarations) entries.push({ declarator, bindings, existing })
         else {
@@ -138,7 +226,7 @@ export function rewriteLooseRedeclarations({
     }
     if (statementRejected) continue
     if (!entries.some(entry => entry.existing.length > 0)) {
-      if (statement.kind === 'const') {
+      if (statement.kind === 'const' && bindingPolicy.variableRedeclarations) {
         replacements.push({
           start: statement.start - offset,
           end: statement.start - offset + statement.kind.length,
@@ -164,7 +252,7 @@ export function rewriteLooseRedeclarations({
         appendPart(mixedDeclaratorText(
           statement,
           declarator,
-          bindings.map(binding => ({ ...binding, existing: knownBindings.has(binding.name) })),
+          bindings.map(binding => ({ ...binding, existing: existing.includes(binding) })),
           code,
           offset,
           allocateName,
@@ -172,7 +260,7 @@ export function rewriteLooseRedeclarations({
         redeclared.push(...existing.map(collisionFor))
         rewrites.push({
           kind: 'redeclaration',
-          description: 'split a mixed top-level declaration while preserving native pattern initialization',
+          description: MIXED_REDECLARATION_REWRITE,
           source: existing.map(binding => binding.name).join(', '),
         })
       } else if (existing.length === bindings.length && bindings.length > 0) {

package/internal/repl-rewrite-contract.js

@@ -0,0 +1,15 @@
+export const MIXED_REDECLARATION_REWRITE =
+  'split a mixed top-level declaration while preserving native pattern initialization'
+
+export const FUNCTION_REDECLARATION_REWRITE =
+  'reassigned an existing top-level function declaration for REPL continuity'
+
+export const CLASS_REDECLARATION_REWRITE =
+  'reassigned an existing top-level class declaration for REPL continuity'
+
+export const LEGACY_DEFAULT_EXPORT_BINDING = 'legacy-variable'
+export const LIVE_DEFAULT_EXPORT_BINDING = 'live-readonly'
+
+export function redeclarationCommitTarget(name, statementStart) {
+  return `redeclaration:${statementStart}:${name}`
+}

package/internal/runtime-config.js

@@ -23,6 +23,7 @@ const BOOLEAN_KEYS = Object.freeze([
   'cordisToolsEnabled',
   'canonicalizeToolCalls',
   'looseTopLevelRedeclarations',
+  'looseTopLevelFunctionClassRedeclarations',
   'durableReplay',
   'autoRewriteImports',
   'autoStripExports',

package/internal/session-cell-executor.js

@@ -18,6 +18,7 @@ import {
 } from './failure-reporting.js'
 import { assertStateName } from './session-journal.js'
 import { PreflightError, prepareProgram } from './cell-analysis.js'
+import { LIVE_DEFAULT_EXPORT_BINDING } from './repl-rewrite-contract.js'
 import { ModuleRewriteError } from './cell-rewriter.js'
 import { mapSourcePosition } from './source-position-map.js'
 import { durabilityState, transitionDurability } from './session-state.js'
@@ -105,9 +106,47 @@ function preflightDiagnostic(error) {
   })
 }
 
+function committedRedeclarationSet(message, prepared) {
+  if (!Array.isArray(message.committedRedeclarations)) {
+    throw new Error('kernel returned an invalid committed redeclaration set')
+  }
+  const allowed = prepared.commitTargets
+  const committed = new Set()
+  for (const name of message.committedRedeclarations) {
+    if (typeof name !== 'string' || committed.has(name) || !allowed.has(name)) {
+      throw new Error('kernel returned an invalid committed redeclaration set')
+    }
+    committed.add(name)
+  }
+  return committed
+}
+
 function collisionDiagnostic(collisions) {
   const names = [...new Set(collisions.map(item => item.name))]
+  const reasons = new Set(collisions.map(item => item.reason).filter(Boolean))
+  const disabledKinds = new Set(collisions
+    .filter(item => item.reason === 'function-class-redeclarations-disabled')
+    .map(item => item.kind))
   const first = collisions[0]
+  const alternatives = [
+    ...(disabledKinds.size === 2
+      ? ['assign function or class expressions to the existing writable bindings']
+      : disabledKinds.has('function')
+        ? ['assign a function expression to the existing writable binding']
+        : disabledKinds.has('class')
+          ? ['assign a class expression to the existing writable binding']
+          : []),
+    ...((reasons.size === 0 || reasons.has('variable-redeclarations-disabled'))
+      ? ['reuse the existing bindings']
+      : []),
+  ]
+  const help = [
+    ...(reasons.has('binding-not-writable')
+      ? ['use a fresh name because the existing binding is immutable']
+      : []),
+    ...(alternatives.length === 0 ? [] : [alternatives.join('; ')]),
+    'place one-off declarations inside a block',
+  ]
   return diagnostic({
     code: 'PTC-N001',
     severity: 'error',
@@ -115,10 +154,7 @@ function collisionDiagnostic(collisions) {
     message: `top-level bindings already exist: ${names.join(', ')}. This cell was not executed; the REPL state is unchanged.`,
     stateEffect: 'unchanged',
     source: { cell: 'current', start: first.start, end: first.end },
-    help: [
-      'reuse the existing bindings',
-      'place one-off declarations inside a block',
-    ],
+    help,
   })
 }
 
@@ -218,22 +254,28 @@ export class SessionCellExecutor {
     }
 
     const catalog = kernel.bindingCatalog.inputs()
-    const looseTopLevelRedeclarations = replayRecord === undefined
-      ? config.looseTopLevelRedeclarations
-      : replayRecord.bindingMode === 'loose'
+    const bindingPolicy = replayRecord === undefined ? {
+      variableRedeclarations: config.looseTopLevelRedeclarations,
+      functionClassRedeclarations: config.looseTopLevelFunctionClassRedeclarations,
+    } : replayRecord.bindingPolicy
     const rewritesEnabled = replayRecord === undefined ? {
       autoRewriteImports: config.autoRewriteImports,
       autoStripExports: config.autoStripExports,
       autoSplitRedeclarations: config.autoSplitRedeclarations,
     } : replayRecord.rewritePolicy
+    const moduleSemantics = replayRecord === undefined ? {
+      defaultExportBinding: LIVE_DEFAULT_EXPORT_BINDING,
+    } : replayRecord.moduleSemantics
     const prepareCell = program => prepareProgram(
       program,
       catalog.knownBindings,
-      looseTopLevelRedeclarations,
+      bindingPolicy,
       request.bindingDescriptors.reservedNames,
       rewritesEnabled,
       catalog.importBindings,
       catalog.importNamespaces,
+      catalog.writableBindings,
+      moduleSemantics,
     )
     let prepared
     try {
@@ -348,6 +390,7 @@ export class SessionCellExecutor {
           type: 'run', id, program: prepared.code, namespaces: bindings.workerDescriptors,
           moduleLoads: prepared.moduleLoads,
           returnSignal: prepared.returnSignal,
+          commitSignal: prepared.commitSignal,
           maxOutputBytes: config.maxOutputBytes,
           valueLimits,
           durability,
@@ -480,6 +523,20 @@ export class SessionCellExecutor {
       }, true)
       return
     }
+    let committed
+    try {
+      committed = committedRedeclarationSet(message, active.prepared)
+    } catch (error) {
+      active.resolve(earlyResult('worker-exit', messageOf(error)), true)
+      return
+    }
+    active.appliedBindingCatalog = message.moduleLoadFailed === true
+      ? active.priorBindingCatalog
+      : active.priorBindingCatalog.advance(
+          active.prepared,
+          active.request.program,
+          committed,
+        )
     if (typeof message.error === 'string') {
       const rawError = {
         kind: 'exception',
@@ -501,9 +558,6 @@ export class SessionCellExecutor {
         declared: message.moduleLoadFailed === true ? new Set() : active.prepared.declared,
         longCellFailure: active.request.program.length >= LONG_CELL_CODE_UNITS,
       })
-      active.appliedBindingCatalog = message.moduleLoadFailed === true
-        ? active.priorBindingCatalog
-        : active.priorBindingCatalog.advance(active.prepared, active.request.program)
       const recordedFailure = active.replay?.diagnostics?.find(item => item.code === 'PTC-X001')
       const failure = recordedFailure?.message === actualFailure.message ? recordedFailure : actualFailure
       const error = {
@@ -532,10 +586,6 @@ export class SessionCellExecutor {
         hasValue: message.hasValue,
         ...(message.hasValue ? { value } : {}),
       }
-      active.appliedBindingCatalog = active.priorBindingCatalog.advance(
-        active.prepared,
-        active.request.program,
-      )
       if (active.replay?.completion?.kind === 'return'
         && (active.replay.completion.hasValue !== message.hasValue
           || (message.hasValue && !valueWiresEqual(active.replay.completion.value, value, active.valueLimits)))) {