@agent-native/core 0.77.10 → 0.77.11

package/corpus/README.md

@@ -28,4 +28,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 ## Generated Counts
 
 - core files: 1933
-- template files: 4293
+- template files: 4302

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @agent-native/core
 
+## 0.77.11
+
+### Patch Changes
+
+- 7560a7c: Clear collaborative awareness state immediately when an editor leaves a document.
+
 ## 0.77.10
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.77.10",
+  "version": "0.77.11",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -211,8 +211,8 @@
     "@react-router/dev": "^8.0.1",
     "@react-router/fs-routes": "^8.0.1",
     "@resvg/resvg-js": "^2.6.2",
-    "@sentry/browser": "^10.61.0",
-    "@sentry/node": "^10.61.0",
+    "@sentry/browser": "10.60.0",
+    "@sentry/node": "10.60.0",
     "@standard-schema/spec": "^1.1.0",
     "@tanstack/react-table": "^8.21.3",
     "@tiptap/core": "3.27.1",

package/corpus/core/src/collab/awareness.ts

@@ -102,7 +102,7 @@ function pruneIfEmpty(docId: string, map: Map<number, AwarenessEntry>): void {
  *
  * Client sends its awareness state and receives other clients' states.
  *
- * Body: { clientId: number, state: string (base64) }
+ * Body: { clientId: number, state: string | null (JSON-encoded awareness state, or null to clear) }
  * Response: { states: Array<{ clientId: number, state: string }> }
  */
 export const postAwareness = defineEventHandler(async (event: H3Event) => {
@@ -115,28 +115,31 @@ export const postAwareness = defineEventHandler(async (event: H3Event) => {
   const body = await readBody(event);
   const { clientId, state } = body as {
     clientId?: number;
-    state?: string;
+    state?: string | null;
   };
 
-  if (clientId == null || !state) {
+  if (clientId == null || state === undefined) {
     // `!clientId` would wrongly reject clientId === 0, which is a valid
-    // (if rare) Yjs client id. Only reject missing/null ids here.
+    // (if rare) Yjs client id. A null state is valid: it clears this client.
     setResponseStatus(event, 400);
     return { error: "clientId and state required" };
   }
 
   const map = getDocAwareness(docId);
 
-  // Store this client's state
-  map.set(clientId, { clientId, state, lastSeen: Date.now() });
+  if (state === null) {
+    map.delete(clientId);
+  } else {
+    // Store this client's state
+    map.set(clientId, { clientId, state, lastSeen: Date.now() });
+  }
 
   // Clean expired entries, then prune the outer-map entry if it becomes empty.
   // Without pruning, a deployment with many transient docIds (e.g. one per
   // session) would grow _awarenessMap without bound.
   cleanExpired(map);
-  // map has at least the sender's entry so size >= 1 here; pruneIfEmpty is a
-  // no-op in the normal path but guards against edge cases (e.g. clientId 0
-  // that was immediately evicted by a concurrent cleanExpired run).
+  // Null-state clears and expiry can empty the map; prune the outer entry so
+  // transient document ids do not accumulate.
   pruneIfEmpty(docId, map);
 
   // Build the full list of current states (all clients including sender).

package/corpus/core/src/collab/client.ts

@@ -276,11 +276,13 @@ function scheduleAwarenessPush(
   const timer = setTimeout(() => {
     _awarenessThrottleTimers.delete(key);
     const state = getState();
-    if (!state) return;
     fetch(`${baseUrl}/${docId}/awareness`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ clientId, state: JSON.stringify(state) }),
+      body: JSON.stringify({
+        clientId,
+        state: state ? JSON.stringify(state) : null,
+      }),
     }).catch(() => {}); // best-effort; poll cycle is the baseline fallback
   }, 150);
 

package/corpus/templates/clips/chrome-extension/package.json

@@ -11,7 +11,7 @@
     "package": "pnpm build && tsx scripts/package.ts"
   },
   "dependencies": {
-    "@sentry/browser": "^10.61.0"
+    "@sentry/browser": "10.60.0"
   },
   "devDependencies": {
     "@types/chrome": "^0.2.0",

package/corpus/templates/content/actions/list-trashed-content-databases.ts

@@ -1,6 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { accessFilter } from "@agent-native/core/sharing";
-import { and, desc, eq, isNotNull } from "drizzle-orm";
+import { and, desc, eq, isNotNull, isNull, ne, or } from "drizzle-orm";
+import { alias } from "drizzle-orm/sqlite-core";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -14,6 +15,16 @@ export default defineAction({
   readOnly: true,
   run: async (): Promise<ListTrashedContentDatabasesResponse> => {
     const db = getDb();
+    const hostDocuments = alias(schema.documents, "host_documents");
+    const isBlockOwned = and(
+      isNotNull(schema.contentDatabases.ownerDocumentId),
+      eq(schema.documents.parentId, schema.contentDatabases.ownerDocumentId),
+    );
+    const isNotBlockOwned = or(
+      isNull(schema.contentDatabases.ownerDocumentId),
+      isNull(schema.documents.parentId),
+      ne(schema.documents.parentId, schema.contentDatabases.ownerDocumentId),
+    );
     const rows = await db
       .select({
         databaseId: schema.contentDatabases.id,
@@ -28,10 +39,33 @@ export default defineAction({
         schema.documents,
         eq(schema.documents.id, schema.contentDatabases.documentId),
       )
+      .leftJoin(
+        hostDocuments,
+        eq(hostDocuments.id, schema.contentDatabases.ownerDocumentId),
+      )
       .where(
         and(
           isNotNull(schema.contentDatabases.deletedAt),
-          accessFilter(schema.documents, schema.documentShares),
+          or(
+            and(
+              isBlockOwned,
+              accessFilter(
+                hostDocuments,
+                schema.documentShares,
+                undefined,
+                "editor",
+              ),
+            ),
+            and(
+              isNotBlockOwned,
+              accessFilter(
+                schema.documents,
+                schema.documentShares,
+                undefined,
+                "admin",
+              ),
+            ),
+          ),
         ),
       )
       .orderBy(desc(schema.contentDatabases.deletedAt));

package/corpus/templates/content/actions/move-document.ts

@@ -1,6 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
-import { assertAccess } from "@agent-native/core/sharing";
+import { assertAccess, type Visibility } from "@agent-native/core/sharing";
 import { and, eq, sql } from "drizzle-orm";
 import { z } from "zod";
 
@@ -54,19 +54,17 @@ async function assertParentIsNotDescendant({
   }
 }
 
-async function clearBlockDatabaseOwnershipAfterParentChange({
+async function preflightBlockDatabaseOwnershipClearance({
   db,
   documentId,
   ownerEmail,
   parentId,
-  updatedAt,
 }: {
   db: ReturnType<typeof getDb>;
   documentId: string;
   ownerEmail: string;
   parentId: string | null;
-  updatedAt: string;
-}) {
+}): Promise<string | null> {
   const [database] = await db
     .select({
       id: schema.contentDatabases.id,
@@ -81,11 +79,24 @@ async function clearBlockDatabaseOwnershipAfterParentChange({
     );
 
   if (!database?.ownerDocumentId || database.ownerDocumentId === parentId) {
-    return;
+    return null;
   }
 
   await assertAccess("document", database.ownerDocumentId, "editor");
+  return database.id;
+}
 
+async function clearBlockDatabaseOwnership({
+  db,
+  databaseId,
+  ownerEmail,
+  updatedAt,
+}: {
+  db: Pick<ReturnType<typeof getDb>, "update">;
+  databaseId: string;
+  ownerEmail: string;
+  updatedAt: string;
+}) {
   await db
     .update(schema.contentDatabases)
     .set({
@@ -95,23 +106,44 @@ async function clearBlockDatabaseOwnershipAfterParentChange({
     })
     .where(
       and(
-        eq(schema.contentDatabases.id, database.id),
+        eq(schema.contentDatabases.id, databaseId),
         eq(schema.contentDatabases.ownerEmail, ownerEmail),
       ),
     );
 }
 
+function sameRootSection(
+  left: { visibility: Visibility; orgId?: string | null },
+  right: { visibility: Visibility; orgId?: string | null },
+) {
+  return left.visibility === right.visibility && left.orgId === right.orgId;
+}
+
+function rootSectionFilter(document: {
+  visibility: Visibility;
+  orgId?: string | null;
+}) {
+  return and(
+    eq(schema.documents.visibility, document.visibility),
+    document.orgId
+      ? eq(schema.documents.orgId, document.orgId)
+      : sql`${schema.documents.orgId} IS NULL`,
+  );
+}
+
 async function resolveSiblingPositionsAfterMove({
   db,
   ownerEmail,
   id,
   parentId,
+  rootSection,
   position,
 }: {
   db: ReturnType<typeof getDb>;
   ownerEmail: string;
   id: string;
   parentId: string | null;
+  rootSection: { visibility: Visibility; orgId?: string | null };
   position: number;
 }) {
   const siblings = await db
@@ -129,6 +161,7 @@ async function resolveSiblingPositionsAfterMove({
           )
         : and(
             eq(schema.documents.ownerEmail, ownerEmail),
+            rootSectionFilter(rootSection),
             sql`parent_id IS NULL`,
           ),
     );
@@ -209,6 +242,9 @@ export default defineAction({
         if (parentAccess.resource.ownerEmail !== ownerEmail) {
           throw new Error("Parent document must belong to the same owner");
         }
+        if (!sameRootSection(parentAccess.resource, existing)) {
+          throw new Error("Parent document must be in the same section");
+        }
         await assertParentIsNotDescendant({
           db,
           ownerEmail,
@@ -221,6 +257,15 @@ export default defineAction({
 
     const targetParentId =
       args.parentId !== undefined ? args.parentId : existing.parentId;
+    const blockDatabaseIdToDetach =
+      args.parentId !== undefined
+        ? await preflightBlockDatabaseOwnershipClearance({
+            db,
+            documentId: id,
+            ownerEmail,
+            parentId: args.parentId,
+          })
+        : null;
     const normalizedSiblingPositions =
       args.position !== undefined
         ? await resolveSiblingPositionsAfterMove({
@@ -228,6 +273,7 @@ export default defineAction({
             ownerEmail,
             id,
             parentId: targetParentId,
+            rootSection: existing,
             position: args.position,
           })
         : null;
@@ -249,36 +295,36 @@ export default defineAction({
               )
             : and(
                 eq(schema.documents.ownerEmail, ownerEmail),
+                rootSectionFilter(existing),
                 sql`parent_id IS NULL`,
               ),
         );
       updates.position = (maxPos[0]?.max ?? -1) + 1;
     }
 
-    await db
-      .update(schema.documents)
-      .set(updates)
-      .where(
-        and(
-          eq(schema.documents.id, id),
-          eq(schema.documents.ownerEmail, ownerEmail),
-        ),
-      );
+    await db.transaction(async (tx) => {
+      await tx
+        .update(schema.documents)
+        .set(updates)
+        .where(
+          and(
+            eq(schema.documents.id, id),
+            eq(schema.documents.ownerEmail, ownerEmail),
+          ),
+        );
 
-    if (args.parentId !== undefined) {
-      await clearBlockDatabaseOwnershipAfterParentChange({
-        db,
-        documentId: id,
-        ownerEmail,
-        parentId: args.parentId,
-        updatedAt,
-      });
-    }
+      if (args.parentId !== undefined && blockDatabaseIdToDetach) {
+        await clearBlockDatabaseOwnership({
+          db: tx,
+          databaseId: blockDatabaseIdToDetach,
+          ownerEmail,
+          updatedAt,
+        });
+      }
 
-    if (normalizedSiblingPositions) {
-      await Promise.all(
-        normalizedSiblingPositions.map((document) =>
-          db
+      if (normalizedSiblingPositions) {
+        for (const document of normalizedSiblingPositions) {
+          await tx
             .update(schema.documents)
             .set({ position: document.position })
             .where(
@@ -286,10 +332,10 @@ export default defineAction({
                 eq(schema.documents.id, document.id),
                 eq(schema.documents.ownerEmail, ownerEmail),
               ),
-            ),
-        ),
-      );
-    }
+            );
+        }
+      }
+    });
 
     const [doc] = await db
       .select()

package/corpus/templates/content/actions/restore-content-database.ts

@@ -1,10 +1,37 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
+import { resolveAccess } from "@agent-native/core/sharing";
 import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
-import { assertContentDatabaseLifecycleAccess } from "./_content-database-lifecycle.js";
+import {
+  assertContentDatabaseLifecycleAccess,
+  collectInlineDatabaseOwnerBlockIds,
+} from "./_content-database-lifecycle.js";
+import pullDocumentAction from "./pull-document.js";
+
+async function shouldClearStaleInlineOwnership(args: {
+  ownerDocumentId: string | null;
+  ownerBlockId: string | null;
+}) {
+  if (!args.ownerDocumentId || !args.ownerBlockId) return false;
+  let content: string | null = null;
+  try {
+    const host = await pullDocumentAction.run({
+      id: args.ownerDocumentId,
+      format: "markdown",
+    });
+    content = String(host.content ?? "");
+  } catch {
+    const hostAccess = await resolveAccess("document", args.ownerDocumentId);
+    if (!hostAccess) return false;
+    content = String(hostAccess.resource.content ?? "");
+  }
+
+  const parsed = await collectInlineDatabaseOwnerBlockIds(content);
+  return parsed.ok && !parsed.ownerBlockIds.has(args.ownerBlockId);
+}
 
 export default defineAction({
   description: "Restore a soft-deleted content database.",
@@ -12,13 +39,23 @@ export default defineAction({
     databaseId: z.string().describe("Content database ID"),
   }),
   run: async ({ databaseId }) => {
-    await assertContentDatabaseLifecycleAccess(databaseId);
+    const ownership = await assertContentDatabaseLifecycleAccess(databaseId);
     const db = getDb();
     const now = new Date().toISOString();
+    const clearInlineOwnership = await shouldClearStaleInlineOwnership({
+      ownerDocumentId: ownership.database.ownerDocumentId,
+      ownerBlockId: ownership.database.ownerBlockId,
+    });
 
     await db
       .update(schema.contentDatabases)
-      .set({ deletedAt: null, updatedAt: now })
+      .set({
+        deletedAt: null,
+        updatedAt: now,
+        ...(clearInlineOwnership
+          ? { ownerDocumentId: null, ownerBlockId: null }
+          : {}),
+      })
       .where(eq(schema.contentDatabases.id, databaseId));
 
     await writeAppState("refresh-signal", { ts: Date.now() });

package/corpus/templates/content/app/components/editor/BubbleToolbar.tsx

@@ -11,10 +11,16 @@ import {
   IconH3,
   IconH4,
 } from "@tabler/icons-react";
-import { NodeSelection, type EditorState } from "@tiptap/pm/state";
+import {
+  NodeSelection,
+  Plugin,
+  PluginKey,
+  type EditorState,
+} from "@tiptap/pm/state";
+import { Decoration, DecorationSet } from "@tiptap/pm/view";
 import type { Editor } from "@tiptap/react";
 import { BubbleMenu } from "@tiptap/react/menus";
-import { useState } from "react";
+import { useEffect, useState } from "react";
 
 import {
   Tooltip,
@@ -44,6 +50,15 @@ const BUBBLE_TOOLBAR_EXCLUDED_NODE_TYPES = new Set([
   "localMdxComponent",
 ]);
 
+type SelectionFillRange = {
+  from: number;
+  to: number;
+};
+
+const selectionFillPluginKey = new PluginKey<SelectionFillRange | null>(
+  "contentSelectionFill",
+);
+
 function selectionIncludesBubbleToolbarExcludedNode(
   state: EditorState,
   from: number,
@@ -72,6 +87,73 @@ export function BubbleToolbar({ editor, onComment }: BubbleToolbarProps) {
   const [showLinkInput, setShowLinkInput] = useState(false);
   const [linkUrl, setLinkUrl] = useState("");
 
+  useEffect(() => {
+    const plugin = new Plugin<SelectionFillRange | null>({
+      key: selectionFillPluginKey,
+      state: {
+        init: () => null,
+        apply: (tr, value) => {
+          const meta = tr.getMeta(selectionFillPluginKey);
+          if (meta !== undefined) return meta;
+          return value
+            ? {
+                from: tr.mapping.map(value.from),
+                to: tr.mapping.map(value.to),
+              }
+            : null;
+        },
+      },
+      props: {
+        decorations(state) {
+          const range = selectionFillPluginKey.getState(state);
+          if (!range || range.from === range.to) return DecorationSet.empty;
+          return DecorationSet.create(state.doc, [
+            Decoration.inline(range.from, range.to, {
+              class: "notion-selection-fill",
+            }),
+          ]);
+        },
+      },
+    });
+
+    editor.registerPlugin(plugin);
+
+    const syncSelectionFill = () => {
+      const { state } = editor;
+      const { from, to } = state.selection;
+      const nextRange =
+        editor.isFocused &&
+        from !== to &&
+        !selectionIncludesBubbleToolbarExcludedNode(state, from, to)
+          ? { from, to }
+          : null;
+      const currentRange = selectionFillPluginKey.getState(state);
+      if (
+        currentRange?.from === nextRange?.from &&
+        currentRange?.to === nextRange?.to
+      ) {
+        return;
+      }
+      editor.view.dispatch(
+        state.tr
+          .setMeta(selectionFillPluginKey, nextRange)
+          .setMeta("addToHistory", false),
+      );
+    };
+
+    editor.on("selectionUpdate", syncSelectionFill);
+    editor.on("focus", syncSelectionFill);
+    editor.on("blur", syncSelectionFill);
+    syncSelectionFill();
+
+    return () => {
+      editor.off("selectionUpdate", syncSelectionFill);
+      editor.off("focus", syncSelectionFill);
+      editor.off("blur", syncSelectionFill);
+      editor.unregisterPlugin(selectionFillPluginKey);
+    };
+  }, [editor]);
+
   const handleSetLink = () => {
     if (linkUrl.trim()) {
       editor