dsh-ptc-plus 0.4.1 → 0.4.3

package/internal/runtime-config.js

@@ -43,8 +43,36 @@ function assertField(field, value) {
  * @param config - raw config object.
  * @returns a resolved config object.
  */
+/**
+ * A volatile schema field validates to a live `{ get }` handle. A field that
+ * has no schema default arrives as a handle with an undefined live value and
+ * keeps the runtime default.
+ */
+function liveConfigValue(value, fallback) {
+  if (value !== null && typeof value === 'object'
+    && typeof value.get === 'function' && Object.keys(value).length === 1) {
+    const live = value.get()
+    return live === undefined ? fallback : live
+  }
+  return value
+}
+
 export function resolveConfig(config = {}) {
+  const provided = new Set()
+  for (const field of CONFIG_FIELDS) {
+    if (!Object.hasOwn(config, field.key)) continue
+    const value = config[field.key]
+    if (value !== null && typeof value === 'object'
+      && typeof value.get === 'function' && Object.keys(value).length === 1) {
+      if (value.get() !== undefined) provided.add(field.key)
+    } else {
+      provided.add(field.key)
+    }
+  }
   const resolved = { ...CONFIG_DEFAULTS, ...config }
+  for (const field of CONFIG_FIELDS) {
+    resolved[field.key] = liveConfigValue(resolved[field.key], CONFIG_DEFAULTS[field.key])
+  }
   for (const field of CONFIG_FIELDS) assertField(field, resolved[field.key])
   // Migrate complete old policies; mixed choices retain their explicit
   // compatibility state until the user selects the unified language.
@@ -52,8 +80,8 @@ export function resolveConfig(config = {}) {
     'looseTopLevelRedeclarations', 'looseTopLevelFunctionClassRedeclarations',
     'autoRewriteImports', 'autoStripExports', 'autoSplitRedeclarations',
   ]
-  if (!Object.hasOwn(config, 'bindingUpdates')
-    && legacyKeys.some(key => Object.hasOwn(config, key))) {
+  if (!provided.has('bindingUpdates')
+    && legacyKeys.some(key => provided.has(key))) {
     if (legacyKeys.every(key => resolved[key] === true)) {
       resolved.bindingUpdates = 'stateful'
     } else if (legacyKeys.slice(0, 2).every(key => resolved[key] === false)
@@ -65,6 +93,38 @@ export function resolveConfig(config = {}) {
   return resolved
 }
 
+/** Whether a validated config carries live volatile field handles. */
+export function hasVolatileFields(config) {
+  if (config === null || typeof config !== 'object') return false
+  return Object.values(config).some(value => value !== null && typeof value === 'object'
+    && typeof value.get === 'function' && Object.keys(value).length === 1)
+}
+
+/**
+ * Follow the host's volatile-only commit into the running fiber.
+ *
+ * The loader updates the retained handles in place and emits
+ * `loader/volatile-update` on the owning fiber; listeners on a child scope are
+ * filtered out, so the listener belongs to the plugin's own context and is
+ * released with the runtime scope it serves.
+ *
+ * @param host - the plugin's own context, owning the loader event listener.
+ * @param scope - the runtime scope whose disposal removes the listener.
+ * @param config - the validated config carrying the volatile handles.
+ * @param listener - receives the newly resolved plain configuration.
+ * @returns whether a volatile listener was installed.
+ */
+export function watchVolatileConfig(host, scope, config, listener) {
+  if (!hasVolatileFields(config) || typeof host?.on !== 'function') return false
+  const update = () => listener(resolveConfig(config))
+  if (typeof scope?.effect === 'function') {
+    scope.effect(() => host.on('loader/volatile-update', update), 'ptc-plus volatile settings lifecycle')
+  } else {
+    host.on('loader/volatile-update', update)
+  }
+  return true
+}
+
 /**
  * Validate one wall-clock ceiling against the platform timer limit.
  * @param value - the configured maximum wall time in milliseconds.

package/internal/runtime-intrinsics.js

@@ -0,0 +1,104 @@
+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,
+    set: Reflect.set,
+  },
+  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,
+  bigintToString: uncurry(BigInt.prototype.toString),
+  jsonStringify: JSON.stringify,
+  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/runtime-messages.js

@@ -1,5 +1,7 @@
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 
+import { isPtcMessageSource, PTC_MESSAGE_SOURCE_KIND } from './message-sources.js'
+
 export const PTC_DELIVERY_CONTEXT = 'tools:ptc-plus-message-delivery'
 export const PTC_BINDING_CATALOG = 'tools:ptc-plus-user-binding-defaults'
 export const PTC_STATE_NAMES = Object.freeze([
@@ -54,7 +56,7 @@ function stateText(sections, prefix = STATE_PREFIX) {
 /** Recognize only bounded, formed PTC records, never authoring tasks or Skills. */
 export function readRuntimeMessage(message) {
   const source = message?.source
-  if (source?.kind !== 'plugin' || source.plugin !== 'ptc-plus'
+  if (!isPtcMessageSource(source)
     || !Array.isArray(message.content) || message.content.length !== 1
     || message.content[0]?.type !== 'text') return undefined
   const text = message.content[0].text
@@ -87,7 +89,7 @@ export function runtimeBindingCatalogMessage(context) {
     throw new Error('invalid PTC binding catalog')
   }
   return createUserMessage({
-    source: { kind: 'plugin', plugin: 'ptc-plus', form: 'catalog' },
+    source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'catalog' },
     content: [{ type: 'text', text: `${CATALOG_PREFIX}\n\n${context?.text ?? EMPTY_CATALOG}` }],
   })
 }
@@ -96,14 +98,14 @@ export function runtimeStateMessage(value) {
   const sections = stateSections(value)
   if (sections === undefined) throw new Error('invalid PTC runtime state sections')
   return createUserMessage({
-    source: { kind: 'plugin', plugin: 'ptc-plus', form: 'snapshot', sections },
+    source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'snapshot', sections },
     content: [{ type: 'text', text: stateText(sections) }],
   })
 }
 
 export function runtimeNoticeMessage(tip) {
   const message = createUserMessage({
-    source: { kind: 'plugin', plugin: 'ptc-plus', form: 'notice', summary: tip.name },
+    source: { kind: PTC_MESSAGE_SOURCE_KIND, form: 'notice', summary: tip.name },
     content: [{ type: 'text', text: tip.text }],
   })
   if (readRuntimeMessage(message) === undefined) throw new Error('invalid PTC recovery notice')

package/internal/session-cell-executor.js

@@ -1,3 +1,5 @@
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
 import {
   decodeValue,
   encodeValue,
@@ -414,7 +416,9 @@ 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 moduleDirectory = kernel.cwd ?? process.cwd()
+    const moduleFilename = resolve(moduleDirectory, 'repl')
     const prepareCell = program => prepareProgram(program, {
       knownBindings: catalog.knownBindings,
       bindingPolicy,
@@ -430,6 +434,11 @@ export class SessionCellExecutor {
       dynamicOrigins: catalog.dynamicOrigins,
       establishedRoots: catalog.establishedRoots,
       moduleSemantics,
+      importMeta: {
+        url: pathToFileURL(moduleFilename).href,
+        filename: moduleFilename,
+        dirname: moduleDirectory,
+      },
     })
     let prepared
     try {
@@ -576,6 +585,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])),
@@ -711,9 +721,10 @@ export class SessionCellExecutor {
       volatile: this.handleVolatile,
       call: this.handleCall,
       'output-limit': this.handleOutputLimit,
+      'worker-output-error': this.handleWorkerOutputError,
       done: this.handleDone,
     }[message.type]
-    handler?.call(this, message)
+    return handler?.call(this, message)
   }
 
   handleVolatile(message) {
@@ -741,6 +752,19 @@ export class SessionCellExecutor {
     }, true)
   }
 
+  handleWorkerOutputError(message) {
+    const active = this.kernel.active
+    if (active?.id !== message.id) return false
+    const detail = typeof message.message === 'string'
+      ? message.message
+      : 'the kernel returned an invalid output-attribution event'
+    active.resolve({
+      logs: [],
+      error: { kind: 'worker-exit', message: `worker output attribution failed: ${detail}` },
+    }, true)
+    return true
+  }
+
   handleDone(message) {
     const kernel = this.kernel
     if (kernel.active?.id !== message.id) return