dsh-ptc-plus 0.4.1 → 0.4.2

package/internal/module-compilation.js

@@ -14,7 +14,7 @@ export { commonJsExportEvidence, linkCommonJsEvidenceSource } from './commonjs-s
 import { COMMONJS_PARAMETERS } from './compiler-scope-facts.js'
 import {
   LEGACY_USER_BINDING_TRANSFORM, USER_BINDING_TRANSFORM, PROTECTED_MODULE_TRANSFORM,
-  supportedUserBindingTransform, transformTypeScriptSource,
+  isStatefulUserBindingTransform, supportedUserBindingTransform, transformTypeScriptSource,
 } from './typescript-transform.js'
 
 const topLevelRegion = region => region.kind === 'program' || region.top === true
@@ -162,7 +162,7 @@ function commonJsBodyRange(source) {
 
 /** Module activations share lexical updates while retaining the native linker. */
 export function compileStatefulModule(source, {
-  transform = USER_BINDING_TRANSFORM, target = 'module', url, nativeUsing,
+  transform = USER_BINDING_TRANSFORM, target = 'module', url, nativeUsing, programBindings = false,
 } = {}) {
   if (transform !== PROTECTED_MODULE_TRANSFORM && !supportedUserBindingTransform(transform)) {
     throw new TypeError('user binding snapshot cannot prove its historical TypeScript transform')
@@ -188,14 +188,14 @@ export function compileStatefulModule(source, {
     nativeJavaScript = marked.nativeJavaScript
     mapped = marked
     if (!nativeJavaScript) mapped = normalizeTypeScriptValues(mapped.code, mapped.sourceMap, target)
-    if (target !== 'commonjs' && (transform === USER_BINDING_TRANSFORM
+    if (target !== 'commonjs' && (isStatefulUserBindingTransform(transform)
       || transform === PROTECTED_MODULE_TRANSFORM && hasModuleResources(mapped.code))) {
       mapped = normalizeModuleExports(mapped.code, mapped.sourceMap)
     }
   }
   const commonJsSource = target === 'commonjs'
     ? commonJsExportEvidence(mapped.code, { legacy: transform === LEGACY_USER_BINDING_TRANSFORM }) : undefined
-  const links = transform === USER_BINDING_TRANSFORM && target === 'module'
+  const links = isStatefulUserBindingTransform(transform) && target === 'module'
     ? moduleLinkPlan(mapped.code) : undefined
   let normalized = transform === LEGACY_USER_BINDING_TRANSFORM ? mapped
     : normalizeStatefulScopes(mapped.code, mapped.sourceMap, { target, moduleImport: links?.reader, nativeJavaScript, nativeUsing,
@@ -222,6 +222,7 @@ export function compileStatefulModule(source, {
     sourceRegions: normalized.sourceRegions,
     callableCollector: createRegionCallableCollector(callableSources),
     module: true, compactOutput: true, importOperation: normalized.importOperation, sourceType, originalSource: source,
+    logicalRoots: programBindings,
     bindings: normalized.dynamicBindings, privateBindings: normalized.privateBindings,
     internalBindings: normalized.internalBindings, parserPlugins: CELL_PARSER_PLUGINS,
   }) }

package/internal/module-transform-contract.js

@@ -1,12 +1,42 @@
 export const LEGACY_USER_BINDING_TRANSFORM = 'amaro@1.1.11'
-export const USER_BINDING_TRANSFORM = 'stateful-module-v1+amaro@1.1.11'
+export const PREVIOUS_USER_BINDING_TRANSFORM = 'stateful-module-v1+amaro@1.1.11'
+export const USER_BINDING_TRANSFORM = 'stateful-module-v2+amaro@1.1.11'
 export const PROTECTED_MODULE_TRANSFORM = 'protected-module-v1+amaro@1.1.11'
+export const MODULE_TRANSFORMS = new Set([
+  LEGACY_USER_BINDING_TRANSFORM,
+  PREVIOUS_USER_BINDING_TRANSFORM,
+  USER_BINDING_TRANSFORM,
+  PROTECTED_MODULE_TRANSFORM,
+])
+
+export function isStatefulUserBindingTransform(transform) {
+  return transform === USER_BINDING_TRANSFORM || transform === PREVIOUS_USER_BINDING_TRANSFORM
+}
 
 export function moduleTransformForLanguage(languageSemantics) {
   return languageSemantics === 'stateful-v1' ? USER_BINDING_TRANSFORM
     : languageSemantics === 'protected-v1' ? PROTECTED_MODULE_TRANSFORM : LEGACY_USER_BINDING_TRANSFORM
 }
 
+export function historicalModuleTransformForLanguage(languageSemantics) {
+  return languageSemantics === 'stateful-v1' ? PREVIOUS_USER_BINDING_TRANSFORM
+    : languageSemantics === 'protected-v1' ? PROTECTED_MODULE_TRANSFORM : LEGACY_USER_BINDING_TRANSFORM
+}
+
+export function moduleTransformMatchesLanguage(transform, languageSemantics) {
+  return languageSemantics === 'stateful-v1' ? isStatefulUserBindingTransform(transform)
+    : languageSemantics === 'protected-v1' ? transform === PROTECTED_MODULE_TRANSFORM
+      : languageSemantics === 'legacy-v1' ? transform === LEGACY_USER_BINDING_TRANSFORM : false
+}
+
+export function normalizeModuleTransform(transform, languageSemantics) {
+  if (!MODULE_TRANSFORMS.has(transform)) throw new TypeError('invalid dsh-ptc-plus journal module transform')
+  if (!moduleTransformMatchesLanguage(transform, languageSemantics)) {
+    throw new TypeError('dsh-ptc-plus journal module transform does not match its language semantics')
+  }
+  return transform
+}
+
 export function supportedUserBindingTransform(transform) {
-  return transform === USER_BINDING_TRANSFORM || transform === LEGACY_USER_BINDING_TRANSFORM
+  return isStatefulUserBindingTransform(transform) || transform === LEGACY_USER_BINDING_TRANSFORM
 }

package/internal/record-utils.js

@@ -1,14 +1,22 @@
 /** Shared structural guards for closed PTC metadata boundaries. */
 
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
+
+const { TypeError, isArray, reflectOwnKeys, objectGetOwnPropertyDescriptor,
+  objectHasOwn, objectPropertyIsEnumerable, objectFreeze, trimString, toString,
+  Set, setHas, setAdd, setSize, appendArray, popArray } = internal
+
 export function isRecord(value) {
-  return value !== null && typeof value === 'object' && !Array.isArray(value)
+  return value !== null && typeof value === 'object' && !isArray(value)
 }
 
 export function assertOwnFields(value, allowed, label) {
-  for (const key of Reflect.ownKeys(value)) {
-    if (typeof key !== 'string' || !allowed.has(key)
-      || !Object.prototype.propertyIsEnumerable.call(value, key)) {
-      throw new TypeError(`invalid ${label} field ${String(key)}`)
+  const keys = reflectOwnKeys(value)
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index]
+    if (typeof key !== 'string' || !setHas(allowed, key)
+      || !objectPropertyIsEnumerable(value, key)) {
+      throw new TypeError(`invalid ${label} field ${toString(key)}`)
     }
   }
 }
@@ -16,7 +24,7 @@ export function assertOwnFields(value, allowed, label) {
 export function assertFields(value, allowed, label) {
   if (!isRecord(value)) throw new TypeError(`invalid ${label}`)
   assertOwnFields(value, allowed, label)
-  if (Reflect.ownKeys(value).length !== allowed.size) throw new TypeError(`invalid ${label} fields`)
+  if (reflectOwnKeys(value).length !== setSize(allowed)) throw new TypeError(`invalid ${label} fields`)
 }
 
 export function record(value, label) {
@@ -25,7 +33,7 @@ export function record(value, label) {
 }
 
 export function text(value, label) {
-  if (typeof value !== 'string' || value.trim().length === 0) {
+  if (typeof value !== 'string' || trimString(value).length === 0) {
     throw new TypeError(`ptc-plus: ${label} must be a non-empty string`)
   }
   return value
@@ -37,17 +45,18 @@ export function deepFreeze(value) {
   const pending = [value]
   const seen = new Set()
   while (pending.length > 0) {
-    const current = pending.pop()
-    if (seen.has(current)) continue
-    seen.add(current)
-    for (const key of Reflect.ownKeys(current)) {
-      const descriptor = Object.getOwnPropertyDescriptor(current, key)
-      if (descriptor !== undefined && Object.hasOwn(descriptor, 'value')) {
+    const current = popArray(pending)
+    if (setHas(seen, current)) continue
+    setAdd(seen, current)
+    const keys = reflectOwnKeys(current)
+    for (let index = 0; index < keys.length; index += 1) {
+      const descriptor = objectGetOwnPropertyDescriptor(current, keys[index])
+      if (descriptor !== undefined && objectHasOwn(descriptor, 'value')) {
         const child = descriptor.value
-        if (child !== null && typeof child === 'object') pending.push(child)
+        if (child !== null && typeof child === 'object') appendArray(pending, child)
       }
     }
-    Object.freeze(current)
+    objectFreeze(current)
   }
   return value
 }

package/internal/repl-value-observer.js

@@ -1,5 +1,5 @@
 import { types } from 'node:util'
-import { runInContext } from 'node:vm'
+import { isContext, runInContext, runInThisContext } from 'node:vm'
 import { parse } from 'acorn'
 import { randomUUID } from 'node:crypto'
 import { walkAst, SKIP_AST_CHILDREN } from './ast-traversal.js'
@@ -16,6 +16,9 @@ const now = Date.now
 const bigintText = BigInt.prototype.toString
 const BIGINT_LIMIT = 10n ** 128n
 const unreadable = () => ({ status: 'unreadable', text: '', truncated: false })
+const runInRealm = (source, context, options) => isContext(context)
+  ? runInContext(source, context, options)
+  : runInThisContext(source, options)
 
 function primitiveText(value) {
   if (typeof value === 'string') return stringify(value.slice(0, MAX_TEXT))
@@ -56,7 +59,7 @@ export async function supportsAwaitLexicals(context, evaluate) {
   try {
     await evaluate(`let ${names[0]} = await Promise.resolve(41); const ${names[1]} = 42;`)
     return names.every((name, index) => ownDescriptor(context, name) === undefined
-      && runInContext(name, context, { timeout: 25 }) === index + 41)
+      && runInRealm(name, context, { timeout: 25 }) === index + 41)
   } catch {
     return false
   } finally {
@@ -97,7 +100,7 @@ export function createReplValueObserver(context, { awaitLexicals = false } = {})
           if (lexicals.has(name)) {
             // Lexical storage shadows global properties, even while uninitialized.
             if (/^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u.test(name) && now() - at < 100) {
-              preview = previewBindingValue(runInContext(name, context, { timeout: 25, displayErrors: false }))
+              preview = previewBindingValue(runInRealm(name, context, { timeout: 25, displayErrors: false }))
             }
           } else if (globals.has(name)) {
             const descriptor = ownDescriptor(context, name)

package/internal/runtime-intrinsics.js

@@ -0,0 +1,101 @@
+import { compilerDescriptors } from './compiler-descriptors.js'
+
+const uncurry = Function.prototype.bind.bind(Function.prototype.call)
+const mapKeys = uncurry(Map.prototype.keys)
+const mapIteratorNext = uncurry(Object.getPrototypeOf(new Map().keys()).next)
+const weakMapGet = uncurry(WeakMap.prototype.get)
+const weakMapSet = uncurry(WeakMap.prototype.set)
+
+function appendArray(target, value) {
+  compilerDescriptors.defineProperty(target, target.length,
+    { value, writable: true, enumerable: true, configurable: true })
+  return target
+}
+
+function copyArray(source, start = 0, end = source.length, target = []) {
+  for (let index = start; index < end; index++) appendArray(target, source[index])
+  return target
+}
+
+/** Host-private operations captured before any owned realm executes user code. */
+export const runtimeIntrinsics = {
+  Object: compilerDescriptors.Object,
+  Reflect: {
+    apply: Reflect.apply,
+    construct: Reflect.construct,
+    deleteProperty: Reflect.deleteProperty,
+    defineProperty: compilerDescriptors.reflectDefineProperty,
+    has: Reflect.has,
+    ownKeys: Reflect.ownKeys,
+  },
+  Error, TypeError, Array, Map, Set, WeakMap, WeakSet, RegExp, Proxy,
+  objectCreate: Object.create,
+  objectDefineProperty: Object.defineProperty,
+  objectEntries: Object.entries,
+  objectFreeze: Object.freeze,
+  objectGetOwnPropertyDescriptor: Object.getOwnPropertyDescriptor,
+  objectGetPrototypeOf: Object.getPrototypeOf,
+  objectHasOwn: Object.hasOwn,
+  objectIs: Object.is,
+  objectKeys: Object.keys,
+  objectPropertyIsEnumerable: uncurry(Object.prototype.propertyIsEnumerable),
+  reflectOwnKeys: Reflect.ownKeys,
+  numberIsFinite: Number.isFinite,
+  numberIsNaN: Number.isNaN,
+  numberIsSafeInteger: Number.isSafeInteger,
+  toBigInt: BigInt,
+  toNumber: Number,
+  toString: String,
+  mapGet: uncurry(Map.prototype.get),
+  mapHas: uncurry(Map.prototype.has),
+  mapSet: uncurry(Map.prototype.set),
+  mapDelete: uncurry(Map.prototype.delete),
+  mapClear: uncurry(Map.prototype.clear),
+  mapSize: uncurry(Object.getOwnPropertyDescriptor(Map.prototype, 'size').get),
+  mapFirstKey: value => mapIteratorNext(mapKeys(value)).value,
+  mapForEach: uncurry(Map.prototype.forEach),
+  setHas: uncurry(Set.prototype.has),
+  setAdd: uncurry(Set.prototype.add),
+  setDelete: uncurry(Set.prototype.delete),
+  setClear: uncurry(Set.prototype.clear),
+  setSize: uncurry(Object.getOwnPropertyDescriptor(Set.prototype, 'size').get),
+  setForEach: uncurry(Set.prototype.forEach),
+  weakMapHas: uncurry(WeakMap.prototype.has),
+  weakMapGet,
+  weakMapSet,
+  weakSetHas: uncurry(WeakSet.prototype.has),
+  weakSetAdd: uncurry(WeakSet.prototype.add),
+  isArray: Array.isArray,
+  everyArray: uncurry(Array.prototype.every),
+  includes: uncurry(Array.prototype.includes),
+  join: uncurry(Array.prototype.join),
+  popArray: uncurry(Array.prototype.pop),
+  prependArray: uncurry(Array.prototype.unshift),
+  someArray: uncurry(Array.prototype.some),
+  sliceString: uncurry(String.prototype.slice),
+  splitString: uncurry(String.prototype.split),
+  searchString: uncurry(String.prototype.search),
+  replaceString: uncurry(String.prototype.replace),
+  trimString: uncurry(String.prototype.trim),
+  replaceAllString: uncurry(String.prototype.replaceAll),
+  includesString: uncurry(String.prototype.includes),
+  startsWith: uncurry(String.prototype.startsWith),
+  endsWith: uncurry(String.prototype.endsWith),
+  regexpExec: uncurry(RegExp.prototype.exec),
+  regexpTest: uncurry(RegExp.prototype.test),
+  floor: Math.floor,
+  min: Math.min,
+  max: Math.max,
+  appendArray,
+  copyArray,
+  sort: uncurry(Array.prototype.sort),
+  compare: uncurry(String.prototype.localeCompare),
+}
+
+if (typeof Buffer === 'function') {
+  runtimeIntrinsics.bufferByteLength = Buffer.byteLength
+  runtimeIntrinsics.bufferConcat = Buffer.concat
+  runtimeIntrinsics.bufferIsBuffer = Buffer.isBuffer
+  runtimeIntrinsics.bufferSubarray = uncurry(Buffer.prototype.subarray)
+  runtimeIntrinsics.bufferToString = uncurry(Buffer.prototype.toString)
+}

package/internal/session-cell-executor.js

@@ -414,7 +414,7 @@ export class SessionCellExecutor {
     }
     const priorBindingCatalog = userBindingPlan.catalog
     const catalog = priorBindingCatalog.inputs()
-    const { bindingPolicy, rewritesEnabled, moduleSemantics, languageSemantics } = executionPolicies(config, replayRecord)
+    const { bindingPolicy, rewritesEnabled, moduleSemantics, languageSemantics, moduleTransform } = executionPolicies(config, replayRecord)
     const prepareCell = program => prepareProgram(program, {
       knownBindings: catalog.knownBindings,
       bindingPolicy,
@@ -576,6 +576,7 @@ export class SessionCellExecutor {
             type: 'run', id, program: prepared.code, namespaces: bindings.workerDescriptors,
             moduleLoads: prepared.moduleLoads,
             languageSemantics,
+            moduleTransform,
             rootRuntimeName: prepared.rootRuntimeName,
             rootBindings: prepared.rootBindings,
             importBindingNamespaces: new Map([...catalog.importBindings].map(([name, binding]) => [name, binding.namespace])),

package/internal/session-journal-schema.js

@@ -13,7 +13,8 @@ export const RECOVERY_BOUNDARY_KEY = 'dshPtcPlusRecoveryBoundaries'
 export const IMPORT_BOUNDARY_JOURNAL_VERSION = 7
 export const PER_NAME_USER_BINDINGS_JOURNAL_VERSION = 8
 export const LANGUAGE_SEMANTICS_JOURNAL_VERSION = 9
-export const JOURNAL_VERSION = LANGUAGE_SEMANTICS_JOURNAL_VERSION
+export const MODULE_TRANSFORM_JOURNAL_VERSION = 10
+export const JOURNAL_VERSION = MODULE_TRANSFORM_JOURNAL_VERSION
 export const LIVE_USER_BINDINGS_SHADOW_POLICY = 'per-name'
 export const LEGACY_USER_BINDINGS_SHADOW_POLICY = 'whole-entry'
 export const LIVE_USER_BINDINGS_REUSE_POLICY = 'implementation-v1'
@@ -30,7 +31,8 @@ export const STATUSES = new Set(['durable', 'volatile', 'discarded', 'noop'])
 export const BINDING_MODES = new Set(['loose', 'strict'])
 export const WHOLE_ENTRY_JOURNAL_FIELDS = new Set(['version', 'bindingPolicy', 'rewritePolicy', 'moduleSemantics', 'userBindingsFingerprint', 'userBindingsReusePolicy', 'status', 'calls', 'operations', 'confirms', 'diagnostics', 'completion', 'volatileReason'])
 export const PER_NAME_JOURNAL_FIELDS = new Set([...WHOLE_ENTRY_JOURNAL_FIELDS, 'userBindingsShadowPolicy', 'userBindingNames'])
-export const JOURNAL_FIELDS = new Set([...PER_NAME_JOURNAL_FIELDS, 'languageSemantics'])
+export const LANGUAGE_SEMANTICS_JOURNAL_FIELDS = new Set([...PER_NAME_JOURNAL_FIELDS, 'languageSemantics'])
+export const JOURNAL_FIELDS = new Set([...LANGUAGE_SEMANTICS_JOURNAL_FIELDS, 'moduleTransform'])
 export const FINGERPRINT_REUSE_JOURNAL_FIELDS = new Set([...WHOLE_ENTRY_JOURNAL_FIELDS].filter(field => field !== 'userBindingsReusePolicy'))
 export const RELATIONLESS_JOURNAL_FIELDS = new Set([...FINGERPRINT_REUSE_JOURNAL_FIELDS].filter(field => field !== 'userBindingsFingerprint'))
 export const PREDECESSOR_JOURNAL_FIELDS = new Set(['version', 'bindingMode', 'rewritePolicy', 'status', 'calls', 'operations', 'confirms', 'diagnostics', 'completion', 'volatileReason'])
@@ -56,32 +58,47 @@ export const ERROR_FIELDS = new Set(['kind', 'message'])
 export const EDIT_TARGET_FIELDS = new Set(['targetCallSeq'])
 export const DERIVED_RUN_FIELDS = new Set(['code', 'description'])
 
-export const JOURNAL_VERSIONS = new Set([LEGACY_JOURNAL_VERSION, INTERMEDIATE_JOURNAL_VERSION, PREVIOUS_JOURNAL_VERSION, USER_BINDING_RELATIONLESS_JOURNAL_VERSION, FINGERPRINT_REUSE_JOURNAL_VERSION, VERSIONED_BINDING_REUSE_JOURNAL_VERSION, IMPORT_BOUNDARY_JOURNAL_VERSION, PER_NAME_USER_BINDINGS_JOURNAL_VERSION, JOURNAL_VERSION])
+export const JOURNAL_VERSIONS = new Set([LEGACY_JOURNAL_VERSION, INTERMEDIATE_JOURNAL_VERSION, PREVIOUS_JOURNAL_VERSION, USER_BINDING_RELATIONLESS_JOURNAL_VERSION, FINGERPRINT_REUSE_JOURNAL_VERSION, VERSIONED_BINDING_REUSE_JOURNAL_VERSION, IMPORT_BOUNDARY_JOURNAL_VERSION, PER_NAME_USER_BINDINGS_JOURNAL_VERSION, LANGUAGE_SEMANTICS_JOURNAL_VERSION, JOURNAL_VERSION])
 export const USER_BINDINGS_REUSE_POLICIES = new Set([LEGACY_USER_BINDINGS_REUSE_POLICY, LIVE_USER_BINDINGS_REUSE_POLICY])
 export const USER_BINDINGS_SHADOW_POLICIES = new Set([LEGACY_USER_BINDINGS_SHADOW_POLICY, LIVE_USER_BINDINGS_SHADOW_POLICY])
 const USER_BINDING_NAME_STATES = new Set(['provider', 'local', 'absent', 'unknown'])
+const isArray = Array.isArray
+const freeze = Object.freeze
+const ownKeys = Reflect.ownKeys
+const defineProperty = Object.defineProperty
+const uncurry = Function.prototype.bind.bind(Function.prototype.call)
+const setHas = uncurry(Set.prototype.has)
+const setAdd = uncurry(Set.prototype.add)
+const sort = uncurry(Array.prototype.sort)
+const enumerable = uncurry(Object.prototype.propertyIsEnumerable)
 
 /** Closed, value-free evidence shared by worker settlement, persistence and Client. */
 export function normalizeUserBindingNames(value) {
-  if (!Array.isArray(value)) throw new TypeError('invalid user binding name evidence')
+  if (!isArray(value)) throw new TypeError('invalid user binding name evidence')
   const names = new Set()
-  return Object.freeze(value.map(fact => {
+  const normalized = []
+  for (let index = 0; index < value.length; index++) {
+    const fact = value[index]
     if (fact === null || typeof fact !== 'object'
-      || !USER_BINDING_NAME_STATES.has(fact.state)
+      || !setHas(USER_BINDING_NAME_STATES, fact.state)
       || typeof fact.name !== 'string' || fact.name.length > 128
       || !/^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u.test(fact.name)
-      || names.has(fact.name)) throw new TypeError('invalid user binding name evidence')
+      || setHas(names, fact.name)) throw new TypeError('invalid user binding name evidence')
     const fields = fact.state === 'provider' ? ['name', 'state', 'entryId'] : ['name', 'state']
-    if (Reflect.ownKeys(fact).length !== fields.length
-      || !fields.every(key => Object.prototype.propertyIsEnumerable.call(fact, key))
+    let validFields = ownKeys(fact).length === fields.length
+    for (let field = 0; validFields && field < fields.length; field++) validFields = enumerable(fact, fields[field])
+    if (!validFields
       || (fact.state === 'provider' && (typeof fact.entryId !== 'string'
         || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(fact.entryId)))) {
       throw new TypeError('invalid user binding name evidence')
     }
-    names.add(fact.name)
-    return Object.freeze({ name: fact.name, state: fact.state,
-      ...(fact.state === 'provider' ? { entryId: fact.entryId } : {}) })
-  }).sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0))
+    setAdd(names, fact.name)
+    defineProperty(normalized, normalized.length, { configurable: true, enumerable: true, writable: true,
+      value: freeze({ name: fact.name, state: fact.state,
+        ...(fact.state === 'provider' ? { entryId: fact.entryId } : {}) }) })
+  }
+  sort(normalized, (left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0)
+  return freeze(normalized)
 }
 
 export function normalizeJournalUserBindingNames(journal) {

package/internal/session-journal.js

@@ -3,6 +3,8 @@ import { normalizeDiagnostic } from './diagnostic.js'
 import { assertOwnFields, isRecord } from './record-utils.js'
 import { sessionEvents } from './session-events.js'
 import { LEGACY_LANGUAGE_SEMANTICS, normalizeLanguageSemantics } from './language-semantics.js'
+import { LEGACY_USER_BINDING_TRANSFORM, historicalModuleTransformForLanguage,
+  moduleTransformForLanguage, normalizeModuleTransform } from './module-transform-contract.js'
 import {
   LEGACY_DEFAULT_EXPORT_BINDING,
   LEGACY_IMPORT_EXPRESSION_BOUNDARY,
@@ -16,6 +18,8 @@ import {
   REWRITES_KEY,
   RECOVERY_BOUNDARY_KEY,
   JOURNAL_VERSION,
+  LANGUAGE_SEMANTICS_JOURNAL_VERSION,
+  LANGUAGE_SEMANTICS_JOURNAL_FIELDS,
   IMPORT_BOUNDARY_JOURNAL_VERSION,
   PER_NAME_USER_BINDINGS_JOURNAL_VERSION,
   PER_NAME_JOURNAL_FIELDS,
@@ -251,12 +255,18 @@ function normalizeUserBindingsFingerprint(value) {
 
 function migrateJournal(value, resolveLegacyConfirm) {
   if (value.version === JOURNAL_VERSION) return value
+  if (value.version === LANGUAGE_SEMANTICS_JOURNAL_VERSION) {
+    assertOwnFields(value, LANGUAGE_SEMANTICS_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
+    const languageSemantics = normalizeLanguageSemantics(value.languageSemantics)
+    return { ...value, version: JOURNAL_VERSION, moduleTransform: historicalModuleTransformForLanguage(languageSemantics) }
+  }
   if (value.version === PER_NAME_USER_BINDINGS_JOURNAL_VERSION) {
     assertOwnFields(value, PER_NAME_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
-    return { ...value, version: JOURNAL_VERSION, languageSemantics: LEGACY_LANGUAGE_SEMANTICS }
+    return { ...value, version: JOURNAL_VERSION, languageSemantics: LEGACY_LANGUAGE_SEMANTICS,
+      moduleTransform: LEGACY_USER_BINDING_TRANSFORM }
   }
   const shadow = { userBindingsShadowPolicy: LEGACY_USER_BINDINGS_SHADOW_POLICY, userBindingNames: null,
-    languageSemantics: LEGACY_LANGUAGE_SEMANTICS }
+    languageSemantics: LEGACY_LANGUAGE_SEMANTICS, moduleTransform: LEGACY_USER_BINDING_TRANSFORM }
   if (value.version === IMPORT_BOUNDARY_JOURNAL_VERSION) {
     assertOwnFields(value, WHOLE_ENTRY_JOURNAL_FIELDS, 'dsh-ptc-plus journal')
     return { ...value, version: JOURNAL_VERSION, ...shadow }
@@ -325,6 +335,7 @@ export function normalizeJournal(value, options = {}) {
   const migrated = migrateJournal(value, options.resolveLegacyConfirm)
   assertOwnFields(migrated, JOURNAL_FIELDS, 'dsh-ptc-plus journal')
   const languageSemantics = normalizeLanguageSemantics(migrated.languageSemantics)
+  const moduleTransform = normalizeModuleTransform(migrated.moduleTransform, languageSemantics)
   const bindingPolicy = normalizeBindingPolicy(migrated.bindingPolicy)
   const rewritePolicy = normalizeRewritePolicy(migrated.rewritePolicy)
   const moduleSemantics = normalizeModuleSemantics(migrated.moduleSemantics)
@@ -355,6 +366,7 @@ export function normalizeJournal(value, options = {}) {
   return Object.freeze({
     version: JOURNAL_VERSION,
     languageSemantics,
+    moduleTransform,
     bindingPolicy,
     rewritePolicy,
     moduleSemantics,
@@ -583,7 +595,8 @@ export function liveToolCallSeq(session, callId, toolName) {
 }
 
 /** Start a mutable journal for one live cell. */
-export function createJournal(confirms = [], bindingPolicy, rewritePolicy, languageSemantics = LEGACY_LANGUAGE_SEMANTICS) {
+export function createJournal(confirms = [], bindingPolicy, rewritePolicy, languageSemantics = LEGACY_LANGUAGE_SEMANTICS,
+  moduleTransform = moduleTransformForLanguage(languageSemantics)) {
   if (typeof bindingPolicy === 'string') {
     if (!BINDING_MODES.has(bindingPolicy)) throw new TypeError('invalid dsh-ptc-plus journal binding mode')
     bindingPolicy = {
@@ -591,9 +604,11 @@ export function createJournal(confirms = [], bindingPolicy, rewritePolicy, langu
       functionClassRedeclarations: false,
     }
   }
+  languageSemantics = normalizeLanguageSemantics(languageSemantics)
   return {
     version: JOURNAL_VERSION,
-    languageSemantics: normalizeLanguageSemantics(languageSemantics),
+    languageSemantics,
+    moduleTransform: normalizeModuleTransform(moduleTransform, languageSemantics),
     bindingPolicy: normalizeBindingPolicy(bindingPolicy),
     rewritePolicy: normalizeRewritePolicy(rewritePolicy),
     moduleSemantics: normalizeModuleSemantics(LIVE_MODULE_SEMANTICS),

package/internal/session-runtime.js

@@ -713,6 +713,7 @@ export class SessionRuntime {
       policies.bindingPolicy,
       policies.rewritesEnabled,
       policies.languageSemantics,
+      policies.moduleTransform,
     )
     const workerReservation = kernel.reserveWorkerConfiguration(cellConfig)
     let result

package/internal/source-position-map.js

@@ -117,6 +117,25 @@ export function sourceOffsetAt(sourceMap, generatedOffset) {
   return segmentOffsetAt(segment, generatedOffset)
 }
 
+/** Whether a complete generated interval still contains its exact original text. */
+export function sourceRangeHasOriginalText(sourceMap, generatedSource, originalSource, generatedStart, generatedEnd) {
+  if (typeof generatedSource !== 'string' || typeof originalSource !== 'string'
+    || generatedEnd <= generatedStart || generatedStart < 0 || generatedEnd > generatedSource.length) return false
+  let cursor = generatedStart
+  for (let index = segmentIndexAt(sourceMap, generatedStart); index < sourceMap.length && cursor < generatedEnd; index += 1) {
+    const segment = sourceMap.at(index)
+    if (segment.generatedStart > cursor || segment.generatedEnd <= cursor) break
+    const end = Math.min(generatedEnd, segment.generatedEnd)
+    const length = end - cursor
+    const originalStart = segmentOffsetAt(segment, cursor)
+    if (segment.originalEnd <= segment.originalStart
+      || originalStart + length > originalSource.length
+      || generatedSource.slice(cursor, end) !== originalSource.slice(originalStart, originalStart + length)) return false
+    cursor = end
+  }
+  return cursor === generatedEnd
+}
+
 function segmentOffsetAt(segment, generatedOffset) {
   const generatedLength = segment.generatedEnd - segment.generatedStart
   const originalLength = segment.originalEnd - segment.originalStart

package/internal/stateful-root-compiler.js

@@ -191,8 +191,10 @@ function rewriteRootReferences(code, sourceMap, runtime, candidateNames, candida
     }
     handled.add(path.node.start)
   } })
+  const classificationSource = applySourceEdits(code, sourceMap, classificationEdits)
   return { ...applySourceEdits(code, sourceMap, edits),
-    classificationCode: applySourceEdits(code, sourceMap, classificationEdits).code,
+    classificationCode: classificationSource.code,
+    classificationSourceMap: classificationSource.sourceMap,
     implicitDeclarations: [...implicitDeclarations.values()],
     readNames: [...readNames] }
 }

package/internal/typescript-transform.js

@@ -1,7 +1,9 @@
 import loadAmaro from './compiler-amaro.cjs'
 
-export { LEGACY_USER_BINDING_TRANSFORM, USER_BINDING_TRANSFORM, PROTECTED_MODULE_TRANSFORM,
-  moduleTransformForLanguage, supportedUserBindingTransform } from './module-transform-contract.js'
+export { LEGACY_USER_BINDING_TRANSFORM, PREVIOUS_USER_BINDING_TRANSFORM, USER_BINDING_TRANSFORM,
+  PROTECTED_MODULE_TRANSFORM, isStatefulUserBindingTransform,
+  historicalModuleTransformForLanguage, moduleTransformForLanguage, moduleTransformMatchesLanguage,
+  normalizeModuleTransform, supportedUserBindingTransform } from './module-transform-contract.js'
 
 /** Keep binding-module lowering independent of the Host's experimental transform API. */
 export function transformTypeScriptModule(source) {