@ai-matrx/chat 0.3.11 → 0.3.19

package/dist/agents/redux/execution-system/instance-working-document/cx-working-document.service.js

@@ -10,27 +10,67 @@ function rowToCxWorkingDocument(row) {
   return {
     id: row.id,
     conversationId: row.metadata?.origin_conversation_id ?? null,
-    kind: row.kind ?? "working",
+    kind: kindForTypeId(row.document_type_id),
     title: row.title,
-    content: row.content,
+    content: row.body,
     version: row.version,
     createdAt: row.created_at,
     updatedAt: row.updated_at
   };
 }
-const WD = () => supabase.schema("workbench").from("working_documents");
+const WORKING_DOCUMENT_ENTITY = "document";
+const TYPE_SLUG = {
+  working: "working_document",
+  scratch: "scratch"
+};
+const WD_COLUMNS = "id, document_type_id, title, body, version, metadata, created_at, updated_at";
+let typeIdsPromise = null;
+let typeIdsResolved = null;
+function workingDocumentTypeIds() {
+  if (!typeIdsPromise) {
+    typeIdsPromise = (async () => {
+      const { data, error } = await supabase.schema("platform").from("categories").select("id, slug").eq("dimension", "document_type").in("slug", [TYPE_SLUG.working, TYPE_SLUG.scratch]).is("deleted_at", null);
+      if (error) {
+        typeIdsPromise = null;
+        throw new Error(
+          `[working-document] document types read failed: ${error.message}`
+        );
+      }
+      const bySlug = new Map(
+        (data ?? []).map((r) => [r.slug, r.id])
+      );
+      const working = bySlug.get(TYPE_SLUG.working);
+      const scratch = bySlug.get(TYPE_SLUG.scratch);
+      if (!working || !scratch) {
+        typeIdsPromise = null;
+        throw new Error(
+          "[working-document] the content store has no Working document / Scratch type."
+        );
+      }
+      typeIdsResolved = { working, scratch };
+      return typeIdsResolved;
+    })();
+  }
+  return typeIdsPromise;
+}
+function kindForTypeId(typeId) {
+  return typeIdsResolved?.scratch === typeId ? "scratch" : "working";
+}
+const WD = () => supabase.schema("content").from("document");
 function getWorkingDocumentAccess(documentId) {
-  return resolveResourceAccess(supabase, "working_document", documentId);
+  return resolveResourceAccess(supabase, WORKING_DOCUMENT_ENTITY, documentId);
 }
 async function getCxWorkingDocumentById(documentId) {
-  const { data, error } = await WD().select("*").eq("id", documentId).is("deleted_at", null).maybeSingle();
+  await workingDocumentTypeIds();
+  const { data, error } = await WD().select(WD_COLUMNS).eq("id", documentId).is("deleted_at", null).maybeSingle();
   if (error) {
     throw new Error(`[working-document] get by id failed: ${error.message}`);
   }
   return data ? rowToCxWorkingDocument(data) : null;
 }
 async function updateCxWorkingDocumentTitle(id, title) {
-  const { data, error } = await WD().update({ title }).eq("id", id).select("*").single();
+  await workingDocumentTypeIds();
+  const { data, error } = await WD().update({ title }).eq("id", id).select(WD_COLUMNS).single();
   if (error || !data) {
     throw new Error(
       `[working-document] title update failed: ${error?.message ?? "no row"}`
@@ -39,7 +79,8 @@ async function updateCxWorkingDocumentTitle(id, title) {
   return rowToCxWorkingDocument(data);
 }
 async function updateCxWorkingDocumentContent(id, content) {
-  const { data, error } = await WD().update({ content }).eq("id", id).select("*").single();
+  await workingDocumentTypeIds();
+  const { data, error } = await WD().update({ body: content }).eq("id", id).select(WD_COLUMNS).single();
   if (error || !data) {
     throw new Error(
       `[working-document] content update failed: ${error?.message ?? "no row"}`
@@ -48,17 +89,18 @@ async function updateCxWorkingDocumentContent(id, content) {
   return rowToCxWorkingDocument(data);
 }
 async function commitWorkingDocumentContent(id, content, baseVersion) {
+  await workingDocumentTypeIds();
   const result = await guardedUpdate({
     expectedVersion: baseVersion,
     applyUpdate: async ({ expectedVersion, nextVersion }) => {
-      const { data, error } = await WD().update({ content, version: nextVersion }).eq("id", id).eq("version", expectedVersion).select("*").maybeSingle();
+      const { data, error } = await WD().update({ body: content, version: nextVersion }).eq("id", id).eq("version", expectedVersion).select(WD_COLUMNS).maybeSingle();
       if (error) {
         throw new Error(`[working-document] commit failed: ${error.message}`);
       }
       return { data, error: null };
     },
     fetchCurrent: async () => {
-      const { data, error } = await WD().select("*").eq("id", id).is("deleted_at", null).maybeSingle();
+      const { data, error } = await WD().select(WD_COLUMNS).eq("id", id).is("deleted_at", null).maybeSingle();
       if (error) {
         throw new Error(
           `[working-document] get by id failed: ${error.message}`
@@ -87,11 +129,7 @@ async function currentUserId() {
   } = await getClaimsUser(supabase);
   return user?.id ?? null;
 }
-const WD_GRANT_SPELLINGS = [
-  "working_document",
-  "working_documents",
-  "workbench.working_documents"
-];
+const WD_GRANT_SPELLINGS = [WORKING_DOCUMENT_ENTITY, "content.document"];
 async function listGrantedDocumentIds(uid) {
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   const { data, error } = await supabase.schema("iam").from("permissions").select("resource_id, status, expires_at").in("resource_type", WD_GRANT_SPELLINGS).eq("granted_to_user_id", uid).or("status.is.null,status.neq.rejected").or(`expires_at.is.null,expires_at.gt.${nowIso}`);
@@ -105,7 +143,8 @@ async function listGrantedDocumentIds(uid) {
 async function listUserDocuments(kind, limit = 50, scope = "mine") {
   const uid = await currentUserId();
   if (!uid) return [];
-  let query = WD().select("*").eq("kind", kind).is("deleted_at", null).order("updated_at", { ascending: false }).limit(limit);
+  const typeIds = await workingDocumentTypeIds();
+  let query = WD().select(WD_COLUMNS).eq("document_type_id", typeIds[kind]).is("deleted_at", null).order("updated_at", { ascending: false }).limit(limit);
   if (scope === "mine") {
     query = query.eq("created_by", uid);
   } else {
@@ -122,7 +161,8 @@ async function listUserDocuments(kind, limit = 50, scope = "mine") {
 async function listRecentUserDocuments(limit = 100) {
   const uid = await currentUserId();
   if (!uid) return [];
-  const { data, error } = await WD().select("id, metadata, kind, title, content, updated_at").eq("created_by", uid).is("deleted_at", null).order("updated_at", { ascending: false }).limit(limit);
+  const typeIds = await workingDocumentTypeIds();
+  const { data, error } = await WD().select("id, metadata, document_type_id, title, preview, updated_at").in("document_type_id", [typeIds.working, typeIds.scratch]).eq("created_by", uid).is("deleted_at", null).order("updated_at", { ascending: false }).limit(limit);
   if (error) {
     throw new Error(`[working-document] list recent failed: ${error.message}`);
   }
@@ -131,9 +171,9 @@ async function listRecentUserDocuments(limit = 100) {
     // Origin lives in metadata.origin_conversation_id (the legacy
     // conversation_id column was dropped in STEP 3).
     conversationId: row.metadata?.origin_conversation_id ?? null,
-    kind: row.kind ?? "working",
+    kind: kindForTypeId(row.document_type_id),
     title: row.title,
-    preview: (row.content ?? "").trim().slice(0, 200),
+    preview: (row.preview ?? "").trim().slice(0, 200),
     updatedAt: row.updated_at
   }));
 }
@@ -148,19 +188,26 @@ function materializeWorkingDocument(args) {
   return promise;
 }
 async function materializeWorkingDocumentImpl(args) {
+  const typeIds = await workingDocumentTypeIds();
   const { data, error } = await WD().upsert(
     {
       id: args.id,
       organization_id: args.organizationId,
-      kind: args.kind,
+      document_type_id: typeIds[args.kind],
+      format: "markdown",
+      visibility: "personal",
       title: args.title,
-      content: args.content,
+      body: args.content,
       metadata: {
         origin_conversation_id: args.conversationId
       }
+      // content_hash and data_class are derived by the database (the derive
+      // trigger and the per-type class floor); the generated Insert type
+      // lists them as required, so the row is passed as the canonical
+      // content-store writers pass it (features/rich-document createDocument).
     },
     { onConflict: "id" }
-  ).select("*").single();
+  ).select(WD_COLUMNS).single();
   if (error || !data) {
     throw new Error(
       `[working-document] materialize failed: ${error?.message ?? "no row"}`
@@ -179,7 +226,7 @@ function edgeMetadata(kind, enabled) {
 }
 async function linkDocumentToConversation(args) {
   const res = await associationsService.add({
-    sourceType: "working_document",
+    sourceType: WORKING_DOCUMENT_ENTITY,
     sourceId: args.documentId,
     targetType: "conversation",
     targetId: args.conversationId,
@@ -194,7 +241,7 @@ async function linkDocumentToConversation(args) {
 }
 async function unlinkDocumentFromConversation(documentId, conversationId) {
   const res = await associationsService.remove({
-    sourceType: "working_document",
+    sourceType: WORKING_DOCUMENT_ENTITY,
     sourceId: documentId,
     targetType: "conversation",
     targetId: conversationId
@@ -223,7 +270,7 @@ async function listConversationDocuments(conversationId) {
       `[working-document] list links failed: ${res.error.message ?? res.error.code}`
     );
   }
-  return res.data.edges.filter((e) => e.sourceType === "working_document").map((e) => {
+  return res.data.edges.filter((e) => e.sourceType === WORKING_DOCUMENT_ENTITY).map((e) => {
     const meta = e.metadata ?? {};
     return {
       documentId: e.sourceId,
@@ -234,7 +281,7 @@ async function listConversationDocuments(conversationId) {
 }
 async function listDocumentConversations(documentId) {
   const res = await associationsService.listForSources(
-    "working_document",
+    WORKING_DOCUMENT_ENTITY,
     [documentId],
     "conversation"
   );
@@ -245,53 +292,54 @@ async function listDocumentConversations(documentId) {
   }
   return res.data.edges.map((e) => e.targetId);
 }
-const WORKING_DOCUMENT_TOKEN = "working_document";
 async function listWorkingDocumentVersions(documentId, limit = 50) {
-  const { data, error } = await supabase.rpc("version_list", {
-    p_token: WORKING_DOCUMENT_TOKEN,
-    p_id: documentId,
-    p_limit: limit
-  });
+  const { data, error } = await supabase.schema("content").rpc("version_list", { p_document_id: documentId, p_limit: limit });
   if (error) {
     throw new Error(`[working-document] version_list failed: ${error.message}`);
   }
-  return (data ?? []).map((r) => ({
-    version: r.version,
-    operation: r.operation,
+  const rows = data ?? [];
+  const newest = rows.reduce((m, r) => Math.max(m, r.content_version), 0);
+  return rows.map((r) => ({
+    version: r.content_version,
+    operation: r.change_kind,
     actorId: r.actor_id ?? null,
-    occurredAt: r.occurred_at,
-    isCurrent: r.is_current
+    occurredAt: r.created_at,
+    isCurrent: r.content_version === newest
   }));
 }
 async function getWorkingDocumentVersionContent(documentId, version) {
-  const { data, error } = await supabase.rpc("version_snapshot", {
-    p_token: WORKING_DOCUMENT_TOKEN,
-    p_id: documentId,
-    p_version: version
+  const { data, error } = await supabase.schema("content").rpc("version_get", {
+    p_document_id: documentId,
+    p_content_version: version
   });
   if (error) {
-    throw new Error(
-      `[working-document] version_snapshot failed: ${error.message}`
-    );
+    throw new Error(`[working-document] version_get failed: ${error.message}`);
   }
-  const content = data?.content;
-  return typeof content === "string" ? content : null;
+  const row = Array.isArray(data) ? data[0] : data;
+  return typeof row?.body === "string" ? row.body : null;
 }
 async function restoreWorkingDocumentVersion(documentId, version) {
-  const { data, error } = await supabase.rpc("version_restore", {
-    p_token: WORKING_DOCUMENT_TOKEN,
-    p_id: documentId,
-    p_version: version
+  const { data: current, error: readError } = await WD().select("version").eq("id", documentId).maybeSingle();
+  if (readError || !current) {
+    throw new Error(
+      `[working-document] restore read failed: ${readError?.message ?? "no row"}`
+    );
+  }
+  const { data, error } = await supabase.schema("content").rpc("version_restore", {
+    p_document_id: documentId,
+    p_content_version: version,
+    p_expected_version: current.version
   });
   if (error) {
     throw new Error(
       `[working-document] version_restore failed: ${error.message}`
     );
   }
-  return data;
+  const row = Array.isArray(data) ? data[0] : data;
+  return row?.content_version ?? version;
 }
 export {
-  WORKING_DOCUMENT_TOKEN,
+  WORKING_DOCUMENT_ENTITY,
   commitWorkingDocumentContent,
   getCxWorkingDocumentById,
   getWorkingDocumentAccess,
@@ -309,5 +357,6 @@ export {
   softDeleteWorkingDocument,
   unlinkDocumentFromConversation,
   updateCxWorkingDocumentContent,
-  updateCxWorkingDocumentTitle
+  updateCxWorkingDocumentTitle,
+  workingDocumentTypeIds
 };

package/dist/agents/redux/execution-system/instance-working-document/instance-working-document.slice.d.ts

@@ -19,7 +19,7 @@
  * - `content`  — canonical document text shared by every mount.
  * - `binding`  — durable source. `{ kind: "none" }` = ephemeral;
  *                `{ kind: "cx_working_document", id }` = a row in
- *                `cx_working_documents` (the chat default); `{ kind: "note" }`
+ *                `content.document` (the chat default); `{ kind: "note" }`
  *                = a `workbench.notes` row (working kind only); `studio_document`
  *                = Scribe's source (shared context-value builder).
  * - `saving`   — true while a bound-source persist is in flight.
@@ -56,7 +56,7 @@ export declare function workingDocKey(conversationId: string, kind?: WorkingDocu
  * Durable source the document is bound to.
  *   - "none"               — ephemeral (Redux only).
  *   - "note"               — a `workbench.notes` row (working kind only).
- *   - "cx_working_document"— a `workbench.working_documents` row: the durable,
+ *   - "cx_working_document"— a `content.document` row: the durable,
  *                            conversation-scoped default backing. The agent's
  *                            ctx_patch edits persist here (working kind) and
  *                            round-trip back via Supabase realtime.

package/dist/agents/redux/execution-system/instance-working-document/instance-working-document.thunks.d.ts

@@ -5,7 +5,7 @@
  * scratch). MATERIALIZE-ON-WRITE model:
  *
  *   - Enabling a document only RESERVES a client id (binding) — no DB row. The
- *     durable `workbench.working_documents` row is created on the FIRST byte of
+ *     durable `content.document` row is created on the FIRST byte of
  *     content, by whichever party writes first
  *     (`materializeWorkingDocumentThunk` for the user; the server's writeback
  *     for the agent, reflected via the stream). The separate association edge

package/dist/agents/redux/execution-system/instance-working-document/scratchpad.thunks.d.ts

@@ -1,7 +1,7 @@
 /**
  * Scratchpad thunks — the USER-GLOBAL scratchpad pool.
  *
- * Scratchpads are the user's personal notepads: `workbench.working_documents`
+ * Scratchpads are the user's personal notepads: `content.document`
  * rows (kind "scratch") owned by the user, DECOUPLED from conversations. One is
  * ACTIVE at all times (`userPreferences.scratchpad.activeId`, synced
  * cross-device); the active one is published read-only into a conversation's

package/dist/agents/redux/execution-system/message-crud/refetch-single-message.thunk.js

@@ -3,6 +3,7 @@ import { supabase } from "../../../../host/db.js";
 import { updateMessageRecord } from "../messages/messages.slice.js";
 import { messageRowToRecord } from "../thunks/conversation-bundle.js";
 import { durableRecordId } from "@ai-matrx/kit/ids";
+import { isSignedOutVisitor } from "../../../../host/identity.js";
 function hasDisplayableMessageContent(value) {
   if (!Array.isArray(value)) return false;
   return value.some((part) => {
@@ -27,6 +28,9 @@ const refetchSingleMessage = createAsyncThunk(
         message: "This answer has no saved copy yet \u2014 nothing to reload."
       });
     }
+    if (await isSignedOutVisitor()) {
+      return { conversationId, messageId, found: false, refreshed: false };
+    }
     const read = () => {
       const byId = supabase.schema("chat").from("message").select("*").eq("id", messageId);
       const scoped = persistedConversationId ? byId.eq("conversation_id", persistedConversationId) : byId;
@@ -35,6 +39,7 @@ const refetchSingleMessage = createAsyncThunk(
     let result = await read();
     let delay = 250;
     for (let attempt = 0; waitForReadable && attempt < 7; attempt++) {
+      if (result.error) break;
       const hasBody = hasDisplayableMessageContent(
         result.data?.user_content ?? result.data?.content
       );

package/dist/agents/redux/execution-system/thunks/process-stream.js

@@ -111,7 +111,7 @@ import { docKindForContextKey } from "../../../utils/workingDocumentContext.js";
 import { isCanvasItemContextKey } from "../../../utils/canvasItemContext.js";
 import { StreamingJsonTracker } from "@ai-matrx/kit/json-extract";
 import { StreamBlockAccumulator } from "../utils/stream-block-accumulator.js";
-import { deriveAnswerText } from "../active-requests/active-requests.selectors.js";
+import { deriveAnswerDataText } from "../active-requests/active-requests.selectors.js";
 import { captureError } from "../../../../host/diagnostics.js";
 import { readReceiptThread, withReceiptHandle } from "../instance-resources/remark-handles.js";
 import { stampPersistedRemarkHandles } from "../message-crud/stamp-remark-handles.thunk.js";
@@ -351,7 +351,7 @@ async function processStream({
   const runJsonExtraction = (isFinal) => {
     if (!jsonTracker) return;
     const req = getState().activeRequests.byRequestId[requestId];
-    const answerText = req ? deriveAnswerText(req) : "";
+    const answerText = req ? deriveAnswerDataText(req, blockAccumulator.getWrapperSplitSources()) : "";
     if (!reasoningLeakReported && hasReasoningLeak(answerText)) {
       reasoningLeakReported = true;
       captureError({

package/dist/agents/redux/execution-system/utils/stream-block-accumulator.d.ts

@@ -38,6 +38,15 @@ export declare class StreamBlockAccumulator {
      * to be a different typed block (see the bare-JSON duplication note there).
      */
     private currentBlockEmitted;
+    /**
+     * THE DATA KEEPS ITS KINDS. A JSON wrapper that holds kinds is drawn as its
+     * kinds plus a residual (A7) — the residual is the wrapper's data WITH ITS
+     * KINDS REMOVED, so it is a display projection, never the answer. Every
+     * such split remembers the bytes it was cut from, keyed by its first block
+     * index, so data capture (`deriveAnswerDataText`) reads what the model wrote.
+     * Live only; a rewind forgets every split at or past its boundary.
+     */
+    private wrapperSplits;
     private subState;
     /**
      * URL + label for the current `audio` block. The accumulator's single-line
@@ -148,6 +157,11 @@ export declare class StreamBlockAccumulator {
      * the local streaming state so the replacement provider attempt cannot
      * concatenate onto or resurrect the failed attempt.
      */
+    /** The source bytes behind every live A7 wrapper split (see `wrapperSplits`). */
+    getWrapperSplitSources(): Array<{
+        blockIds: string[];
+        source: string;
+    }>;
     rewindToBlockCount(blockCount: number): void;
     /**
      * Close the current text block at an interleaved-content boundary — a tool

package/dist/agents/redux/execution-system/utils/stream-block-accumulator.js

@@ -321,6 +321,15 @@ class StreamBlockAccumulator {
    * to be a different typed block (see the bare-JSON duplication note there).
    */
   currentBlockEmitted = false;
+  /**
+   * THE DATA KEEPS ITS KINDS. A JSON wrapper that holds kinds is drawn as its
+   * kinds plus a residual (A7) — the residual is the wrapper's data WITH ITS
+   * KINDS REMOVED, so it is a display projection, never the answer. Every
+   * such split remembers the bytes it was cut from, keyed by its first block
+   * index, so data capture (`deriveAnswerDataText`) reads what the model wrote.
+   * Live only; a rewind forgets every split at or past its boundary.
+   */
+  wrapperSplits = /* @__PURE__ */ new Map();
   subState = { kind: "none" };
   /**
    * URL + label for the current `audio` block. The accumulator's single-line
@@ -524,7 +533,19 @@ ${this.pendingLineFragment}` : this.pendingLineFragment
    * the local streaming state so the replacement provider attempt cannot
    * concatenate onto or resurrect the failed attempt.
    */
+  /** The source bytes behind every live A7 wrapper split (see `wrapperSplits`). */
+  getWrapperSplitSources() {
+    return [...this.wrapperSplits.values()].map((split) => ({
+      blockIds: split.indices.map((i) => `client_block_${i}`),
+      source: split.source
+    }));
+  }
   rewindToBlockCount(blockCount) {
+    for (const [start, split] of this.wrapperSplits) {
+      if (start >= blockCount || split.indices.some((i) => i >= blockCount)) {
+        this.wrapperSplits.delete(start);
+      }
+    }
     this.irDisposeAll();
     this.currentBlockIndex = Math.max(0, blockCount);
     this.currentBlockType = "text";
@@ -1769,6 +1790,9 @@ ${this.currentBlockContent}
     const containerMetadata = genericXml || recoveredXmlContainer ? { genericXmlContainer: true } : void 0;
     let emitted = 0;
     let followsKind = false;
+    const splitStart = this.currentBlockIndex;
+    const splitIndices = [];
+    const isWrapperSplit = pieces.some((piece) => piece.type === "residual");
     for (const piece of pieces) {
       if (piece.type === "chrome") continue;
       const isKind = piece.type === "kind";
@@ -1788,9 +1812,13 @@ ${this.currentBlockContent}
         metadata: asJson ? withIrEnvelope(content, void 0) : containerMetadata
       };
       dispatch(this.upsertAction({ requestId: this.requestId, block }));
+      splitIndices.push(this.currentBlockIndex);
       emitted++;
       this.emitCount++;
     }
+    if (isWrapperSplit && emitted > 0) {
+      this.wrapperSplits.set(splitStart, { indices: splitIndices, source: recoverySource });
+    }
     this.currentBlockEmitted = emitted > 0;
     return emitted > 0;
   }

package/dist/agents/utils/platform-keys.d.ts

@@ -0,0 +1,15 @@
+/**
+ * platform-keys — which platform the person is on, and the undo/redo shortcut hints for it.
+ * Shared by the run-side input undo (useInstanceInputUndoRedo) and the agent builder's
+ * own undo hook (matrx-frontend features/agents/hooks/useAgentUndoRedo).
+ */
+export type Platform = "mac" | "windows" | "ios" | "android" | "linux" | "unknown";
+export declare function getPlatform(): Platform;
+export declare function isMacLike(): boolean;
+export declare function isTouchDevice(): boolean;
+/**
+ * Returns a human-readable shortcut hint string for the current platform.
+ * Examples: "⌘Z" on Mac, "Ctrl+Z" on Windows, "Shake" on iOS.
+ */
+export declare function getUndoShortcutHint(): string;
+export declare function getRedoShortcutHint(): string;

package/dist/agents/utils/platform-keys.js

@@ -0,0 +1,69 @@
+let _cachedPlatform = null;
+function getPlatform() {
+  if (_cachedPlatform) return _cachedPlatform;
+  if (typeof navigator === "undefined") return "unknown";
+  const ua = navigator.userAgent.toLowerCase();
+  if (/iphone|ipad|ipod/.test(ua)) {
+    _cachedPlatform = "ios";
+  } else if (/android/.test(ua)) {
+    _cachedPlatform = "android";
+  } else if (/mac/.test(ua)) {
+    _cachedPlatform = "mac";
+  } else if (/win/.test(ua)) {
+    _cachedPlatform = "windows";
+  } else if (/linux/.test(ua)) {
+    _cachedPlatform = "linux";
+  } else {
+    _cachedPlatform = "unknown";
+  }
+  return _cachedPlatform;
+}
+function isMacLike() {
+  const p = getPlatform();
+  return p === "mac" || p === "ios";
+}
+function isTouchDevice() {
+  const p = getPlatform();
+  return p === "ios" || p === "android";
+}
+function getUndoShortcutHint() {
+  const p = getPlatform();
+  switch (p) {
+    case "mac":
+      return "\u2318Z";
+    case "ios":
+      return "Shake to Undo";
+    case "android":
+      return "Ctrl+Z";
+    case "windows":
+      return "Ctrl+Z";
+    case "linux":
+      return "Ctrl+Z";
+    default:
+      return "Ctrl+Z";
+  }
+}
+function getRedoShortcutHint() {
+  const p = getPlatform();
+  switch (p) {
+    case "mac":
+      return "\u21E7\u2318Z";
+    case "ios":
+      return "Shake to Redo";
+    case "android":
+      return "Ctrl+Shift+Z";
+    case "windows":
+      return "Ctrl+Y";
+    case "linux":
+      return "Ctrl+Shift+Z";
+    default:
+      return "Ctrl+Shift+Z";
+  }
+}
+export {
+  getPlatform,
+  getRedoShortcutHint,
+  getUndoShortcutHint,
+  isMacLike,
+  isTouchDevice
+};

package/dist/context/sources/scopes.d.ts

@@ -20,7 +20,7 @@ import type { ComponentType } from "react";
 import type { AssociationSourceEdge, AssociationTargetEdge } from "@ai-matrx/associations";
 import type { ChatDatabase, Json } from "../../host/db-types.js";
 import { type AnyComponent, type AnyFn } from "../../host/registered-source.js";
-export type ContextItemRow = ChatDatabase["context"]["Tables"]["context_items"]["Row"];
+export type ContextItemRow = ChatDatabase["deprecated"]["Tables"]["context_items"]["Row"];
 export type ContextItemValueType = ChatDatabase["public"]["Enums"]["context_value_type"];
 export type ContextValueType = ContextItemValueType;
 export interface ScopeNode {

package/dist/cx-chat/components/user-input/ConversationInput.js

@@ -53,7 +53,7 @@ import { useTouchOnlyDevice } from "../../../ui/composer/useTouchOnlyDevice.js";
 import {
   composerKeyIntent,
   intentTakesTheKey
-} from "../../../ui/composer/composerSubmit.js";
+} from "@ai-matrx/kit/composer-keys";
 import { Button } from "@ai-matrx/design-system/controls";
 function uploadMimeToBlockType(mime) {
   return mime.startsWith("image/") ? "image" : "document";

package/dist/cx-conversation/ConversationInput.js

@@ -64,7 +64,7 @@ import { useTouchOnlyDevice } from "../ui/composer/useTouchOnlyDevice.js";
 import {
   composerKeyIntent,
   intentTakesTheKey
-} from "../ui/composer/composerSubmit.js";
+} from "@ai-matrx/kit/composer-keys";
 import { Button } from "@ai-matrx/design-system/controls";
 function ConversationInput({
   sessionId,