dsh-ptc-plus 0.4.1 → 0.4.2

package/internal/worker-repl-realm.js

@@ -0,0 +1,134 @@
+import { createContext, runInContext, runInThisContext } from 'node:vm'
+import { types } from 'node:util'
+import { protectNextAsyncLocalStorageRun } from './async-local-storage-intrinsics.js'
+
+export const WORKER_REPL_OPTIONS = Object.freeze({ useGlobal: true })
+const NativeMap = Map
+const ownKeys = Reflect.ownKeys
+const deleteProperty = Reflect.deleteProperty
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+const defineProperty = Object.defineProperty
+const createObject = Object.create
+const hasOwn = Object.hasOwn
+const sameValue = Object.is
+const isMap = types.isMap
+const mapSet = Function.prototype.call.bind(Map.prototype.set)
+const mapHas = Function.prototype.call.bind(Map.prototype.has)
+const mapForEach = Function.prototype.call.bind(Map.prototype.forEach)
+const DESCRIPTOR_FIELDS = ['configurable', 'enumerable', 'writable', 'value', 'get', 'set']
+
+/** Snapshot the native worker surface before Node installs REPL conveniences. */
+export function captureWorkerReplGlobals(globalObject = globalThis) {
+  const baseline = new NativeMap()
+  const keys = ownKeys(globalObject)
+  for (let index = 0; index < keys.length; index += 1) {
+    mapSet(baseline, keys[index], getOwnPropertyDescriptor(globalObject, keys[index]))
+  }
+  return baseline
+}
+
+function descriptorsEqual(left, right) {
+  const field = (descriptor, name) => descriptor !== undefined && hasOwn(descriptor, name)
+    ? descriptor[name] : undefined
+  return left !== undefined && right !== undefined
+    && field(left, 'configurable') === field(right, 'configurable')
+    && field(left, 'enumerable') === field(right, 'enumerable')
+    && field(left, 'writable') === field(right, 'writable')
+    && sameValue(field(left, 'value'), field(right, 'value'))
+    && field(left, 'get') === field(right, 'get')
+    && field(left, 'set') === field(right, 'set')
+}
+
+function detachedDescriptor(descriptor) {
+  const detached = createObject(null)
+  for (let index = 0; index < DESCRIPTOR_FIELDS.length; index += 1) {
+    const name = DESCRIPTOR_FIELDS[index]
+    if (hasOwn(descriptor, name)) detached[name] = descriptor[name]
+  }
+  return detached
+}
+
+/** Remove Node's REPL-only module shortcuts and restore changed native globals. */
+export function restoreWorkerReplGlobals(baseline, globalObject = globalThis) {
+  if (!isMap(baseline)) throw new TypeError('worker REPL global baseline must be a Map')
+  const keys = ownKeys(globalObject)
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index]
+    if (typeof key === 'string' && !mapHas(baseline, key) && !deleteProperty(globalObject, key)) {
+      throw new Error(`worker REPL added a non-configurable global ${String(key)}`)
+    }
+  }
+  mapForEach(baseline, (descriptor, key) => {
+    if (!descriptorsEqual(getOwnPropertyDescriptor(globalObject, key), descriptor)) {
+      defineProperty(globalObject, key, detachedDescriptor(descriptor))
+    }
+  })
+  return globalObject
+}
+
+/** A dedicated worker is the native realm shared by its REPL and Node modules. */
+export function workerReplContext(server) {
+  if (server.context !== globalThis) {
+    throw new Error('worker REPL did not use its native global realm')
+  }
+  return server.context
+}
+
+let replAsyncContextProtected = false
+
+/** Newer Node REPLs own an AsyncLocalStorage instance whose public prototype
+ * remains user-mutable. Give only that platform instance its native operations
+ * before the first user evaluation. */
+export function protectWorkerReplAsyncContext(server) {
+  if (replAsyncContextProtected) return
+  let callbackError
+  const scope = protectNextAsyncLocalStorageRun(() => {
+    server.eval('void 0\n', server.context, 'ptc-plus-repl-bootstrap', error => { callbackError = error })
+  })
+  if (callbackError !== null && callbackError !== undefined) throw callbackError
+  replAsyncContextProtected = true
+  return scope !== undefined
+}
+
+export function runInWorkerReplRealm(source, options) {
+  return runInThisContext(source, options)
+}
+
+/** Control promises stay outside the user-mutable worker realm. */
+export function createWorkerControlPromise() {
+  return runInContext('Promise', createContext())
+}
+
+/** PTC owns settlement; the REPL's legacy domain would run Node bookkeeping
+ * through user-mutable prototypes in the shared worker realm. */
+export function disableWorkerReplDomain(domain) {
+  domain.enter = () => domain
+  domain.exit = () => domain
+  return domain
+}
+
+/** Newer REPLs format errors before the eval callback unless an owned
+ * evaluation consumes the original thrown value through handleError. */
+export function createWorkerReplErrorHandler(evaluationScope, settle) {
+  return error => {
+    const finish = evaluationScope.getStore()
+    if (finish === undefined) return 'unhandled'
+    settle(finish, error)
+    return 'ignore'
+  }
+}
+
+/** Older REPLs can bypass handleError. Keep their process-level fallback
+ * directly testable without requiring a version-specific uncaught event. */
+export function createWorkerUncaughtExceptionHandler(evaluationScope, listenerOwner = process) {
+  const handleUncaughtException = error => {
+    const finish = evaluationScope.getStore()
+    if (finish !== undefined) {
+      finish(true, error)
+      return
+    }
+    listenerOwner.removeListener('uncaughtException', handleUncaughtException)
+    throw error
+  }
+  return handleUncaughtException
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ptc-plus",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
   "main": "./index.js",
@@ -96,6 +96,7 @@
     "review:gate": "node scripts/review-findings.mjs gate",
     "session:migrate": "node scripts/migrate-session-log.mjs",
     "coverage": "node scripts/coverage.mjs",
+    "coverage:focus": "node scripts/coverage.mjs --focus",
     "verify": "npm run review:validate && npm run build:check && node --check index.js && node --check internal/kernel-worker.js && node --check scripts/migrate-session-log.mjs && node --check scripts/expensive-headless-acceptance.mjs && node --check scripts/ab-headless-trajectories.mjs && npm run test:client && npm run coverage",
     "check": "node scripts/review-findings.mjs check",
     "test:expensive": "node scripts/expensive-headless-acceptance.mjs",

package/src/client-activity.js

@@ -3,6 +3,7 @@ import {
   STATUSES as JOURNAL_STATUSES,
   BINDING_MODES,
   JOURNAL_FIELDS,
+  LANGUAGE_SEMANTICS_JOURNAL_FIELDS,
   PER_NAME_JOURNAL_FIELDS,
   LANGUAGE_SEMANTICS_JOURNAL_VERSION,
   WHOLE_ENTRY_JOURNAL_FIELDS,
@@ -33,6 +34,7 @@ import {
   USER_BINDINGS_REUSE_POLICIES,
 } from '../internal/session-journal-schema.js'
 import { normalizeLanguageSemantics } from '../internal/language-semantics.js'
+import { normalizeModuleTransform } from '../internal/module-transform-contract.js'
 import {
   VALUE_CODEC,
   DEFAULT_VALUE_LIMITS,
@@ -292,7 +294,8 @@ function isReadableJournalUnchecked(value) {
       : value.version === 4 ? RELATIONLESS_JOURNAL_FIELDS
         : value.version === 5 ? FINGERPRINT_REUSE_JOURNAL_FIELDS
           : value.version < PER_NAME_USER_BINDINGS_JOURNAL_VERSION ? WHOLE_ENTRY_JOURNAL_FIELDS
-            : value.version < LANGUAGE_SEMANTICS_JOURNAL_VERSION ? PER_NAME_JOURNAL_FIELDS : JOURNAL_FIELDS
+          : value.version < LANGUAGE_SEMANTICS_JOURNAL_VERSION ? PER_NAME_JOURNAL_FIELDS
+            : value.version === LANGUAGE_SEMANTICS_JOURNAL_VERSION ? LANGUAGE_SEMANTICS_JOURNAL_FIELDS : JOURNAL_FIELDS
   const required = predecessor
     ? ['version', 'bindingMode', 'status', 'calls', 'operations', 'diagnostics']
     : ['version', 'bindingPolicy', 'rewritePolicy', 'moduleSemantics', 'status', 'calls', 'operations', 'diagnostics']
@@ -307,6 +310,10 @@ function isReadableJournalUnchecked(value) {
     required.push('languageSemantics')
     normalizeLanguageSemantics(value.languageSemantics)
   }
+  if (value.version > LANGUAGE_SEMANTICS_JOURNAL_VERSION) {
+    required.push('moduleTransform')
+    normalizeModuleTransform(value.moduleTransform, value.languageSemantics)
+  }
   if (!hasClosedFields(value, fields, required)
     || (predecessor && !BINDING_MODES.has(value.bindingMode))
     || (value.version >= 4 && !isValidBindingPolicy(value.bindingPolicy))