dsh-aris-panel 0.2.7 → 0.2.8

package/dsh/client.js

@@ -1009,7 +1009,7 @@ function ArisWorkbenchView(props) {
       setError(String(cause))
       setData(undefined)
     }).finally(function () { if (!silent) setBusy(false) })
-  }, [connection, sessionId])
+  }, [sessionId])
 
   React.useEffect(function () { load() }, [load])
 

package/dsh/http-rpc.mjs

@@ -19,11 +19,11 @@
  *
  *   - `connection.fetch` — exact-path Fetch registry under `/api`
  *     (documented as `HostConnectionFetch.register(ConnectionFetchRoute)`).
- *     Registration touches no service beyond Connection, so it mounts whatever
- *     the Connection context injects. Serving is dsh's own `/api` prefix route,
- *     which applies the Host/Origin trust fence and the browser-session cookie
- *     before dispatching to any exact fetch route — the same authority the RPC
- *     channel used to carry.
+ *     Registration resolves nothing beyond the Connection service itself, so it
+ *     mounts under whatever Connection context the host provides. Serving is
+ *     dsh's own `/api` prefix route, which applies the Host/Origin trust fence
+ *     and the browser-session cookie before dispatching to any exact fetch
+ *     route — the same authority the RPC channel used to carry.
  *
  * ARIS therefore mounts one JSON endpoint per view on the Fetch registry. The
  * wire contract is deliberately tiny and mirrored in `dsh/client.js`:
@@ -121,8 +121,9 @@ export function httpRpcRoute(path, handler) {
  *
  * The caller supplies the effect and the injected services, because the two
  * ARIS views need different ones (`sessions` for both, `agents` and
- * `workspaceRegistry` for the workbench only). Registering touches no
- * `webServer` lookup, so it works on every shipped dsh build.
+ * `workspaceRegistry` for the workbench only). Registration resolves no
+ * `webServer`, which is what keeps the mount independent of the Connection
+ * context's inject list.
  *
  * @param ctx - the ARIS plugin context, which must have `connection` injected.
  * @param path - exact `/api/<segment>` route path the browser POSTs to.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-aris-panel",
-  "version": "0.2.7",
+  "version": "0.2.8",
   "description": "ARIS research-workflow skills + interactive workbench panel for DeepSeek Harness (user fork of dsh-aris: 83 skills, bundled upstream dsh-aris 0.1.1 payload, ppt-master PPTX backend for the talk pipeline, cross-model Codex review, idea/workflow launcher, research status board).",
   "license": "MIT",
   "type": "module",
@@ -8,7 +8,7 @@
     "node": "^22.19.0 || >=24.0.0"
   },
   "scripts": {
-    "test": "node test/transport-smoke.mjs"
+    "test": "node test/transport-smoke.mjs && node test/client-render-smoke.mjs"
   },
   "keywords": [
     "dsh-plugin",

package/test/client-render-smoke.mjs

@@ -0,0 +1,131 @@
+/**
+ * ARIS browser-half render smoke test.
+ *
+ *   node test/client-render-smoke.mjs
+ *
+ * Why this exists: `test/transport-smoke.mjs` proves the host half mounts, but
+ * dsh/client.js is only ever executed by a browser, so a client-side error
+ * (an undefined identifier left behind by a refactor, say) reaches the user as
+ * "the panel does not open" with no failing test. This file executes the real
+ * bundle in Node against a minimal React/element renderer and walks every
+ * returned component, so ReferenceErrors and typos in component bodies or hook
+ * dependency arrays fail here instead.
+ *
+ * It is deliberately a stub renderer, not React: components are called and
+ * their element trees walked, hooks run eagerly, and network calls are answered
+ * with empty payloads. That catches crashes, not behaviour.
+ */
+
+import { pathToFileURL } from 'node:url'
+
+let failures = 0
+function check(label, condition, detail) {
+  if (condition) {
+    console.log(`  PASS  ${label}`)
+    return
+  }
+  failures += 1
+  console.log(`  FAIL  ${label}${detail === undefined ? '' : ` — ${detail}`}`)
+}
+
+/** Collect anything a hook or effect throws instead of letting it escape. */
+const crashes = []
+process.on('unhandledRejection', (reason) => { crashes.push(reason) })
+
+console.log('\n1. the bundle loads the way dsh client-modules loads it')
+let registration
+let documentState
+{
+  const styleNodes = []
+  documentState = { styleNodes }
+  globalThis.window = {
+    __ModuleLoader__: {
+      load(module) { registration = module },
+    },
+  }
+  globalThis.document = {
+    createElement() {
+      const node = { textContent: '', removed: false, remove() { node.removed = true } }
+      styleNodes.push(node)
+      return node
+    },
+    head: { append() {} },
+  }
+  // The views answer every call with an empty successful payload.
+  globalThis.fetch = async () => ({ status: 200, json: async () => ({ ok: true, value: {} }) })
+
+  await import(new URL('../dsh/client.js', import.meta.url).href)
+  check('the bundle registers one module', registration !== undefined && registration.id === 'dsh-aris-panel',
+    registration === undefined ? 'window.__ModuleLoader__.load was never called' : String(registration.id))
+}
+
+console.log('\n2. every component renders without crashing')
+let rendered
+{
+  /** Minimal React: enough for createElement + the hooks this bundle uses. */
+  const React = {
+    createElement(type, props, ...children) {
+      return { type, props: { ...(props ?? {}), children: children.flat() } }
+    },
+    useState(initial) { return [typeof initial === 'function' ? initial() : initial, () => {}] },
+    useEffect(run) { run() },
+    useCallback(fn) { return fn },
+    useRef(value) { return { current: value } },
+  }
+  const requireStub = (name) => {
+    if (name === 'react') return React
+    throw new Error(`client bundle required an unexpected module: ${name}`)
+  }
+
+  const plugin = registration.factory(requireStub)
+  check('the factory returns a plugin with an inject list', Array.isArray(plugin.inject), JSON.stringify(plugin.inject))
+  check('the plugin declares the slot service', plugin.inject.includes('slots'))
+
+  let render
+  const ctx = {
+    connection: {},
+    effect(run) { return run() },
+    slots: {
+      inject(name, registerCall) {
+        check('the plugin injects the conversation view slot', name === 'conversation.view', name)
+        registerCall()
+      },
+      register(spec, renderCall) {
+        check('the ARIS slot registers itself', spec.id === 'aris' && spec.name === 'conversation.view', JSON.stringify(spec))
+        render = renderCall
+      },
+    },
+  }
+  plugin.apply(ctx)
+  check('the slot exposes a render function', typeof render === 'function')
+
+  /** Call function components and walk host elements, like React would. */
+  let elements = 0
+  const walk = (node, depth = 0) => {
+    if (node === null || node === undefined || typeof node === 'boolean' || typeof node === 'string' || typeof node === 'number') return
+    if (Array.isArray(node)) { for (const child of node) walk(child, depth); return }
+    if (depth > 40) throw new Error('render tree did not settle')
+    elements += 1
+    if (typeof node.type === 'function') { walk(node.type(node.props ?? {}), depth + 1); return }
+    walk(node.props?.children, depth + 1)
+  }
+
+  try {
+    rendered = render({ sessionId: 'render-smoke', openView: undefined })
+    walk(rendered)
+    check('the ARIS tab renders a tree', elements > 5, `${elements} elements`)
+  } catch (error) {
+    check('the ARIS tab renders a tree', false, `${error.name}: ${error.message}`)
+  }
+}
+
+console.log('\n3. the stylesheet effect is wired')
+check('one style node was created', documentState.styleNodes.length === 1, String(documentState.styleNodes.length))
+
+const asyncCrashes = crashes.filter((reason) => reason !== undefined)
+check('no asynchronous crash escaped the views', asyncCrashes.length === 0, asyncCrashes.map(String).join('; '))
+check('the module left no uncaught error', rendered !== undefined)
+
+console.log(failures === 0 ? '\nOK — the browser half renders' : `\n${failures} check(s) failed`)
+await new Promise((resolve) => setTimeout(resolve, 20))
+process.exit(failures === 0 && crashes.length === 0 ? 0 : 1)