dsh-ptc-plus 0.3.2 → 0.4.2

package/internal/worker-cwd-virtualization.js

@@ -1,5 +1,10 @@
 import { isAbsolute, parse, resolve, sep } from 'node:path'
 import { promisify } from 'node:util'
+import { runtimeIntrinsics as internal } from './runtime-intrinsics.js'
+
+const { Reflect: privateReflect, appendArray, bufferConcat, bufferIsBuffer, bufferToString,
+  copyArray, isArray, regexpTest } = internal
+const TRAILING_SEPARATOR = /[\\/]$/
 
 const FILE_SYSTEM_PATH_ARGUMENTS = Object.freeze({
   access: [0], accessSync: [0], appendFile: [0], appendFileSync: [0],
@@ -34,7 +39,7 @@ const CHILD_PROCESS_PROJECTED_PROPERTIES = Object.freeze({
 function wrapBuiltinCallable(original, projectArguments, projectedProperties = []) {
   const wrapped = {
     invoke(...args) {
-      return Reflect.apply(original, this, projectArguments(args))
+      return privateReflect.apply(original, this, projectArguments(args))
     },
   }.invoke
   const descriptors = Object.getOwnPropertyDescriptors(original)
@@ -59,80 +64,101 @@ function wrapBuiltin(owner, name, projectArguments, projectedProperties) {
   owner[name] = wrapBuiltinCallable(original, projectArguments, projectedProperties)
 }
 
+export function projectChildProcessArguments(name, args, sessionCwd) {
+  const sessionChildOptions = options => (
+    options === null || typeof options !== 'object' || options.cwd !== undefined
+      ? options
+      : { ...options, cwd: sessionCwd }
+  )
+  const withDefaultOptions = (index) => {
+    const next = copyArray(args)
+    next[index] = sessionChildOptions(next[index]) ?? { cwd: sessionCwd }
+    return next
+  }
+  const insertDefaultOptions = (index) => {
+    const next = copyArray(args, 0, index)
+    appendArray(next, { cwd: sessionCwd })
+    return copyArray(args, index, args.length, next)
+  }
+  if (name === 'exec' || name === 'execSync') {
+    const next = copyArray(args)
+    if (typeof next[1] === 'function') return insertDefaultOptions(1)
+    else next[1] = sessionChildOptions(next[1]) ?? { cwd: sessionCwd }
+    return next
+  }
+  if (name === 'execFile' || name === 'execFileSync') {
+    if (args.length === 1 || typeof args[1] === 'function') {
+      return insertDefaultOptions(1)
+    }
+    if (typeof args[2] === 'function') {
+      if (args[1] !== undefined && !isArray(args[1])) return withDefaultOptions(1)
+      return insertDefaultOptions(2)
+    }
+    if (args[1] !== undefined && !isArray(args[1])) return withDefaultOptions(1)
+    return withDefaultOptions(2)
+  }
+  return args.length === 1 || (args[1] !== undefined && !isArray(args[1]))
+    ? withDefaultOptions(1)
+    : withDefaultOptions(2)
+}
+
 /** Install one session's cwd projection into Node builtins loaded by the worker. */
-export function installWorkerCwdVirtualization(sessionCwd, originalRequire) {
-  if (sessionCwd === undefined) return
+export function installWorkerCwdVirtualization(sessionCwd, originalRequire, markVolatile) {
+  if (sessionCwd === undefined) {
+    const nativeCwd = process.cwd
+    process.cwd = () => {
+      markVolatile('process.cwd')
+      return privateReflect.apply(nativeCwd, process, [])
+    }
+    return
+  }
   const nativeResolve = resolve
-  const bufferPrefix = Buffer.from(sessionCwd + (/[\\/]$/.test(sessionCwd) ? '' : sep))
+  const bufferPrefix = Buffer.from(sessionCwd + (regexpTest(TRAILING_SEPARATOR, sessionCwd) ? '' : sep))
   const sessionPath = (value) => {
     if (typeof value === 'string') return isAbsolute(value) ? value : nativeResolve(sessionCwd, value)
-    if (Buffer.isBuffer(value)) {
-      const absolute = isAbsolute(String.fromCharCode(...value.subarray(0, 3)))
-      return absolute ? value : Buffer.concat([bufferPrefix, value])
+    if (bufferIsBuffer(value)) {
+      const absolute = isAbsolute(bufferToString(value, 'utf8', 0, 3))
+      return absolute ? value : bufferConcat([bufferPrefix, value])
     }
     return value
   }
   const sessionPathPrefix = (value) => {
     if (typeof value !== 'string' || isAbsolute(value) || parse(value).root !== '') return sessionPath(value)
-    return sessionCwd + (/[\\/]$/.test(sessionCwd) ? '' : sep) + value
+    return sessionCwd + (regexpTest(TRAILING_SEPARATOR, sessionCwd) ? '' : sep) + value
   }
   const projectPaths = (args, indices) => {
-    const next = [...args]
-    for (const index of indices) next[index] = sessionPath(next[index])
+    const next = copyArray(args)
+    for (let offset = 0; offset < indices.length; offset += 1) {
+      const index = indices[offset]
+      next[index] = sessionPath(next[index])
+    }
     return next
   }
   const projectPrefix = (args) => {
-    const next = [...args]
+    const next = copyArray(args)
     next[0] = sessionPathPrefix(next[0])
     return next
   }
-  const sessionChildOptions = options => (
-    options === null || typeof options !== 'object' || options.cwd !== undefined
-      ? options
-      : { ...options, cwd: sessionCwd }
-  )
-  const withDefaultOptions = (args, index) => {
-    const next = [...args]
-    next[index] = sessionChildOptions(next[index]) ?? { cwd: sessionCwd }
-    return next
-  }
-  const childProcessOptions = (name, args) => {
-    if (name === 'exec' || name === 'execSync') {
-      const next = [...args]
-      if (typeof next[1] === 'function') next.splice(1, 0, { cwd: sessionCwd })
-      else next[1] = sessionChildOptions(next[1]) ?? { cwd: sessionCwd }
-      return next
-    }
-    if (name === 'execFile' || name === 'execFileSync') {
-      if (args.length === 1 || typeof args[1] === 'function') {
-        const next = [...args]
-        next.splice(1, 0, { cwd: sessionCwd })
-        return next
-      }
-      if (typeof args[2] === 'function') {
-        if (args[1] !== undefined && !Array.isArray(args[1])) return withDefaultOptions(args, 1)
-        const next = [...args]
-        next.splice(2, 0, { cwd: sessionCwd })
-        return next
-      }
-      if (args[1] !== undefined && !Array.isArray(args[1])) return withDefaultOptions(args, 1)
-      return withDefaultOptions(args, 2)
-    }
-    return args.length === 1 || (args[1] !== undefined && !Array.isArray(args[1]))
-      ? withDefaultOptions(args, 1)
-      : withDefaultOptions(args, 2)
-  }
   const sessionGlobOptions = (args) => {
-    const next = [...args]
-    if (typeof next[1] === 'function') next.splice(1, 0, { cwd: sessionCwd })
-    else if (next[1] === undefined) next[1] = { cwd: sessionCwd }
+    if (typeof args[1] === 'function') {
+      const next = copyArray(args, 0, 1)
+      appendArray(next, { cwd: sessionCwd })
+      return copyArray(args, 1, args.length, next)
+    }
+    const next = copyArray(args)
+    if (next[1] === undefined) next[1] = { cwd: sessionCwd }
     else if (next[1] !== null && typeof next[1] === 'object' && next[1].cwd === undefined) {
       next[1] = { ...next[1], cwd: sessionCwd }
     }
     return next
   }
 
-  process.cwd = () => sessionCwd
+  Object.defineProperty(process, 'cwd', {
+    configurable: false,
+    enumerable: true,
+    writable: false,
+    value: () => sessionCwd,
+  })
   const fs = originalRequire('node:fs')
   const path = originalRequire('node:path')
   for (const [name, indices] of Object.entries(FILE_SYSTEM_PATH_ARGUMENTS)) {
@@ -147,9 +173,10 @@ export function installWorkerCwdVirtualization(sessionCwd, originalRequire) {
     wrapBuiltin(fs, name, sessionGlobOptions)
     wrapBuiltin(fs.promises, name, sessionGlobOptions)
   }
-  wrapBuiltin(path, 'resolve', args => [sessionCwd, ...args])
+  wrapBuiltin(path, 'resolve', args => copyArray(args, 0, args.length, [sessionCwd]))
   const childProcess = originalRequire('node:child_process')
   for (const name of ['exec', 'execFile', 'execFileSync', 'execSync', 'fork', 'spawn', 'spawnSync']) {
-    wrapBuiltin(childProcess, name, args => childProcessOptions(name, args), CHILD_PROCESS_PROJECTED_PROPERTIES[name])
+    wrapBuiltin(childProcess, name,
+      args => projectChildProcessArguments(name, args, sessionCwd), CHILD_PROCESS_PROJECTED_PROPERTIES[name])
   }
 }

package/internal/worker-environment.js

@@ -0,0 +1,65 @@
+const WINDOWS_ENVIRONMENT_NAMES = new Map([
+  ['appdata', 'APPDATA'],
+  ['comspec', 'ComSpec'],
+  ['home', 'HOME'],
+  ['homedrive', 'HOMEDRIVE'],
+  ['homepath', 'HOMEPATH'],
+  ['localappdata', 'LOCALAPPDATA'],
+  ['path', 'PATH'],
+  ['pathext', 'PATHEXT'],
+  ['programdata', 'ProgramData'],
+  ['programfiles', 'ProgramFiles'],
+  ['programfiles(x86)', 'ProgramFiles(x86)'],
+  ['systemdrive', 'SystemDrive'],
+  ['systemroot', 'SystemRoot'],
+  ['temp', 'TEMP'],
+  ['tmp', 'TMP'],
+  ['userprofile', 'USERPROFILE'],
+  ['windir', 'windir'],
+])
+export const HOST_ONLY_ENVIRONMENT_NAMES = new Set([
+  'node_test_context',
+  'node_v8_coverage',
+  'dsh_ptc_compiler_bytecode',
+])
+
+/** Detect whether the Host executable needs Electron's Node startup mode. */
+export function isElectronHost(versions = process.versions) {
+  return typeof versions?.electron === 'string'
+}
+
+/** Overlay only the helper process environment needed to boot an Electron executable as Node. */
+export function helperProcessEnvironment(source, platform = process.platform, electronHost = isElectronHost()) {
+  if (!electronHost) return source
+  const environment = { ...(source ?? process.env) }
+  if (platform === 'win32') {
+    for (const name of Object.keys(environment)) {
+      if (name !== 'ELECTRON_RUN_AS_NODE' && name.toLowerCase() === 'electron_run_as_node') {
+        delete environment[name]
+      }
+    }
+  }
+  environment.ELECTRON_RUN_AS_NODE = '1'
+  return environment
+}
+
+/** Project the host environment once without losing Windows case variants. */
+export function normalizeWorkerEnvironment(source, platform = process.platform) {
+  if (platform !== 'win32') {
+    return Object.fromEntries(Object.entries(source).filter(([name, value]) => (
+      value !== undefined && !HOST_ONLY_ENVIRONMENT_NAMES.has(name.toLowerCase())
+    )))
+  }
+  const normalized = new Map()
+  for (const [name, value] of Object.entries(source)) {
+    if (value === undefined) continue
+    const key = name.toLowerCase()
+    if (HOST_ONLY_ENVIRONMENT_NAMES.has(key)) continue
+    const canonicalName = WINDOWS_ENVIRONMENT_NAMES.get(key) ?? name
+    const current = normalized.get(key)
+    if (current === undefined || name === canonicalName) {
+      normalized.set(key, [canonicalName, value])
+    }
+  }
+  return Object.fromEntries(normalized.values())
+}

package/internal/worker-output-relay.js

@@ -0,0 +1,29 @@
+/** Forward one worker output stream while honoring destination backpressure. */
+export function relayWorkerOutput(source, destination) {
+  if (source === null || source === undefined) return Promise.resolve()
+  return new Promise((resolve, reject) => {
+    let ended = false
+    let pending = 0
+    let settled = false
+    let failure
+    const finish = error => {
+      if (error !== undefined) failure ??= error
+      if (settled || (!ended && failure === undefined) || pending > 0) return
+      settled = true
+      if (failure === undefined) resolve()
+      else reject(failure)
+    }
+    source.on('data', chunk => {
+      source.pause()
+      pending += 1
+      destination.write(chunk, error => {
+        pending -= 1
+        if (error !== null && error !== undefined) { finish(error); return }
+        if (failure === undefined) source.resume()
+        finish()
+      })
+    })
+    source.once('end', () => { ended = true; finish() })
+    source.once('error', error => { ended = true; finish(error) })
+  })
+}

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/internal/worker-shutdown.js

@@ -0,0 +1,14 @@
+/**
+ * Shutdown protocol shared by the plugin's worker entries.
+ *
+ * Each worker entry releases the machinery it owns when it receives the request
+ * and reports that release with the acknowledgement. The release, the real exit
+ * and the kill bound belong to the helper process boundary in
+ * isolated-worker.js; these two constants are the only part the worker entries
+ * themselves need.
+ */
+
+/** Request that asks one worker to release everything it owns and stop. */
+export const WORKER_SHUTDOWN_REQUEST = 'shutdown'
+/** Reply a worker posts after releasing its own machinery, before it exits. */
+export const WORKER_SHUTDOWN_ACKNOWLEDGEMENT = 'shutdown-released'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ptc-plus",
-  "version": "0.3.2",
+  "version": "0.4.2",
   "description": "A session-bound agent-native REPL for DeepSeek Harness PTC mode.",
   "type": "module",
   "main": "./index.js",
@@ -12,6 +12,16 @@
   "files": [
     "index.js",
     "client.js",
+    "compiler-core.cjs",
+    "compiler-core.cjs.map",
+    "compiler-platform.cjs",
+    "compiler-platform.cjs.map",
+    "compiler-typescript.cjs",
+    "compiler-typescript.cjs.map",
+    "compiler-amaro.cjs",
+    "compiler-amaro.cjs.map",
+    "compiler-assets.json",
+    "compiler-asset-*.txt",
     "src",
     "internal",
     "docs",
@@ -21,6 +31,8 @@
     "assets/ptc-plus-bindings-zh.png",
     "assets/ptc-plus-repair-zh.png",
     "assets/ptc-plus-repair-en.png",
+    "assets/ptc-plus-repl-workspace-en.png",
+    "assets/ptc-plus-repl-workspace-zh.png",
     "assets/ptc-plus-settings-en.png",
     "assets/ptc-plus-settings-zh.png",
     "cordis.patch.yml",
@@ -36,28 +48,56 @@
   },
   "dependencies": {
     "@babel/code-frame": "^7.29.7",
+    "@babel/core": "^7.29.7",
+    "@babel/generator": "^7.29.8",
+    "@babel/helper-create-class-features-plugin": "^7.29.7",
     "@babel/parser": "^7.29.0",
+    "@babel/plugin-proposal-decorators": "^7.29.7",
+    "@babel/plugin-transform-explicit-resource-management": "^7.29.7",
+    "@babel/plugin-transform-optional-chaining": "^7.29.7",
+    "@babel/plugin-transform-typescript": "^7.29.7",
     "@babel/traverse": "^7.29.0",
+    "@codemirror/lang-javascript": "^6.2.5",
+    "@codemirror/language": "^6.12.4",
+    "@codemirror/state": "^6.7.4",
+    "@codemirror/view": "^6.43.11",
     "@deepseek-ai/schemastery": "^3.18.1",
-    "acorn": "^8.15.0"
+    "@jridgewell/trace-mapping": "^0.3.31",
+    "@lezer/highlight": "^1.2.3",
+    "acorn": "^8.15.0",
+    "amaro": "1.1.11",
+    "codemirror": "^6.0.2",
+    "fflate": "^0.8.3",
+    "pathe": "^2.0.3",
+    "tslib": "^2.8.1",
+    "typescript": "^6.0.3"
   },
   "peerDependencies": {
+    "@deepseek-ai/dsh-atomic-write": "*",
+    "@deepseek-ai/dsh-home-paths": "*",
+    "@deepseek-ai/dsh-llm": "*",
     "@deepseek-ai/dsh-settings": "*",
     "@deepseek-ai/dsh-skill-filesystem": "*",
     "@deepseek-ai/dsh-tool-cordis": "*",
-    "@deepseek-ai/dsh-tools": "*"
+    "@deepseek-ai/dsh-tools": "*",
+    "@deepseek-ai/dsh-typert-protocol": "*"
   },
   "scripts": {
-    "build": "node scripts/client-bundle.mjs build",
-    "build:check": "node scripts/client-bundle.mjs check",
+    "build": "node scripts/client-bundle.mjs build && node scripts/compiler-bundle.mjs build",
+    "build:check": "node scripts/client-bundle.mjs check && node scripts/compiler-bundle.mjs check",
+    "test:client": "vitest run --config scripts/client-test.config.mjs",
+    "test:semantics": "node --test --test-concurrency=1 test/semantic-test262.test.js test/semantic-dialect.test.js test/semantic-boundaries.test.js",
+    "test:client:web": "node scripts/client-web-smoke.mjs",
+    "test:client:layout": "node scripts/client-binding-layout.mjs",
     "prepack": "npm run build:check",
     "hooks:install": "node scripts/review-findings.mjs install-hook",
     "review:new": "node scripts/review-findings.mjs create",
     "review:validate": "node scripts/review-findings.mjs validate",
     "review:gate": "node scripts/review-findings.mjs gate",
     "session:migrate": "node scripts/migrate-session-log.mjs",
-    "coverage": "node --test --experimental-test-module-mocks --experimental-test-coverage --test-concurrency=1 --test-coverage-include=\"index.js\" --test-coverage-include=\"internal/*.js\" --test-coverage-lines=100 --test-coverage-branches=95 --test-coverage-functions=100 \"test/*.test.js\"",
-    "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 coverage",
+    "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",
     "test:ab": "node scripts/ab-headless-trajectories.mjs"
@@ -89,21 +129,50 @@
         "react"
       ],
       "inject": [
+        "@deepseek-ai/dsh-api-gateway",
+        "@deepseek-ai/dsh-api-remotes",
         "@deepseek-ai/dsh-client-runtime",
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-settings",
         "@deepseek-ai/dsh-client-ui-settings-plugins",
+        "@deepseek-ai/dsh-client-ui-conversation",
         "@deepseek-ai/dsh-client-connection",
         "@deepseek-ai/dsh-client-ui-primitives"
       ]
     }
   },
   "devDependencies": {
+    "@deepseek-ai/dsh-agent-loop": "next",
+    "@deepseek-ai/dsh-api-gateway": "next",
+    "@deepseek-ai/dsh-api-remotes": "next",
+    "@deepseek-ai/dsh-atomic-write": "next",
+    "@deepseek-ai/dsh-client-locale": "next",
+    "@deepseek-ai/dsh-client-store": "next",
+    "@deepseek-ai/dsh-client-test-runtime": "next",
+    "@deepseek-ai/dsh-client-ui-conversation": "next",
+    "@deepseek-ai/dsh-client-ui-primitives": "next",
+    "@deepseek-ai/dsh-client-ui-renderer": "next",
+    "@deepseek-ai/dsh-client-ui-session": "next",
+    "@deepseek-ai/dsh-client-ui-slots": "next",
+    "@deepseek-ai/dsh-commands": "next",
+    "@deepseek-ai/dsh-home-paths": "next",
+    "@deepseek-ai/dsh-llm": "next",
+    "@deepseek-ai/dsh-session-persistence-jsonl": "next",
     "@deepseek-ai/dsh-settings": "next",
     "@deepseek-ai/dsh-skill-filesystem": "next",
     "@deepseek-ai/dsh-tool-cordis": "next",
     "@deepseek-ai/dsh-tools": "next",
+    "@deepseek-ai/dsh-typert-protocol": "next",
+    "@deepseek-ai/dsh-typert-registry": "next",
+    "@testing-library/react": "^16.3.3",
+    "c8": "^12.0.0",
+    "convert-source-map": "^2.0.0",
     "esbuild": "0.28.2",
+    "jsdom": "^29.1.1",
+    "playwright": "^1.63.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "vitest": "^5.0.0",
     "yaml": "^2.9.0"
   }
 }