@goodandready/dsh-voice 0.8.36 → 0.8.37

package/lib/client.js

@@ -2166,7 +2166,10 @@ window.__ModuleLoader__.load({
       // writes are dropped. The server does not share that restriction, and
       // dsh-lanmode rebuilds the same mechanics on the same calls. Prefer its
       // service when installed, otherwise the kernel one (fine on loopback).
-      const scope = ((ctx.get && ctx.get('lanSettings')) || ctx.configForms).get(NS)
+      const settingsService = (ctx.get && ctx.get('lanSettings')) || ctx.configForms || ctx.settingsScope
+      const scope = settingsService && typeof settingsService.get === 'function'
+        ? settingsService.get(NS)
+        : (settingsService && typeof settingsService.bind === 'function' ? settingsService.bind({ namespace: NS }) : null)
       const [snap, setSnap] = React.useState(null)
       const [draft, setDraft] = React.useState(null)
       const [saved, setSaved] = React.useState(false)
@@ -2190,11 +2193,11 @@ window.__ModuleLoader__.load({
 
       React.useEffect(() => {
         let alive = true
-        const render = () => { if (alive) setSnap(scope.getSnapshot()) }
+        const render = () => { if (alive && scope && typeof scope.getSnapshot === 'function') setSnap(scope.getSnapshot()) }
         render()
-        const off = scope.subscribe(render)
+        const off = (scope && typeof scope.subscribe === 'function') ? scope.subscribe(render) : () => {}
         return () => { alive = false; off() }
-      }, [])
+      }, [scope])
 
       const [devices, setDevices] = React.useState([])
       React.useEffect(() => {
@@ -2214,7 +2217,13 @@ window.__ModuleLoader__.load({
         const timer = setInterval(() => {
           if (tries >= 15) { clearInterval(timer); return }
           tries += 1
-          try { ctx.configForms.describe().load() } catch (e) { /* service not up yet */ }
+          try {
+            if (ctx.configForms && typeof ctx.configForms.describe === 'function') {
+              ctx.configForms.describe().load()
+            } else if (ctx.settingsScope && typeof ctx.settingsScope.describe === 'function') {
+              ctx.settingsScope.describe().load()
+            }
+          } catch (e) { /* service not up yet */ }
         }, 1000)
         return () => clearInterval(timer)
       }, [ready])
@@ -3125,7 +3134,7 @@ window.__ModuleLoader__.load({
         },
         PluginCard,
       ))
-      // Row seat and the legacy card stay as fallbacks.
+      // Row seat (plugins.row.config): rendered in the plugin row in Plugins table.
       ctx.slots.inject('plugins.row.config', () => ctx.slots.register(
         {
           name: 'plugins.row.config',
@@ -3135,6 +3144,7 @@ window.__ModuleLoader__.load({
         },
         PluginCard,
       ))
+      // Legacy seat fallback
       ctx.slots.inject('settings.plugin.item', () => ctx.slots.register(
         {
           name: 'settings.plugin.item',

package/lib/config-compat.js

@@ -0,0 +1,43 @@
+// Decode modern volatile Config references while retaining stable identities for
+// the request hot path. Legacy cores pass ordinary resolved configuration.
+// If ctx is provided, invalidation listeners cache the unwrapped tree so the hot
+// path never recursively walks volatile nodes on unchanged configuration.
+export function createConfigReader(config, ctx) {
+  let previous
+  let dirty = true
+  if (ctx && typeof ctx.on === 'function') {
+    const markDirty = () => { dirty = true }
+    if (typeof ctx.effect === 'function') {
+      ctx.effect(() => ctx.on('settings/document-updated', markDirty))
+      ctx.effect(() => ctx.on('loader/volatile-update', markDirty))
+      ctx.effect(() => ctx.on('config', markDirty))
+    } else {
+      ctx.on('settings/document-updated', markDirty)
+      ctx.on('loader/volatile-update', markDirty)
+      ctx.on('config', markDirty)
+    }
+  }
+
+  const read = (value, held) => {
+    if (value && typeof value.get === 'function') value = value.get()
+    if (!value || typeof value !== 'object') return value
+    const keys = Object.keys(value)
+    const next = Array.isArray(value) ? [] : {}
+    let same = held && typeof held === 'object' && Array.isArray(value) === Array.isArray(held)
+      && keys.length === Object.keys(held).length
+    for (const key of keys) {
+      Object.defineProperty(next, key, { value: read(value[key], held?.[key]), writable: true, enumerable: true, configurable: true })
+      if (!held || !Object.hasOwn(held, key) || !Object.is(next[key], held[key])) same = false
+    }
+    return same ? held : next
+  }
+
+  return () => {
+    if (ctx && !dirty && previous !== undefined) {
+      return previous
+    }
+    previous = read(config, previous)
+    dirty = false
+    return previous
+  }
+}

package/lib/index.js

@@ -28,6 +28,7 @@ import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import { buildProviderOrder, sessionCommand } from './transcribe-core.js'
 import { registerPluginUpdater } from './updater.js'
 import { registerSensevoiceInstaller } from './sensevoice-installer.js'
+import { createConfigReader } from './config-compat.js'
 
 function isAutoLang(lang) {
   return !lang || lang === 'auto' || String(lang).includes(',')
@@ -65,7 +66,21 @@ const CustomProvider = z.object({
       + 'Empty means the built-in one.'),
 })
 
-export const Config = z.object({
+function makeVolatile(schema) {
+  if (!schema || typeof schema.volatile !== 'function') return schema
+  if (schema.type === 'object' && schema.dict) {
+    const dict = {}
+    for (const [k, v] of Object.entries(schema.dict)) {
+      dict[k] = makeVolatile(v)
+    }
+    const res = z.object(dict)
+    if (schema.meta) Object.assign(res.meta, schema.meta)
+    return res
+  }
+  return schema.volatile()
+}
+
+const BaseConfig = z.object({
   dictation: z.object({
     chain: z.array(ChainEntry)
       .default([{ provider: 'deepgram', model: '' }, { provider: 'groq', model: '' }, { provider: 'local-whisper', model: '' }])
@@ -181,6 +196,10 @@ export const Config = z.object({
     .description('Target voice dictation and numeric choices to active DSH structured prompt modals.'),
 })
 
+export const Config = typeof z.number().volatile === 'function'
+  ? makeVolatile(BaseConfig)
+  : BaseConfig
+
 const MIME_BY_EXT = {
   '.wav': 'audio/wav', '.mp3': 'audio/mpeg', '.m4a': 'audio/mp4', '.mp4': 'audio/mp4',
   '.ogg': 'audio/ogg', '.oga': 'audio/ogg', '.flac': 'audio/flac', '.webm': 'audio/webm', '.aac': 'audio/aac',
@@ -190,18 +209,22 @@ const MIME_BY_EXT = {
 export function apply(ctx, baseConfig) {
   let child = null
 
-  // The settings card edits a namespace named after the plugin. Until the
-  // host registers it via settings.register the snapshot is empty and
-  // read-only. Reading through live() means edits apply to the next request
-  // instead of requiring a process restart.
+  // The settings card edits a namespace named after the plugin.
+  // Using createConfigReader decodes volatile nodes on modern DSH cores
+  // while caching unwrapped values across requests.
+  const readEntryConfig = createConfigReader(baseConfig, ctx)
   let scope = null
-  let getConfig = () => baseConfig
-  const live = () => Config(structuredClone(getConfig() ?? {})) ?? baseConfig
+  let getConfig = readEntryConfig
+  const live = () => BaseConfig(structuredClone(getConfig() ?? {})) ?? readEntryConfig()
 
   ctx.inject(['settings'], (sctx) => {
-    scope = sctx.settings.register(NS, Config, { base: baseConfig })
-    getConfig = () => scope.get() ?? baseConfig
-    sctx.effect(() => () => { getConfig = () => baseConfig; scope = null })
+    try {
+      scope = sctx.settings.register(NS, Config, { base: baseConfig })
+      if (scope && typeof scope.get === 'function') {
+        getConfig = () => scope.get() ?? readEntryConfig()
+      }
+    } catch { /* modern DSH handles settings via SettingsForms */ }
+    sctx.effect(() => () => { getConfig = readEntryConfig; scope = null })
   })
 
   async function resolveKey(ref) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.8.36",
+  "version": "0.8.37",
   "description": "Voice input for DeepSeek Harness: dictation chunked by pauses and voice messages, each with its own provider fallback chain (Deepgram, Groq, HuggingFace, local whisper.cpp, plus any OpenAI-compatible API of your own).",
   "license": "MIT",
   "type": "module",