@llui/agent 0.0.48 → 0.0.50

package/dist/client/agentAttention.d.ts

@@ -0,0 +1,129 @@
+import type { AgentEffect } from './effects.js';
+import type { LogEntry } from '../protocol.js';
+/**
+ * Visual attention layer. Companion to `agentLog` — same `Append { entry }`
+ * input shape, different output. While `agentLog` ring-buffers the full
+ * activity history, `agentAttention` tracks only the most recent
+ * dispatched entry's effective metadata so the host's view can flash
+ * highlight classes onto DOM regions whose state paths just changed.
+ *
+ * Why a separate slice: the activity log is a passive timeline (read-only,
+ * no time-bounded expiry, no per-region accessors). The attention layer
+ * is a transient projection — the "current dispatch's spotlight" — that
+ * has to clear itself after a configurable window, decay across renders,
+ * and drive per-path accessors (one per highlightable region in the
+ * host's layout). Mixing these into one slice would conflate "I want
+ * to read past actions" with "I want to point at the current one."
+ *
+ * Composition contract: the host appends the SAME `LogEntry` payload
+ * to both slices on every `log-append` from the ws-client (typically
+ * via a single `agent/log/Append` Msg routed by `sliceHandler`). The
+ * attention reducer ignores entries whose `kind` isn't `'dispatched'`
+ * — proposed, blocked, error, and read entries don't update the
+ * attention focus, since they don't represent a state mutation.
+ *
+ * Auto-clear: the reducer fires an `AgentAttentionFlashTimeout` effect
+ * keyed by `entryId`. After `flashDurationMs`, the effect handler
+ * dispatches a `Clear { entryId }` Msg back into the slice. The
+ * conditional clear (only-if-current) means a fast follow-up dispatch
+ * cleanly replaces the spotlight without the timer racing to wipe the
+ * new one. Hosts that don't wire `wrapAttentionMsg` in the factory
+ * still see the spotlight set; it just won't auto-clear (the next
+ * dispatch overwrites it instead).
+ */
+export type AgentAttentionState = {
+    /**
+     * The current dispatch's spotlight, or null when no dispatch has
+     * landed yet (or the auto-clear timer fired and `latestDispatch.entryId`
+     * matched).
+     */
+    latestDispatch: {
+        entryId: string;
+        /**
+         * Top-level state paths the dispatch touched, derived from the
+         * entry's JSON-Patch `stateDiff`. A whole-state replace (path
+         * `/`) collapses to the wildcard `'*'` so callers can match every
+         * region without enumerating their own state keys.
+         */
+        paths: string[];
+        variant?: string;
+        intent?: string;
+        at: number;
+    } | null;
+    /** Configurable: how long the spotlight persists before auto-clear. */
+    flashDurationMs: number;
+};
+export type AgentAttentionInitOpts = {
+    /** Default 600ms — long enough to read, short enough not to obscure. */
+    flashDurationMs?: number;
+};
+export type AgentAttentionMsg = {
+    /**
+     * Same shape as `agentLog`'s `Append` so the host can route a
+     * single incoming Msg to both slices via `sliceHandler` without
+     * a translation layer.
+     */
+    type: 'Append';
+    entry: LogEntry;
+} | {
+    /**
+     * Fired by the auto-clear timer effect. Guarded by `entryId` —
+     * the reducer only clears when `latestDispatch.entryId` matches,
+     * so a fast follow-up dispatch isn't wiped by the previous
+     * dispatch's pending timer.
+     */
+    type: 'Clear';
+    entryId: string;
+} | {
+    /**
+     * Adjust the flash duration at runtime. Persists in state so
+     * subsequent timeouts use the new value. Existing in-flight
+     * timers are not cancelled — they'll fire at their original
+     * delay, and the conditional clear handles the race.
+     */
+    type: 'SetFlashDuration';
+    ms: number;
+};
+export declare function init(opts?: AgentAttentionInitOpts): [AgentAttentionState, AgentEffect[]];
+export declare function update(state: AgentAttentionState, msg: AgentAttentionMsg): [AgentAttentionState, AgentEffect[]];
+import type { Send } from '@llui/dom';
+export type ConnectBag<S> = {
+    root: {
+        'data-scope': 'agent-attention';
+    };
+    /**
+     * Reactive boolean accessor: true while the spotlight covers `path`.
+     * Use as the predicate for a conditional class binding in the host's
+     * own element bag. Memoized by `path` so each `flashing(path)` call
+     * returns the same accessor across renders, keeping the underlying
+     * binding's `lastValue` short-circuit valid.
+     */
+    flashing: (path: string) => (s: S) => boolean;
+    /**
+     * Convenience accessor: returns `className` (default `'agent-flash'`)
+     * while flashing, otherwise `undefined`. Spread into element bags
+     * via `class: bag.flashClass('items')`. Memoized per `(path, className)`
+     * pair.
+     */
+    flashClass: (path: string, className?: string) => (s: S) => string | undefined;
+    /**
+     * Metadata about the action that touched this path, or null when
+     * the spotlight isn't on this path. Useful for tooltips or aria-live
+     * narration: "agent → SelectAlternative just changed alternatives."
+     * Memoized per `path`.
+     */
+    regionAction: (path: string) => (s: S) => {
+        entryId: string;
+        variant?: string;
+        intent?: string;
+        at: number;
+    } | null;
+    /**
+     * Direct accessor on the latest dispatch envelope. Useful for a
+     * single panel-level "now flashing: X" indicator outside the
+     * per-region instrumentation.
+     */
+    latestDispatch: (s: S) => AgentAttentionState['latestDispatch'];
+};
+export declare function connect<S>(get: (s: S) => AgentAttentionState, _send: Send<AgentAttentionMsg>): ConnectBag<S>;
+//# sourceMappingURL=agentAttention.d.ts.map

package/dist/client/agentAttention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentAttention.d.ts","sourceRoot":"","sources":["../../src/client/agentAttention.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAG9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC;;;;OAIG;IACH,cAAc,EAAE;QACd,OAAO,EAAE,MAAM,CAAA;QACf;;;;;WAKG;QACH,KAAK,EAAE,MAAM,EAAE,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,EAAE,EAAE,MAAM,CAAA;KACX,GAAG,IAAI,CAAA;IACR,uEAAuE;IACvE,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,wEAAwE;IACxE,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,iBAAiB,GACzB;IACE;;;;OAIG;IACH,IAAI,EAAE,QAAQ,CAAA;IACd,KAAK,EAAE,QAAQ,CAAA;CAChB,GACD;IACE;;;;;OAKG;IACH,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,MAAM,CAAA;CAChB,GACD;IACE;;;;;OAKG;IACH,IAAI,EAAE,kBAAkB,CAAA;IACxB,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAIL,wBAAgB,IAAI,CAAC,IAAI,GAAE,sBAA2B,GAAG,CAAC,mBAAmB,EAAE,WAAW,EAAE,CAAC,CAQ5F;AAED,wBAAgB,MAAM,CACpB,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,iBAAiB,GACrB,CAAC,mBAAmB,EAAE,WAAW,EAAE,CAAC,CAuCtC;AAgCD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAIrC,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,IAAI,EAAE;QAAE,YAAY,EAAE,iBAAiB,CAAA;KAAE,CAAA;IACzC;;;;;;OAMG;IACH,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;IAC7C;;;;;OAKG;IACH,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,CAAA;IAC9E;;;;;OAKG;IACH,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK;QACxC,OAAO,EAAE,MAAM,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,EAAE,EAAE,MAAM,CAAA;KACX,GAAG,IAAI,CAAA;IACR;;;;OAIG;IACH,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,mBAAmB,CAAC,gBAAgB,CAAC,CAAA;CAChE,CAAA;AAED,wBAAgB,OAAO,CAAC,CAAC,EACvB,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,mBAAmB,EAClC,KAAK,EAAE,IAAI,CAAC,iBAAiB,CAAC,GAC7B,UAAU,CAAC,CAAC,CAAC,CA2Ef"}

package/dist/client/agentAttention.js

@@ -0,0 +1,156 @@
+const DEFAULT_FLASH_MS = 600;
+export function init(opts = {}) {
+    return [
+        {
+            latestDispatch: null,
+            flashDurationMs: opts.flashDurationMs ?? DEFAULT_FLASH_MS,
+        },
+        [],
+    ];
+}
+export function update(state, msg) {
+    switch (msg.type) {
+        case 'Append': {
+            const entry = msg.entry;
+            // Only dispatched entries update the spotlight. Read / proposed /
+            // blocked / error / user-input entries don't represent a state
+            // mutation, so the visual cue is meaningless for them.
+            if (entry.kind !== 'dispatched')
+                return [state, []];
+            const paths = topLevelPaths(entry.stateDiff);
+            // No diff (or empty diff) means the dispatch landed but nothing
+            // changed — silent success. Skip the spotlight rather than
+            // flashing nothing in particular.
+            if (paths.length === 0)
+                return [state, []];
+            const next = {
+                ...state,
+                latestDispatch: {
+                    entryId: entry.id,
+                    paths,
+                    variant: entry.variant,
+                    intent: entry.intent,
+                    at: entry.at,
+                },
+            };
+            return [
+                next,
+                [{ type: 'AgentAttentionFlashTimeout', entryId: entry.id, delayMs: state.flashDurationMs }],
+            ];
+        }
+        case 'Clear': {
+            // Conditional clear: only wipe if the timer's entryId still
+            // matches the current spotlight. If a newer dispatch landed in
+            // the meantime, the older timer is a no-op.
+            if (state.latestDispatch?.entryId !== msg.entryId)
+                return [state, []];
+            return [{ ...state, latestDispatch: null }, []];
+        }
+        case 'SetFlashDuration': {
+            return [{ ...state, flashDurationMs: Math.max(0, msg.ms) }, []];
+        }
+    }
+}
+/**
+ * Extract top-level state paths from a JSON-Patch StateDiff.
+ *
+ * - `op.path === '/'` (root replace) → wildcard `'*'`. The host's
+ *   accessors match every region against `'*'`, so a whole-state
+ *   swap (rare in TEA but possible via dev hot-reload, time-travel
+ *   restore) flashes everything.
+ * - `op.path === '/items/3/name'` → `'items'`. Multi-segment paths
+ *   collapse to their top-level field; per-region matching is at
+ *   field granularity, not deep-path granularity, because the host's
+ *   layout typically maps regions to top-level state slices, not to
+ *   deep cells.
+ * - Empty / undefined diff → empty array. No spotlight.
+ */
+function topLevelPaths(diff) {
+    if (!diff || diff.length === 0)
+        return [];
+    const seen = new Set();
+    for (const op of diff) {
+        const path = op.path;
+        if (path === '' || path === '/') {
+            seen.add('*');
+            continue;
+        }
+        // JSON-Pointer: leading '/' splits into ['', '<top>', '<rest>...'].
+        const parts = path.split('/');
+        if (parts.length >= 2 && parts[1])
+            seen.add(parts[1]);
+    }
+    return Array.from(seen);
+}
+const UNSET = Symbol('agent-attention-unset');
+export function connect(get, _send) {
+    // Per-call-shape accessor caches. Two reasons for memoizing:
+    // 1. Stable reference per `(path, className)` lets the underlying
+    //    LLui binding short-circuit on `Object.is(lastValue, newValue)`
+    //    — without it, `bag.flashing('items')` would allocate a fresh
+    //    closure each call and the binding would re-fire even when the
+    //    state hasn't changed.
+    // 2. Hosts iterate `each(visibleEntries, ...)` calling these in tight
+    //    inner loops; per-render allocation costs would compound.
+    const flashingCache = new Map();
+    const flashClassCache = new Map();
+    const regionActionCache = new Map();
+    // Single-slot memo on the parent state ref for `flashing(path)`'s
+    // path → boolean lookup. Hot path: each frame's view evaluates
+    // every region's `flashing(path)` once; on a state where 30 regions
+    // are wired and one is highlighted, the inclusion check is trivial,
+    // but the parent-state-ref invariant still saves the `get(s)` and
+    // `Array.includes` work for the other 29.
+    let lastFlashState = UNSET;
+    let lastDispatch = null;
+    const refreshDispatch = (state) => {
+        if (state === lastFlashState)
+            return lastDispatch;
+        lastDispatch = get(state).latestDispatch;
+        lastFlashState = state;
+        return lastDispatch;
+    };
+    const matches = (state, path) => {
+        const d = refreshDispatch(state);
+        if (!d)
+            return false;
+        return d.paths.includes('*') || d.paths.includes(path);
+    };
+    return {
+        root: { 'data-scope': 'agent-attention' },
+        flashing: (path) => {
+            const cached = flashingCache.get(path);
+            if (cached)
+                return cached;
+            const accessor = (s) => matches(s, path);
+            flashingCache.set(path, accessor);
+            return accessor;
+        },
+        flashClass: (path, className = 'agent-flash') => {
+            const key = `${path}\0${className}`;
+            const cached = flashClassCache.get(key);
+            if (cached)
+                return cached;
+            const accessor = (s) => (matches(s, path) ? className : undefined);
+            flashClassCache.set(key, accessor);
+            return accessor;
+        },
+        regionAction: (path) => {
+            const cached = regionActionCache.get(path);
+            if (cached)
+                return cached;
+            const accessor = (s) => {
+                const d = refreshDispatch(s);
+                if (!d)
+                    return null;
+                if (!d.paths.includes('*') && !d.paths.includes(path))
+                    return null;
+                return { entryId: d.entryId, variant: d.variant, intent: d.intent, at: d.at };
+            };
+            regionActionCache.set(path, accessor);
+            return accessor;
+        },
+        latestDispatch: (s) => get(s).latestDispatch,
+    };
+}
+//# sourceMappingURL=agentAttention.js.map

package/dist/client/agentAttention.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentAttention.js","sourceRoot":"","sources":["../../src/client/agentAttention.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AgentEffect } from './effects.js'\nimport type { LogEntry } from '../protocol.js'\nimport type { StateDiff } from '../state-diff.js'\n\n/**\n * Visual attention layer. Companion to `agentLog` — same `Append { entry }`\n * input shape, different output. While `agentLog` ring-buffers the full\n * activity history, `agentAttention` tracks only the most recent\n * dispatched entry's effective metadata so the host's view can flash\n * highlight classes onto DOM regions whose state paths just changed.\n *\n * Why a separate slice: the activity log is a passive timeline (read-only,\n * no time-bounded expiry, no per-region accessors). The attention layer\n * is a transient projection — the \"current dispatch's spotlight\" — that\n * has to clear itself after a configurable window, decay across renders,\n * and drive per-path accessors (one per highlightable region in the\n * host's layout). Mixing these into one slice would conflate \"I want\n * to read past actions\" with \"I want to point at the current one.\"\n *\n * Composition contract: the host appends the SAME `LogEntry` payload\n * to both slices on every `log-append` from the ws-client (typically\n * via a single `agent/log/Append` Msg routed by `sliceHandler`). The\n * attention reducer ignores entries whose `kind` isn't `'dispatched'`\n * — proposed, blocked, error, and read entries don't update the\n * attention focus, since they don't represent a state mutation.\n *\n * Auto-clear: the reducer fires an `AgentAttentionFlashTimeout` effect\n * keyed by `entryId`. After `flashDurationMs`, the effect handler\n * dispatches a `Clear { entryId }` Msg back into the slice. The\n * conditional clear (only-if-current) means a fast follow-up dispatch\n * cleanly replaces the spotlight without the timer racing to wipe the\n * new one. Hosts that don't wire `wrapAttentionMsg` in the factory\n * still see the spotlight set; it just won't auto-clear (the next\n * dispatch overwrites it instead).\n */\nexport type AgentAttentionState = {\n  /**\n   * The current dispatch's spotlight, or null when no dispatch has\n   * landed yet (or the auto-clear timer fired and `latestDispatch.entryId`\n   * matched).\n   */\n  latestDispatch: {\n    entryId: string\n    /**\n     * Top-level state paths the dispatch touched, derived from the\n     * entry's JSON-Patch `stateDiff`. A whole-state replace (path\n     * `/`) collapses to the wildcard `'*'` so callers can match every\n     * region without enumerating their own state keys.\n     */\n    paths: string[]\n    variant?: string\n    intent?: string\n    at: number\n  } | null\n  /** Configurable: how long the spotlight persists before auto-clear. */\n  flashDurationMs: number\n}\n\nexport type AgentAttentionInitOpts = {\n  /** Default 600ms — long enough to read, short enough not to obscure. */\n  flashDurationMs?: number\n}\n\nexport type AgentAttentionMsg =\n  | {\n      /**\n       * Same shape as `agentLog`'s `Append` so the host can route a\n       * single incoming Msg to both slices via `sliceHandler` without\n       * a translation layer.\n       */\n      type: 'Append'\n      entry: LogEntry\n    }\n  | {\n      /**\n       * Fired by the auto-clear timer effect. Guarded by `entryId` —\n       * the reducer only clears when `latestDispatch.entryId` matches,\n       * so a fast follow-up dispatch isn't wiped by the previous\n       * dispatch's pending timer.\n       */\n      type: 'Clear'\n      entryId: string\n    }\n  | {\n      /**\n       * Adjust the flash duration at runtime. Persists in state so\n       * subsequent timeouts use the new value. Existing in-flight\n       * timers are not cancelled — they'll fire at their original\n       * delay, and the conditional clear handles the race.\n       */\n      type: 'SetFlashDuration'\n      ms: number\n    }\n\nconst DEFAULT_FLASH_MS = 600\n\nexport function init(opts: AgentAttentionInitOpts = {}): [AgentAttentionState, AgentEffect[]] {\n  return [\n    {\n      latestDispatch: null,\n      flashDurationMs: opts.flashDurationMs ?? DEFAULT_FLASH_MS,\n    },\n    [],\n  ]\n}\n\nexport function update(\n  state: AgentAttentionState,\n  msg: AgentAttentionMsg,\n): [AgentAttentionState, AgentEffect[]] {\n  switch (msg.type) {\n    case 'Append': {\n      const entry = msg.entry\n      // Only dispatched entries update the spotlight. Read / proposed /\n      // blocked / error / user-input entries don't represent a state\n      // mutation, so the visual cue is meaningless for them.\n      if (entry.kind !== 'dispatched') return [state, []]\n      const paths = topLevelPaths(entry.stateDiff)\n      // No diff (or empty diff) means the dispatch landed but nothing\n      // changed — silent success. Skip the spotlight rather than\n      // flashing nothing in particular.\n      if (paths.length === 0) return [state, []]\n      const next: AgentAttentionState = {\n        ...state,\n        latestDispatch: {\n          entryId: entry.id,\n          paths,\n          variant: entry.variant,\n          intent: entry.intent,\n          at: entry.at,\n        },\n      }\n      return [\n        next,\n        [{ type: 'AgentAttentionFlashTimeout', entryId: entry.id, delayMs: state.flashDurationMs }],\n      ]\n    }\n    case 'Clear': {\n      // Conditional clear: only wipe if the timer's entryId still\n      // matches the current spotlight. If a newer dispatch landed in\n      // the meantime, the older timer is a no-op.\n      if (state.latestDispatch?.entryId !== msg.entryId) return [state, []]\n      return [{ ...state, latestDispatch: null }, []]\n    }\n    case 'SetFlashDuration': {\n      return [{ ...state, flashDurationMs: Math.max(0, msg.ms) }, []]\n    }\n  }\n}\n\n/**\n * Extract top-level state paths from a JSON-Patch StateDiff.\n *\n * - `op.path === '/'` (root replace) → wildcard `'*'`. The host's\n *   accessors match every region against `'*'`, so a whole-state\n *   swap (rare in TEA but possible via dev hot-reload, time-travel\n *   restore) flashes everything.\n * - `op.path === '/items/3/name'` → `'items'`. Multi-segment paths\n *   collapse to their top-level field; per-region matching is at\n *   field granularity, not deep-path granularity, because the host's\n *   layout typically maps regions to top-level state slices, not to\n *   deep cells.\n * - Empty / undefined diff → empty array. No spotlight.\n */\nfunction topLevelPaths(diff: StateDiff | undefined): string[] {\n  if (!diff || diff.length === 0) return []\n  const seen = new Set<string>()\n  for (const op of diff) {\n    const path = op.path\n    if (path === '' || path === '/') {\n      seen.add('*')\n      continue\n    }\n    // JSON-Pointer: leading '/' splits into ['', '<top>', '<rest>...'].\n    const parts = path.split('/')\n    if (parts.length >= 2 && parts[1]) seen.add(parts[1])\n  }\n  return Array.from(seen)\n}\n\nimport type { Send } from '@llui/dom'\n\nconst UNSET: unique symbol = Symbol('agent-attention-unset')\n\nexport type ConnectBag<S> = {\n  root: { 'data-scope': 'agent-attention' }\n  /**\n   * Reactive boolean accessor: true while the spotlight covers `path`.\n   * Use as the predicate for a conditional class binding in the host's\n   * own element bag. Memoized by `path` so each `flashing(path)` call\n   * returns the same accessor across renders, keeping the underlying\n   * binding's `lastValue` short-circuit valid.\n   */\n  flashing: (path: string) => (s: S) => boolean\n  /**\n   * Convenience accessor: returns `className` (default `'agent-flash'`)\n   * while flashing, otherwise `undefined`. Spread into element bags\n   * via `class: bag.flashClass('items')`. Memoized per `(path, className)`\n   * pair.\n   */\n  flashClass: (path: string, className?: string) => (s: S) => string | undefined\n  /**\n   * Metadata about the action that touched this path, or null when\n   * the spotlight isn't on this path. Useful for tooltips or aria-live\n   * narration: \"agent → SelectAlternative just changed alternatives.\"\n   * Memoized per `path`.\n   */\n  regionAction: (path: string) => (s: S) => {\n    entryId: string\n    variant?: string\n    intent?: string\n    at: number\n  } | null\n  /**\n   * Direct accessor on the latest dispatch envelope. Useful for a\n   * single panel-level \"now flashing: X\" indicator outside the\n   * per-region instrumentation.\n   */\n  latestDispatch: (s: S) => AgentAttentionState['latestDispatch']\n}\n\nexport function connect<S>(\n  get: (s: S) => AgentAttentionState,\n  _send: Send<AgentAttentionMsg>,\n): ConnectBag<S> {\n  // Per-call-shape accessor caches. Two reasons for memoizing:\n  // 1. Stable reference per `(path, className)` lets the underlying\n  //    LLui binding short-circuit on `Object.is(lastValue, newValue)`\n  //    — without it, `bag.flashing('items')` would allocate a fresh\n  //    closure each call and the binding would re-fire even when the\n  //    state hasn't changed.\n  // 2. Hosts iterate `each(visibleEntries, ...)` calling these in tight\n  //    inner loops; per-render allocation costs would compound.\n  const flashingCache = new Map<string, (s: S) => boolean>()\n  const flashClassCache = new Map<string, (s: S) => string | undefined>()\n  const regionActionCache = new Map<\n    string,\n    (s: S) => {\n      entryId: string\n      variant?: string\n      intent?: string\n      at: number\n    } | null\n  >()\n\n  // Single-slot memo on the parent state ref for `flashing(path)`'s\n  // path → boolean lookup. Hot path: each frame's view evaluates\n  // every region's `flashing(path)` once; on a state where 30 regions\n  // are wired and one is highlighted, the inclusion check is trivial,\n  // but the parent-state-ref invariant still saves the `get(s)` and\n  // `Array.includes` work for the other 29.\n  let lastFlashState: S | typeof UNSET = UNSET\n  let lastDispatch: AgentAttentionState['latestDispatch'] = null\n  const refreshDispatch = (state: S): AgentAttentionState['latestDispatch'] => {\n    if (state === lastFlashState) return lastDispatch\n    lastDispatch = get(state).latestDispatch\n    lastFlashState = state\n    return lastDispatch\n  }\n\n  const matches = (state: S, path: string): boolean => {\n    const d = refreshDispatch(state)\n    if (!d) return false\n    return d.paths.includes('*') || d.paths.includes(path)\n  }\n\n  return {\n    root: { 'data-scope': 'agent-attention' },\n    flashing: (path) => {\n      const cached = flashingCache.get(path)\n      if (cached) return cached\n      const accessor = (s: S): boolean => matches(s, path)\n      flashingCache.set(path, accessor)\n      return accessor\n    },\n    flashClass: (path, className = 'agent-flash') => {\n      const key = `${path}\\0${className}`\n      const cached = flashClassCache.get(key)\n      if (cached) return cached\n      const accessor = (s: S): string | undefined => (matches(s, path) ? className : undefined)\n      flashClassCache.set(key, accessor)\n      return accessor\n    },\n    regionAction: (path) => {\n      const cached = regionActionCache.get(path)\n      if (cached) return cached\n      const accessor = (\n        s: S,\n      ): { entryId: string; variant?: string; intent?: string; at: number } | null => {\n        const d = refreshDispatch(s)\n        if (!d) return null\n        if (!d.paths.includes('*') && !d.paths.includes(path)) return null\n        return { entryId: d.entryId, variant: d.variant, intent: d.intent, at: d.at }\n      }\n      regionActionCache.set(path, accessor)\n      return accessor\n    },\n    latestDispatch: (s) => get(s).latestDispatch,\n  }\n}\n"]}

package/dist/client/agentChat.d.ts

@@ -0,0 +1,100 @@
+import type { AgentEffect } from './effects.js';
+/**
+ * In-app chat composer slice. Owns the editor-state half of the
+ * conversational surface (`pendingInput`, `submitting`); the
+ * timeline half lives in `agentLog` (which renders the user's
+ * submission as a `LogEntry { kind: 'user-input' }` alongside agent
+ * actions, so the conversation reads chronologically).
+ *
+ * Pattern: host wires the slice into its app state via
+ * `sliceHandler`, spreads `connect()`'s prop bag into the host's
+ * own input/button layout, and the `Submit` Msg fires an effect
+ * that the framework's effect handler turns into a WS
+ * `user-input-submitted` frame + a synthesized log entry. The
+ * agent's `wait_for_user_input` LAP tool picks up the frame at the
+ * server.
+ *
+ * The composer is NOT an LLM. It's a relay surface: the user's text
+ * is delivered to the user's own LLM (Claude desktop / IDE / wherever
+ * is mounted on the MCP bridge), which already has cross-app context.
+ * The framework just provides the in-app rendezvous so the user
+ * doesn't have to alt-tab to a different window to talk to their
+ * agent about the app they're looking at.
+ */
+export type AgentChatState = {
+    /** Current contents of the input field. Bound to the input's `value`. */
+    pendingInput: string;
+    /**
+     * True between `Submit` and the effect handler completing the
+     * frame send. Disables the submit button and (typically) the
+     * input itself; reducer-driven so the UI never disagrees.
+     */
+    submitting: boolean;
+};
+export type AgentChatInitOpts = {
+    /** Pre-fill the input on mount — e.g. session-restore. */
+    initialInput?: string;
+};
+export type AgentChatMsg = {
+    /** Bound to the input's `oninput` event. Round-trip stays in the slice. */
+    type: 'SetInput';
+    value: string;
+} | {
+    /**
+     * Bound to the submit button's `onClick` and the input's
+     * `onKeyDown` (Enter, no shift). Reducer:
+     *
+     *   - Empty/whitespace → no-op (no effect, no state change).
+     *   - Has content → clear `pendingInput`, set `submitting: true`,
+     *     emit `AgentChatSendInput { text, at }` effect.
+     */
+    type: 'Submit';
+} | {
+    /**
+     * Fired by the effect handler after the frame sends so the
+     * UI re-enables the input. Always paired 1:1 with each
+     * dispatched `AgentChatSendInput` effect.
+     */
+    type: 'SubmitComplete';
+};
+export declare function init(opts?: AgentChatInitOpts): [AgentChatState, AgentEffect[]];
+export declare function update(state: AgentChatState, msg: AgentChatMsg): [AgentChatState, AgentEffect[]];
+import { type Send } from '@llui/dom';
+/**
+ * Static-prop-bag-with-reactive-accessors. Spread directly into
+ * element helpers; matches the convention of the other agent
+ * namespaces.
+ *
+ * The `input` bag carries both `oninput` and `onkeydown` because
+ * the canonical chat-composer affordance is "type, press Enter"
+ * (Shift+Enter for newline if the host wraps it themselves). Hosts
+ * that want a multiline textarea can spread `input.oninput` and
+ * skip `onkeydown`, wiring submit to the button only.
+ */
+export type ConnectBag<S> = {
+    root: {
+        'data-scope': 'agent-chat';
+        'data-submitting': (s: S) => boolean;
+    };
+    input: {
+        'data-part': 'input';
+        value: (s: S) => string;
+        disabled: (s: S) => boolean;
+        oninput: (e: Event) => void;
+        onkeydown: (e: KeyboardEvent) => void;
+    };
+    submitButton: {
+        'data-part': 'submit';
+        onClick: () => void;
+        disabled: (s: S) => boolean;
+    };
+    /**
+     * True iff the input has non-whitespace content AND we're not
+     * mid-submit. Useful as the predicate for a "send" affordance
+     * separate from the button's own `disabled` field (e.g. a
+     * keyboard-shortcut hint).
+     */
+    canSubmit: (s: S) => boolean;
+};
+export declare function connect<S>(get: (s: S) => AgentChatState, send: Send<AgentChatMsg>): ConnectBag<S>;
+//# sourceMappingURL=agentChat.d.ts.map

package/dist/client/agentChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentChat.d.ts","sourceRoot":"","sources":["../../src/client/agentChat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,yEAAyE;IACzE,YAAY,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,YAAY,GACpB;IACE,2EAA2E;IAC3E,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,EAAE,MAAM,CAAA;CACd,GACD;IACE;;;;;;;OAOG;IACH,IAAI,EAAE,QAAQ,CAAA;CACf,GACD;IACE;;;;OAIG;IACH,IAAI,EAAE,gBAAgB,CAAA;CACvB,CAAA;AAEL,wBAAgB,IAAI,CAAC,IAAI,GAAE,iBAAsB,GAAG,CAAC,cAAc,EAAE,WAAW,EAAE,CAAC,CAQlF;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,EAAE,YAAY,GAAG,CAAC,cAAc,EAAE,WAAW,EAAE,CAAC,CAyBhG;AAED,OAAO,EAAW,KAAK,IAAI,EAAE,MAAM,WAAW,CAAA;AAE9C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,IAAI,EAAE;QAAE,YAAY,EAAE,YAAY,CAAC;QAAC,iBAAiB,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;KAAE,CAAA;IAC1E,KAAK,EAAE;QACL,WAAW,EAAE,OAAO,CAAA;QACpB,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;QACvB,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;QAC3B,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAA;QAC3B,SAAS,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,IAAI,CAAA;KACtC,CAAA;IACD,YAAY,EAAE;QACZ,WAAW,EAAE,QAAQ,CAAA;QACrB,OAAO,EAAE,MAAM,IAAI,CAAA;QACnB,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;KAC5B,CAAA;IACD;;;;;OAKG;IACH,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;CAC7B,CAAA;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,cAAc,EAAE,IAAI,EAAE,IAAI,CAAC,YAAY,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAyCjG"}

package/dist/client/agentChat.js

@@ -0,0 +1,84 @@
+export function init(opts = {}) {
+    return [
+        {
+            pendingInput: opts.initialInput ?? '',
+            submitting: false,
+        },
+        [],
+    ];
+}
+export function update(state, msg) {
+    switch (msg.type) {
+        case 'SetInput':
+            // No-op when the value is identical — keeps state ref stable
+            // for memoization above this slice.
+            if (msg.value === state.pendingInput)
+                return [state, []];
+            return [{ ...state, pendingInput: msg.value }, []];
+        case 'Submit': {
+            // Don't double-submit while a previous send is in flight, and
+            // don't send empty/whitespace messages — neither is a useful
+            // signal for the agent and both are common bounce events
+            // (keyboard auto-repeat on Enter, click-then-click-again).
+            if (state.submitting)
+                return [state, []];
+            const trimmed = state.pendingInput.trim();
+            if (trimmed.length === 0)
+                return [state, []];
+            const at = Date.now();
+            return [
+                { ...state, pendingInput: '', submitting: true },
+                [{ type: 'AgentChatSendInput', text: trimmed, at }],
+            ];
+        }
+        case 'SubmitComplete':
+            if (!state.submitting)
+                return [state, []];
+            return [{ ...state, submitting: false }, []];
+    }
+}
+import { tagSend } from '@llui/dom';
+export function connect(get, send) {
+    const submit = tagSend(send, ['Submit'], () => send({ type: 'Submit' }));
+    const setInput = (value) => send({ type: 'SetInput', value });
+    return {
+        root: {
+            'data-scope': 'agent-chat',
+            'data-submitting': (s) => get(s).submitting,
+        },
+        input: {
+            'data-part': 'input',
+            value: (s) => get(s).pendingInput,
+            disabled: (s) => get(s).submitting,
+            oninput: (e) => {
+                // The cast is the standard "input event target is an
+                // HTMLInputElement / HTMLTextAreaElement" assumption; we
+                // coerce via `.value`. Hosts using non-DOM inputs (custom
+                // contenteditable etc.) bypass this prop bag and dispatch
+                // SetInput directly.
+                const target = e.target;
+                if (target && typeof target.value === 'string')
+                    setInput(target.value);
+            },
+            onkeydown: (e) => {
+                if (e.key === 'Enter' && !e.shiftKey) {
+                    e.preventDefault();
+                    submit();
+                }
+            },
+        },
+        submitButton: {
+            'data-part': 'submit',
+            onClick: submit,
+            disabled: (s) => {
+                const cs = get(s);
+                return cs.submitting || cs.pendingInput.trim().length === 0;
+            },
+        },
+        canSubmit: (s) => {
+            const cs = get(s);
+            return !cs.submitting && cs.pendingInput.trim().length > 0;
+        },
+    };
+}
+//# sourceMappingURL=agentChat.js.map

package/dist/client/agentChat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentChat.js","sourceRoot":"","sources":["../../src/client/agentChat.ts"],"names":[],"mappings":"AAkEA,MAAM,UAAU,IAAI,CAAC,OAA0B,EAAE;IAC/C,OAAO;QACL;YACE,YAAY,EAAE,IAAI,CAAC,YAAY,IAAI,EAAE;YACrC,UAAU,EAAE,KAAK;SAClB;QACD,EAAE;KACH,CAAA;AACH,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,KAAqB,EAAE,GAAiB;IAC7D,QAAQ,GAAG,CAAC,IAAI,EAAE,CAAC;QACjB,KAAK,UAAU;YACb,6DAA6D;YAC7D,oCAAoC;YACpC,IAAI,GAAG,CAAC,KAAK,KAAK,KAAK,CAAC,YAAY;gBAAE,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;YACxD,OAAO,CAAC,EAAE,GAAG,KAAK,EAAE,YAAY,EAAE,GAAG,CAAC,KAAK,EAAE,EAAE,EAAE,CAAC,CAAA;QACpD,KAAK,QAAQ,CAAC,CAAC,CAAC;YACd,8DAA8D;YAC9D,6DAA6D;YAC7D,yDAAyD;YACzD,2DAA2D;YAC3D,IAAI,KAAK,CAAC,UAAU;gBAAE,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;YACxC,MAAM,OAAO,GAAG,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,CAAA;YACzC,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;YAC5C,MAAM,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;YACrB,OAAO;gBACL,EAAE,GAAG,KAAK,EAAE,YAAY,EAAE,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE;gBAChD,CAAC,EAAE,IAAI,EAAE,oBAAoB,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;aACpD,CAAA;QACH,CAAC;QACD,KAAK,gBAAgB;YACnB,IAAI,CAAC,KAAK,CAAC,UAAU;gBAAE,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;YACzC,OAAO,CAAC,EAAE,GAAG,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAA;IAChD,CAAC;AACH,CAAC;AAED,OAAO,EAAE,OAAO,EAAa,MAAM,WAAW,CAAA;AAoC9C,MAAM,UAAU,OAAO,CAAI,GAA6B,EAAE,IAAwB;IAChF,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAA;IACxE,MAAM,QAAQ,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAA;IACrE,OAAO;QACL,IAAI,EAAE;YACJ,YAAY,EAAE,YAAY;YAC1B,iBAAiB,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU;SAC5C;QACD,KAAK,EAAE;YACL,WAAW,EAAE,OAAO;YACpB,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY;YACjC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU;YAClC,OAAO,EAAE,CAAC,CAAC,EAAE,EAAE;gBACb,qDAAqD;gBACrD,yDAAyD;gBACzD,0DAA0D;gBAC1D,0DAA0D;gBAC1D,qBAAqB;gBACrB,MAAM,MAAM,GAAG,CAAC,CAAC,MAAmC,CAAA;gBACpD,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ;oBAAE,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;YACxE,CAAC;YACD,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE;gBACf,IAAI,CAAC,CAAC,GAAG,KAAK,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;oBACrC,CAAC,CAAC,cAAc,EAAE,CAAA;oBAClB,MAAM,EAAE,CAAA;gBACV,CAAC;YACH,CAAC;SACF;QACD,YAAY,EAAE;YACZ,WAAW,EAAE,QAAQ;YACrB,OAAO,EAAE,MAAM;YACf,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE;gBACd,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAA;gBACjB,OAAO,EAAE,CAAC,UAAU,IAAI,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,CAAA;YAC7D,CAAC;SACF;QACD,SAAS,EAAE,CAAC,CAAC,EAAE,EAAE;YACf,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,CAAA;YACjB,OAAO,CAAC,EAAE,CAAC,UAAU,IAAI,EAAE,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAA;QAC5D,CAAC;KACF,CAAA;AACH,CAAC","sourcesContent":["import type { AgentEffect } from './effects.js'\n\n/**\n * In-app chat composer slice. Owns the editor-state half of the\n * conversational surface (`pendingInput`, `submitting`); the\n * timeline half lives in `agentLog` (which renders the user's\n * submission as a `LogEntry { kind: 'user-input' }` alongside agent\n * actions, so the conversation reads chronologically).\n *\n * Pattern: host wires the slice into its app state via\n * `sliceHandler`, spreads `connect()`'s prop bag into the host's\n * own input/button layout, and the `Submit` Msg fires an effect\n * that the framework's effect handler turns into a WS\n * `user-input-submitted` frame + a synthesized log entry. The\n * agent's `wait_for_user_input` LAP tool picks up the frame at the\n * server.\n *\n * The composer is NOT an LLM. It's a relay surface: the user's text\n * is delivered to the user's own LLM (Claude desktop / IDE / wherever\n * is mounted on the MCP bridge), which already has cross-app context.\n * The framework just provides the in-app rendezvous so the user\n * doesn't have to alt-tab to a different window to talk to their\n * agent about the app they're looking at.\n */\nexport type AgentChatState = {\n  /** Current contents of the input field. Bound to the input's `value`. */\n  pendingInput: string\n  /**\n   * True between `Submit` and the effect handler completing the\n   * frame send. Disables the submit button and (typically) the\n   * input itself; reducer-driven so the UI never disagrees.\n   */\n  submitting: boolean\n}\n\nexport type AgentChatInitOpts = {\n  /** Pre-fill the input on mount — e.g. session-restore. */\n  initialInput?: string\n}\n\nexport type AgentChatMsg =\n  | {\n      /** Bound to the input's `oninput` event. Round-trip stays in the slice. */\n      type: 'SetInput'\n      value: string\n    }\n  | {\n      /**\n       * Bound to the submit button's `onClick` and the input's\n       * `onKeyDown` (Enter, no shift). Reducer:\n       *\n       *   - Empty/whitespace → no-op (no effect, no state change).\n       *   - Has content → clear `pendingInput`, set `submitting: true`,\n       *     emit `AgentChatSendInput { text, at }` effect.\n       */\n      type: 'Submit'\n    }\n  | {\n      /**\n       * Fired by the effect handler after the frame sends so the\n       * UI re-enables the input. Always paired 1:1 with each\n       * dispatched `AgentChatSendInput` effect.\n       */\n      type: 'SubmitComplete'\n    }\n\nexport function init(opts: AgentChatInitOpts = {}): [AgentChatState, AgentEffect[]] {\n  return [\n    {\n      pendingInput: opts.initialInput ?? '',\n      submitting: false,\n    },\n    [],\n  ]\n}\n\nexport function update(state: AgentChatState, msg: AgentChatMsg): [AgentChatState, AgentEffect[]] {\n  switch (msg.type) {\n    case 'SetInput':\n      // No-op when the value is identical — keeps state ref stable\n      // for memoization above this slice.\n      if (msg.value === state.pendingInput) return [state, []]\n      return [{ ...state, pendingInput: msg.value }, []]\n    case 'Submit': {\n      // Don't double-submit while a previous send is in flight, and\n      // don't send empty/whitespace messages — neither is a useful\n      // signal for the agent and both are common bounce events\n      // (keyboard auto-repeat on Enter, click-then-click-again).\n      if (state.submitting) return [state, []]\n      const trimmed = state.pendingInput.trim()\n      if (trimmed.length === 0) return [state, []]\n      const at = Date.now()\n      return [\n        { ...state, pendingInput: '', submitting: true },\n        [{ type: 'AgentChatSendInput', text: trimmed, at }],\n      ]\n    }\n    case 'SubmitComplete':\n      if (!state.submitting) return [state, []]\n      return [{ ...state, submitting: false }, []]\n  }\n}\n\nimport { tagSend, type Send } from '@llui/dom'\n\n/**\n * Static-prop-bag-with-reactive-accessors. Spread directly into\n * element helpers; matches the convention of the other agent\n * namespaces.\n *\n * The `input` bag carries both `oninput` and `onkeydown` because\n * the canonical chat-composer affordance is \"type, press Enter\"\n * (Shift+Enter for newline if the host wraps it themselves). Hosts\n * that want a multiline textarea can spread `input.oninput` and\n * skip `onkeydown`, wiring submit to the button only.\n */\nexport type ConnectBag<S> = {\n  root: { 'data-scope': 'agent-chat'; 'data-submitting': (s: S) => boolean }\n  input: {\n    'data-part': 'input'\n    value: (s: S) => string\n    disabled: (s: S) => boolean\n    oninput: (e: Event) => void\n    onkeydown: (e: KeyboardEvent) => void\n  }\n  submitButton: {\n    'data-part': 'submit'\n    onClick: () => void\n    disabled: (s: S) => boolean\n  }\n  /**\n   * True iff the input has non-whitespace content AND we're not\n   * mid-submit. Useful as the predicate for a \"send\" affordance\n   * separate from the button's own `disabled` field (e.g. a\n   * keyboard-shortcut hint).\n   */\n  canSubmit: (s: S) => boolean\n}\n\nexport function connect<S>(get: (s: S) => AgentChatState, send: Send<AgentChatMsg>): ConnectBag<S> {\n  const submit = tagSend(send, ['Submit'], () => send({ type: 'Submit' }))\n  const setInput = (value: string) => send({ type: 'SetInput', value })\n  return {\n    root: {\n      'data-scope': 'agent-chat',\n      'data-submitting': (s) => get(s).submitting,\n    },\n    input: {\n      'data-part': 'input',\n      value: (s) => get(s).pendingInput,\n      disabled: (s) => get(s).submitting,\n      oninput: (e) => {\n        // The cast is the standard \"input event target is an\n        // HTMLInputElement / HTMLTextAreaElement\" assumption; we\n        // coerce via `.value`. Hosts using non-DOM inputs (custom\n        // contenteditable etc.) bypass this prop bag and dispatch\n        // SetInput directly.\n        const target = e.target as { value?: string } | null\n        if (target && typeof target.value === 'string') setInput(target.value)\n      },\n      onkeydown: (e) => {\n        if (e.key === 'Enter' && !e.shiftKey) {\n          e.preventDefault()\n          submit()\n        }\n      },\n    },\n    submitButton: {\n      'data-part': 'submit',\n      onClick: submit,\n      disabled: (s) => {\n        const cs = get(s)\n        return cs.submitting || cs.pendingInput.trim().length === 0\n      },\n    },\n    canSubmit: (s) => {\n      const cs = get(s)\n      return !cs.submitting && cs.pendingInput.trim().length > 0\n    },\n  }\n}\n"]}

package/dist/client/agentLog.d.ts

@@ -1,5 +1,6 @@
 import type { AgentEffect } from './effects.js';
 import type { LogEntry, LogKind } from '../protocol.js';
+import type { StateDiff } from '../state-diff.js';
 export type AgentLogFilter = {
     kinds?: LogKind[];
     since?: number;
@@ -63,6 +64,22 @@ export type ConnectBag<S> = {
     };
     /** Filtered view of entries — respects state.filter. */
     visibleEntries: (s: S) => LogEntry[];
+    /**
+     * Reactive accessor for an entry's structural diff (JSON-Patch).
+     * Returns the entry's `stateDiff` when present, `null` otherwise —
+     * `null` covers three distinct cases: the entry exists but its kind
+     * (read / proposed / etc.) doesn't carry a diff; the entry was filtered
+     * out; the entry was evicted by the ring-buffer or never appended.
+     * Hosts that render a per-entry "what changed" sidecar wire this to
+     * a structural primitive (`branch`, `each`) so the sidecar disposes
+     * cleanly when the entry leaves.
+     *
+     * Lookup is over `state.entries` directly (NOT through the filter)
+     * — a hidden-by-filter entry still has its diff available, which is
+     * what consumers expect when reading from a sidecar that may outlive
+     * the visibility filter.
+     */
+    entryDiff: (id: string) => (s: S) => StateDiff | null;
 };
 export declare function connect<S>(get: (s: S) => AgentLogState, send: Send<AgentLogMsg>): ConnectBag<S>;
 //# sourceMappingURL=agentLog.d.ts.map

package/dist/client/agentLog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agentLog.d.ts","sourceRoot":"","sources":["../../src/client/agentLog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAEvD,MAAM,MAAM,cAAc,GAAG;IAAE,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAElE,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,QAAQ,EAAE,CAAA;IACnB,MAAM,EAAE,cAAc,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtD,MAAM,MAAM,WAAW;AACrB;;;;GAIG;AACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE;AACrC,8CAA8C;GAC5C;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE;AACnB,6DAA6D;GAC3D;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,cAAc,CAAA;CAAE,CAAA;AAIjD,wBAAgB,IAAI,CAAC,KAAK,GAAE,gBAAqB,GAAG,CAAC,aAAa,EAAE,WAAW,EAAE,CAAC,CAEjF;AAED,wBAAgB,MAAM,CACpB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,WAAW,EAChB,IAAI,GAAE,gBAAqB,GAC1B,CAAC,aAAa,EAAE,WAAW,EAAE,CAAC,CAchC;AAGD,OAAO,EAAW,KAAK,IAAI,EAAE,MAAM,WAAW,CAAA;AAM9C;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,IAAI,EAAE;QAAE,YAAY,EAAE,WAAW,CAAA;KAAE,CAAA;IACnC,IAAI,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;KAAE,CAAA;IAC7D,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK;QACzB,WAAW,EAAE,OAAO,CAAA;QACpB,SAAS,EAAE,MAAM,CAAA;QACjB,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,SAAS,CAAA;KAC3C,CAAA;IACD,cAAc,EAAE;QACd,WAAW,EAAE;YAAE,OAAO,EAAE,MAAM,IAAI,CAAC;YAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;SAAE,CAAA;QACjE,SAAS,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAA;KAC5C,CAAA;IACD,wDAAwD;IACxD,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,EAAE,CAAA;CACrC,CAAA;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,aAAa,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CA4C/F"}
+{"version":3,"file":"agentLog.d.ts","sourceRoot":"","sources":["../../src/client/agentLog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,MAAM,MAAM,cAAc,GAAG;IAAE,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAElE,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,QAAQ,EAAE,CAAA;IACnB,MAAM,EAAE,cAAc,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEtD,MAAM,MAAM,WAAW;AACrB;;;;GAIG;AACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE;AACrC,8CAA8C;GAC5C;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE;AACnB,6DAA6D;GAC3D;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,cAAc,CAAA;CAAE,CAAA;AAIjD,wBAAgB,IAAI,CAAC,KAAK,GAAE,gBAAqB,GAAG,CAAC,aAAa,EAAE,WAAW,EAAE,CAAC,CAEjF;AAED,wBAAgB,MAAM,CACpB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,WAAW,EAChB,IAAI,GAAE,gBAAqB,GAC1B,CAAC,aAAa,EAAE,WAAW,EAAE,CAAC,CAchC;AAGD,OAAO,EAAW,KAAK,IAAI,EAAE,MAAM,WAAW,CAAA;AAM9C;;;;;;;GAOG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,IAAI,EAAE;QAAE,YAAY,EAAE,WAAW,CAAA;KAAE,CAAA;IACnC,IAAI,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;KAAE,CAAA;IAC7D,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK;QACzB,WAAW,EAAE,OAAO,CAAA;QACpB,SAAS,EAAE,MAAM,CAAA;QACjB,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,SAAS,CAAA;KAC3C,CAAA;IACD,cAAc,EAAE;QACd,WAAW,EAAE;YAAE,OAAO,EAAE,MAAM,IAAI,CAAC;YAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAA;SAAE,CAAA;QACjE,SAAS,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAA;KAC5C,CAAA;IACD,wDAAwD;IACxD,cAAc,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,QAAQ,EAAE,CAAA;IACpC;;;;;;;;;;;;;;OAcG;IACH,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,SAAS,GAAG,IAAI,CAAA;CACtD,CAAA;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,aAAa,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CA+D/F"}

package/dist/client/agentLog.js

@@ -48,6 +48,16 @@ export function connect(get, send) {
         return lastResult;
     };
     const findVisible = (state, id) => visible(state).find((x) => x.id === id);
+    // Per-id diff accessor cache. The `each(bag.visibleEntries)` pattern
+    // calls `bag.entryDiff(entry.id)` once per row at view-construction —
+    // memoizing keeps each row's accessor stable across re-renders, so
+    // the underlying binding's `lastValue` short-circuits repeat reads
+    // when state hasn't changed (parent state ref equality is sufficient
+    // because TEA state is immutable). Without this, every view pass
+    // would allocate a fresh closure and the binding would re-fire even
+    // though the entry's diff is invariant for an entry's lifetime.
+    const diffAccessorCache = new Map();
+    const findById = (state, id) => get(state).entries.find((x) => x.id === id);
     return {
         root: { 'data-scope': 'agent-log' },
         list: {
@@ -67,6 +77,14 @@ export function connect(get, send) {
             setFilter: (filter) => send({ type: 'SetFilter', filter }),
         },
         visibleEntries: visible,
+        entryDiff: (id) => {
+            const cached = diffAccessorCache.get(id);
+            if (cached)
+                return cached;
+            const accessor = (s) => findById(s, id)?.stateDiff ?? null;
+            diffAccessorCache.set(id, accessor);
+            return accessor;
+        },
     };
 }
 //# sourceMappingURL=agentLog.js.map