@ai-matrx/chat 0.7.1 → 0.7.3

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @ai-matrx/chat
 
+## 0.7.3
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/chat/v0.7.2..npm/chat/v0.7.3 -- apps/shared/chat`).
+No source changes intended and no consumer action required.
+
+## 0.7.2
+
+Automatic changed-only republish (docs/metadata drift since the last tag — see
+`git diff npm/chat/v0.7.1..npm/chat/v0.7.2 -- apps/shared/chat`).
+No source changes intended and no consumer action required.
+
 ## 0.7.1
 
 Automatic changed-only republish (docs/metadata drift since the last tag — see

package/dist/agents/redux/execution-system/instance-resources/default-remark-durability.d.ts

@@ -8,15 +8,21 @@
  * (state_version > sent_version, not dismissed at that version) and carries `blockStateRef` so the
  * server marks it sent with the message. A chip belongs to the conversation it was staged into.
  * Registered by `<ChatProvider>` for a private store when the host registered no port of its own.
- * Not in this default: the live feed from another tab (the next mount lists again).
+ * Live: a chip made, sent or dismissed in another tab or on another device lands here without a
+ * reload, through the realtime feed (`subscribeFeed`, injectable for tests). Runs on EVERY host.
  */
 import type { ChatDb } from "../../../../host/contract.js";
 import type { ChatDispatch } from "../../../../store/root-state.js";
+import { type RemarkFeedSubscribe } from "./remark-feed.js";
 import { type RemarkDurability } from "./remarks.js";
 export interface DefaultRemarkDurabilityOptions {
     db: ChatDb;
     dispatch: ChatDispatch;
+    /** The host store's state: answers (a conversation with none has no feed), sent chips, the person. */
+    getState: () => unknown;
+    /** The live feed of a conversation's rows. Default: the realtime broadcast. */
+    subscribeFeed?: RemarkFeedSubscribe;
     /** A write that failed: say so (the host's notify + console). */
     onFailure: (message: string, error: unknown) => void;
 }
-export declare function createDbRemarkDurability({ db, dispatch, onFailure }: DefaultRemarkDurabilityOptions): RemarkDurability;
+export declare function createDbRemarkDurability({ db, dispatch, getState, subscribeFeed, onFailure }: DefaultRemarkDurabilityOptions): RemarkDurability;

package/dist/agents/redux/execution-system/instance-resources/default-remark-durability.js

@@ -1,7 +1,10 @@
 import { durableRecordId } from "@ai-matrx/kit/ids";
+import { selectUserId } from "../../../../host/identity.js";
+import { subscribeRemarkFeed } from "./remark-feed.js";
 import {
   attachRemarkRef,
   readStoredRemarks,
+  remarkSourceOf,
   restageRemarks,
   unstageRemark
 } from "./remarks.js";
@@ -35,7 +38,7 @@ function stripRef(item) {
   const { blockStateRef: _ref, ...rest } = item;
   return rest;
 }
-function createDbRemarkDurability({ db, dispatch, onFailure }) {
+function createDbRemarkDurability({ db, dispatch, getState, subscribeFeed = subscribeRemarkFeed, onFailure }) {
   const rpc = (name, args) => db.rpc(name, args);
   const slots = /* @__PURE__ */ new Map();
   const restored = /* @__PURE__ */ new Set();
@@ -87,6 +90,52 @@ function createDbRemarkDurability({ db, dispatch, onFailure }) {
       }
     });
   };
+  const applyRows = (conversationId, all) => {
+    const mine = all.filter((r) => r.kind === "remark" && r.state.stagedIn === conversationId && r.state.remark && typeof r.state.remark === "object");
+    const state = getState();
+    const sentRefs = /* @__PURE__ */ new Set();
+    for (const resourceId of state.instanceResources?.submittedIds?.[conversationId] ?? []) {
+      const resource = state.instanceResources?.byConversationId?.[conversationId]?.[resourceId];
+      const sentRef = resource ? remarkSourceOf(resource)?.remark.blockStateRef : null;
+      if (sentRef) sentRefs.add(`${sentRef.id}:${sentRef.stateVersion}`);
+    }
+    for (const r of mine) {
+      if (!isDue(r) && typeof r.state.coalesceKey === "string") {
+        dispatch(unstageRemark(conversationId, r.state.coalesceKey, { retire: false }));
+      }
+    }
+    const stored = readStoredRemarks(
+      mine.filter(isDue).filter((r) => !sentRefs.has(`${r.id}:${r.state_version}`)).map((r) => ({
+        resourceId: typeof r.state.resourceId === "string" ? r.state.resourceId : r.id,
+        coalesceKey: typeof r.state.coalesceKey === "string" ? r.state.coalesceKey : null,
+        item: { ...r.state.remark, blockStateRef: { id: r.id, stateVersion: r.state_version } }
+      }))
+    );
+    if (stored.length > 0) dispatch(restageRemarks(conversationId, stored));
+  };
+  const watching = /* @__PURE__ */ new Map();
+  const watch = (conversationId) => {
+    if (watching.has(conversationId)) return;
+    const answers = getState().messages?.byConversationId?.[conversationId]?.orderedIds?.length ?? 0;
+    if (answers === 0) return;
+    const userId = selectUserId(getState());
+    if (!userId) return;
+    const release = subscribeFeed({ scope: "conversation", entityId: conversationId }, userId, (signal) => {
+      if ("rows" in signal) {
+        applyRows(conversationId, signal.rows);
+      } else {
+        void (async () => {
+          const { data, error } = await rpc("block_state_list_staged", { p_conversation_id: conversationId });
+          if (error) return console.error("[remarks] resync failed:", error.message);
+          applyRows(conversationId, (Array.isArray(data) ? data : []).flatMap((e) => {
+            const r = rowOf(e);
+            return r ? [r] : [];
+          }));
+        })();
+      }
+    });
+    watching.set(conversationId, release);
+  };
   return {
     save(conversationId, resourceId, coalesceKey, item) {
       const key = coalesceKey ?? resourceId;
@@ -125,36 +174,30 @@ function createDbRemarkDurability({ db, dispatch, onFailure }) {
       await Promise.all(slotsOf(conversationId).map(([, slot]) => slot.chain));
     },
     restore(conversationId) {
-      if (restored.has(conversationId) || restoring.has(conversationId)) return;
+      if (restored.has(conversationId)) {
+        watch(conversationId);
+        return;
+      }
+      if (restoring.has(conversationId)) return;
       restoring.add(conversationId);
       void (async () => {
+        let rows;
         try {
           const { data, error } = await rpc("block_state_list_staged", { p_conversation_id: conversationId });
           if (error) throw new Error(error.message);
-          restored.add(conversationId);
-          const rows = (Array.isArray(data) ? data : []).flatMap((entry) => {
+          rows = (Array.isArray(data) ? data : []).flatMap((entry) => {
             const row = rowOf(entry);
             return row ? [row] : [];
           });
-          const mine = rows.filter((r) => r.kind === "remark" && r.state.stagedIn === conversationId && r.state.remark && typeof r.state.remark === "object");
-          for (const r of mine) {
-            if (!isDue(r) && typeof r.state.coalesceKey === "string") {
-              dispatch(unstageRemark(conversationId, r.state.coalesceKey, { retire: false }));
-            }
-          }
-          const stored = readStoredRemarks(
-            mine.filter(isDue).map((r) => ({
-              resourceId: typeof r.state.resourceId === "string" ? r.state.resourceId : r.id,
-              coalesceKey: typeof r.state.coalesceKey === "string" ? r.state.coalesceKey : null,
-              item: { ...r.state.remark, blockStateRef: { id: r.id, stateVersion: r.state_version } }
-            }))
-          );
-          if (stored.length > 0) dispatch(restageRemarks(conversationId, stored));
         } catch (error) {
           console.error("[remarks] restoring unsent chips failed:", error);
+          return;
         } finally {
           restoring.delete(conversationId);
         }
+        restored.add(conversationId);
+        applyRows(conversationId, rows);
+        watch(conversationId);
       })();
     }
   };

package/dist/agents/redux/execution-system/instance-resources/remark-feed.d.ts

@@ -0,0 +1,26 @@
+/**
+ * remark-feed — the live feed of one conversation's block-state rows (PRIVATE Database Broadcast
+ * topics the block-state door sends on; event `block_state`, payload {op, row}):
+ *   shared rows   block_states:<scope>:<entity id>
+ *   private rows  block_states:<scope>:<entity id>:<user id>
+ * `scope` is `conversation` for chat answers. Refcounted: one pair of channels per unit.
+ * Namespace specs are identical to the host's own block feed, so both may declare them.
+ */
+export interface RemarkFeedRow {
+    id: string;
+    kind: string;
+    state_version: number;
+    sent_version: number;
+    state: Record<string, unknown>;
+    metadata: Record<string, unknown> | null;
+}
+export type RemarkFeedSignal = {
+    rows: RemarkFeedRow[];
+} | {
+    resync: true;
+};
+export type RemarkFeedSubscribe = (unit: {
+    scope: string;
+    entityId: string;
+}, userId: string, listener: (signal: RemarkFeedSignal) => void) => () => void;
+export declare const subscribeRemarkFeed: RemarkFeedSubscribe;

package/dist/agents/redux/execution-system/instance-resources/remark-feed.js

@@ -0,0 +1,87 @@
+import { defineChannelNamespace, onRealtimeManagerChange } from "@ai-matrx/realtime";
+const sharedChannel = defineChannelNamespace({
+  namespace: "block-states-shared",
+  parts: ["scope", "entityId"],
+  description: "Block state rows everyone on a record sees (private Database Broadcast)",
+  foreignTopic: "block_states"
+});
+const privateChannel = defineChannelNamespace({
+  namespace: "block-states-private",
+  parts: ["scope", "entityId", "viewerId"],
+  description: "One person's own block state rows on a record (private Database Broadcast)",
+  foreignTopic: "block_states"
+});
+const entries = /* @__PURE__ */ new Map();
+function rowOf(value) {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (typeof r.id !== "string" || typeof r.state_version !== "number") return null;
+  return {
+    id: r.id,
+    kind: String(r.kind ?? ""),
+    state_version: r.state_version,
+    sent_version: typeof r.sent_version === "number" ? r.sent_version : 0,
+    state: r.state && typeof r.state === "object" ? r.state : {},
+    metadata: r.metadata && typeof r.metadata === "object" ? r.metadata : null
+  };
+}
+const subscribeRemarkFeed = (unit, userId, listener) => {
+  const id = `${unit.scope}:${unit.entityId}:${userId}`;
+  let entry = entries.get(id);
+  if (!entry) {
+    const created = { listeners: /* @__PURE__ */ new Set(), handles: [], stop: () => {
+    } };
+    const fan = (signal) => {
+      for (const l of Array.from(created.listeners)) l(signal);
+    };
+    const closeAll = () => {
+      for (const h of created.handles) h.close();
+      created.handles = [];
+    };
+    created.stop = onRealtimeManagerChange((manager) => {
+      closeAll();
+      if (!manager) return;
+      const open = (topic) => manager.open({
+        topic,
+        private: true,
+        wire: { mode: "raw", acceptEchoFromSelf: true },
+        broadcast: [
+          {
+            event: "block_state",
+            onMessage: ({ data }) => {
+              const row = rowOf(data?.row);
+              if (row) fan({ rows: [row] });
+            }
+          }
+        ],
+        eventKey: (_source, payload) => {
+          const frame = payload;
+          const row = frame?.row;
+          return row?.id === void 0 ? void 0 : `${String(row.id)}:${String(row.version)}:${String(row.state_version)}:${String(row.sent_version)}:${frame?.op ?? ""}`;
+        },
+        // Realtime has no replay: whatever happened while the socket was away is re-read.
+        onBackfill: () => fan({ resync: true })
+      });
+      created.handles = [
+        open(sharedChannel.topic({ scope: unit.scope, entityId: unit.entityId })),
+        open(privateChannel.topic({ scope: unit.scope, entityId: unit.entityId, viewerId: userId }))
+      ];
+    });
+    entries.set(id, created);
+    entry = created;
+  }
+  entry.listeners.add(listener);
+  return () => {
+    const current = entries.get(id);
+    if (!current) return;
+    current.listeners.delete(listener);
+    if (current.listeners.size === 0) {
+      current.stop();
+      for (const h of current.handles) h.close();
+      entries.delete(id);
+    }
+  };
+};
+export {
+  subscribeRemarkFeed
+};

package/dist/agents/redux/execution-system/instance-resources/remarks.d.ts

@@ -157,6 +157,16 @@ export interface RemarkDurability {
     /** Write everything queued NOW and wait until every chip holds its saved row/ref. */
     flush(conversationId: string): Promise<void>;
 }
+/**
+ * Other writers whose saved state a send must wait for (a mounted interactive block's queued
+ * answers). They join the chips' flush: one call writes everything for the conversation.
+ */
+export interface PendingWritesPort {
+    hasPending(conversationId: string): boolean;
+    flush(conversationId: string): Promise<void>;
+}
+/** Join the send's flush. Returns the release. */
+export declare function registerPendingWritesPort(port: PendingWritesPort): () => void;
 /** True while some chip of this conversation has not yet been saved server-side. */
 export declare function hasPendingRemarkWrites(conversationId: string): boolean;
 /**

package/dist/agents/redux/execution-system/instance-resources/remarks.js

@@ -69,8 +69,15 @@ function buildSource(item, coalesceKey) {
     text: remarkReadableText(item)
   };
 }
+const pendingWritePorts = /* @__PURE__ */ new Set();
+function registerPendingWritesPort(port) {
+  pendingWritePorts.add(port);
+  return () => {
+    pendingWritePorts.delete(port);
+  };
+}
 function hasPendingRemarkWrites(conversationId) {
-  return durability?.hasPending(conversationId) ?? false;
+  return (durability?.hasPending(conversationId) ?? false) || [...pendingWritePorts].some((p) => p.hasPending(conversationId));
 }
 function isRemarkDurabilityRegistered() {
   return durability !== null;
@@ -80,12 +87,12 @@ function announceMissingDurability(op) {
   if (announcedMissing.has(op)) return;
   announcedMissing.add(op);
   console.error(
-    `[remarks] ${op} ran with no durability port registered: unsent chips are NOT kept server-side. The app must call registerRemarkDurability (providers/ChatSurfaceRegistrations).`
+    `[remarks] ${op} ran with no durability port registered: unsent chips are NOT kept server-side. <ChatProvider> registers the default; a host that replaced it must keep one registered.`
   );
 }
 async function flushRemarkWrites(conversationId) {
   if (!durability) announceMissingDurability("flush");
-  await durability?.flush(conversationId);
+  await Promise.all([durability?.flush(conversationId), ...[...pendingWritePorts].map((p) => p.flush(conversationId))]);
 }
 function restoreComposerRemarks(conversationId) {
   if (!durability) announceMissingDurability("restore");
@@ -222,6 +229,7 @@ export {
   hasPendingRemarkWrites,
   isRemarkDurabilityRegistered,
   readStoredRemarks,
+  registerPendingWritesPort,
   registerRemarkDurability,
   remarkChipTitle,
   remarkKindLabel,