@agent-native/core 0.136.5 → 0.137.1

package/corpus/templates/clips/app/components/library/library-layout.tsx

@@ -32,8 +32,6 @@ import {
   IconShare,
   IconSettings,
   IconSearch,
-  IconUpload,
-  IconLink,
 } from "@tabler/icons-react";
 import { ReactNode, useEffect, useMemo, useState } from "react";
 import { NavLink, useLocation, useParams } from "react-router";
@@ -43,6 +41,7 @@ import {
   CaptureInstallButton,
   CaptureInstallInlineLink,
 } from "@/components/capture-install-options";
+import { ImportMenu } from "@/components/import-menu";
 import {
   AlertDialog,
   AlertDialogAction,
@@ -400,34 +399,14 @@ export function LibraryLayout({ children }: LibraryLayoutProps) {
               </div>
 
               <div className="flex flex-col items-center gap-1 px-2">
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <NavLink
-                      to="/record?autoUpload=1"
-                      aria-label={t("preRecord.uploadVideo")}
-                      className="flex h-9 w-9 items-center justify-center rounded-md text-muted-foreground hover:bg-accent/60 hover:text-foreground"
-                    >
-                      <IconUpload className="h-4 w-4" />
-                    </NavLink>
-                  </TooltipTrigger>
-                  <TooltipContent side="right">
-                    {t("preRecord.uploadVideo")}
-                  </TooltipContent>
-                </Tooltip>
-                <Tooltip>
-                  <TooltipTrigger asChild>
-                    <NavLink
-                      to="/import"
-                      aria-label={t("preRecord.importLoom")}
-                      className="flex h-9 w-9 items-center justify-center rounded-md text-muted-foreground hover:bg-accent/60 hover:text-foreground"
-                    >
-                      <IconLink className="h-4 w-4" />
-                    </NavLink>
-                  </TooltipTrigger>
-                  <TooltipContent side="right">
-                    {t("preRecord.importLoom")}
-                  </TooltipContent>
-                </Tooltip>
+                <ImportMenu
+                  uploadHref="/record?autoUpload=1"
+                  importLoomHref="/import"
+                  iconOnly
+                  variant="ghost"
+                  menuSide="right"
+                  menuAlign="start"
+                />
               </div>
 
               <nav className="mt-3 flex flex-col items-center gap-1 px-2">
@@ -463,28 +442,13 @@ export function LibraryLayout({ children }: LibraryLayoutProps) {
                     {t("navigation.newRecording")}
                   </NavLink>
                 </Button>
-                <Button
-                  className="mt-1.5 w-full gap-1.5 text-muted-foreground"
+                <ImportMenu
+                  uploadHref="/record?autoUpload=1"
+                  importLoomHref="/import"
                   size="sm"
                   variant="ghost"
-                  asChild
-                >
-                  <NavLink to="/record?autoUpload=1">
-                    <IconUpload className="h-4 w-4" />
-                    {t("preRecord.uploadVideo")}
-                  </NavLink>
-                </Button>
-                <Button
-                  className="mt-1.5 w-full gap-1.5 text-muted-foreground"
-                  size="sm"
-                  variant="ghost"
-                  asChild
-                >
-                  <NavLink to="/import">
-                    <IconLink className="h-4 w-4" />
-                    {t("preRecord.importLoom")}
-                  </NavLink>
-                </Button>
+                  className="mt-1.5 w-full"
+                />
               </div>
 
               <nav className="mt-3 space-y-0.5 px-2">

package/corpus/templates/clips/app/components/library/sort-menu.tsx

@@ -7,6 +7,11 @@ import {
   DropdownMenuItem,
   DropdownMenuTrigger,
 } from "@/components/ui/dropdown-menu";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
 
 export type SortKey = "recent" | "views" | "oldest";
 
@@ -24,12 +29,21 @@ interface SortMenuProps {
 export function SortMenu({ value, onChange }: SortMenuProps) {
   return (
     <DropdownMenu>
-      <DropdownMenuTrigger asChild>
-        <Button variant="outline" size="sm" className="gap-1.5 h-9">
-          <IconArrowsSort className="h-3.5 w-3.5" />
-          <span className="text-xs">{LABELS[value]}</span>
-        </Button>
-      </DropdownMenuTrigger>
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <DropdownMenuTrigger asChild>
+            <Button
+              variant="outline"
+              size="icon"
+              className="h-9 w-9"
+              aria-label={LABELS[value]}
+            >
+              <IconArrowsSort className="h-3.5 w-3.5" />
+            </Button>
+          </DropdownMenuTrigger>
+        </TooltipTrigger>
+        <TooltipContent>{LABELS[value]}</TooltipContent>
+      </Tooltip>
       <DropdownMenuContent align="end" className="w-44">
         {(Object.keys(LABELS) as SortKey[]).map((key) => (
           <DropdownMenuItem

package/corpus/templates/clips/app/components/recorder/pre-record-panel.tsx

@@ -7,16 +7,14 @@ import {
   IconChevronDown,
   IconDeviceDesktop,
   IconDeviceScreen,
-  IconLink,
   IconMicrophone,
   IconPlayerRecord,
-  IconUpload,
   IconVideo,
 } from "@tabler/icons-react";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Link } from "react-router";
 
 import { CaptureInstallInlineLink } from "@/components/capture-install-options";
+import { ImportMenu } from "@/components/import-menu";
 import { Button } from "@/components/ui/button";
 import {
   Collapsible,
@@ -66,15 +64,14 @@ export interface PreRecordPanelProps {
   initialDisplaySurface?: DisplaySurface | null;
   /** Called when the user picks a local video file to upload. */
   onUpload?: (file: File) => void;
-  /** When set, shows an "Import Loom" link pointing at the dedicated
-   * Loom-import page instead of an inline import form. */
+  /** When set, includes an "Import Loom" option in the shared import menu. */
   importLoomHref?: string;
   onCancel?: () => void;
   busy?: boolean;
   cameraSize?: CameraBubbleSize;
   onCameraSizeChange?: (size: CameraBubbleSize) => void;
   /** Opens the file picker once on mount, e.g. when arriving from a
-   * dedicated "Upload video" entry point elsewhere in the app. */
+   * dedicated upload entry point elsewhere in the app. */
   autoOpenUpload?: boolean;
 }
 
@@ -924,34 +921,13 @@ export function PreRecordPanel({
 
         {(onUpload || importLoomHref) && (
           <>
-            <div
-              className={cn(
-                "grid gap-2",
-                onUpload && importLoomHref && "sm:grid-cols-2",
-              )}
-            >
-              {onUpload ? (
-                <button
-                  type="button"
-                  disabled={busy}
-                  onClick={() => fileInputRef.current?.click()}
-                  className="flex w-full cursor-pointer items-center justify-center gap-2 rounded-lg px-3 py-2 text-sm text-muted-foreground transition-colors hover:bg-muted hover:text-foreground disabled:cursor-not-allowed disabled:opacity-60"
-                >
-                  <IconUpload className="h-4 w-4" />
-                  {t("preRecord.uploadVideo")}
-                </button>
-              ) : null}
-
-              {importLoomHref ? (
-                <Link
-                  to={importLoomHref}
-                  className="flex w-full cursor-pointer items-center justify-center gap-2 rounded-lg px-3 py-2 text-sm text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
-                >
-                  <IconLink className="h-4 w-4" />
-                  {t("preRecord.importLoom")}
-                </Link>
-              ) : null}
-            </div>
+            <ImportMenu
+              onUpload={
+                onUpload ? () => fileInputRef.current?.click() : undefined
+              }
+              importLoomHref={importLoomHref}
+              disabled={busy}
+            />
 
             {onUpload ? (
               <input

package/corpus/templates/clips/app/routes/_app.library._index.tsx

@@ -1,5 +1,4 @@
 import { useT } from "@agent-native/core/client/i18n";
-import { IconPlayerRecord } from "@tabler/icons-react";
 import { NavLink } from "react-router";
 
 import { LibraryGrid } from "@/components/library/library-grid";
@@ -38,7 +37,6 @@ export default function LibraryIndexRoute() {
             asChild
           >
             <NavLink to="/record" aria-label={t("navigation.newRecording")}>
-              <IconPlayerRecord className="h-4 w-4" />
               <span className="hidden sm:inline">
                 {t("navigation.newRecording")}
               </span>

package/corpus/templates/clips/changelog/2026-08-04-cleaner-library-controls-with-an-icon-only-sort-button.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-04
+---
+
+Cleaner Library controls with a simpler New recording button and icon-only sort control

package/corpus/templates/clips/changelog/2026-08-04-upload-and-loom-imports-now-live-under-one-import-menu.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-08-04
+---
+
+Upload and Loom imports now live under one Import menu

package/corpus/templates/content/actions/_database-utils.ts

@@ -1399,6 +1399,9 @@ export async function deleteDatabaseDataForDocument(
     db,
   );
   if (database) {
+    await db
+      .delete(schema.contentDatabaseItemKeyClaims)
+      .where(eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id));
     const definitions = await db
       .select({ id: schema.documentPropertyDefinitions.id })
       .from(schema.documentPropertyDefinitions)
@@ -1464,6 +1467,9 @@ export async function deleteDatabaseDataForDocument(
     db,
   );
   if (item) {
+    await db
+      .delete(schema.contentDatabaseItemKeyClaims)
+      .where(eq(schema.contentDatabaseItemKeyClaims.documentId, documentId));
     await db
       .delete(schema.contentDatabaseBodyHydrationQueue)
       .where(

package/corpus/templates/content/actions/bind-content-database-source-field.ts

@@ -1,6 +1,6 @@
 import { defineAction } from "@agent-native/core";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq, inArray, ne } from "drizzle-orm";
+import { and, eq, inArray, isNull, ne, sql } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
@@ -8,7 +8,10 @@ import type {
   BindContentDatabaseSourceFieldRequest,
   ContentDatabaseResponse,
 } from "../shared/api.js";
-import { serializePropertyValue } from "../shared/properties.js";
+import {
+  serializePropertyValue,
+  type DocumentPropertyType,
+} from "../shared/properties.js";
 import { chunks } from "./_batch-utils.js";
 import { resolveDatabaseForSourceMutation } from "./_database-source-utils.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
@@ -71,40 +74,92 @@ export default defineAction({
 
     // ── Unbind ────────────────────────────────────────────────────────────
     if (args.propertyId === null) {
-      if (field.propertyId) {
-        const sourceRows = await db
-          .select({ documentId: schema.contentDatabaseSourceRows.documentId })
-          .from(schema.contentDatabaseSourceRows)
-          .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
-        const sourceDocumentIds = sourceRows
-          .map((row) => row.documentId)
-          .filter((id): id is string => Boolean(id));
-        if (sourceDocumentIds.length > 0) {
-          await db
-            .delete(schema.documentPropertyValues)
-            .where(
-              and(
-                eq(schema.documentPropertyValues.propertyId, field.propertyId),
-                inArray(
-                  schema.documentPropertyValues.documentId,
-                  sourceDocumentIds,
+      await db.transaction(async (tx) => {
+        const [lockedDatabase] = await tx
+          .update(schema.contentDatabases)
+          .set({ updatedAt: sql`${schema.contentDatabases.updatedAt}` })
+          .where(
+            and(
+              eq(schema.contentDatabases.id, database.id),
+              eq(schema.contentDatabases.ownerEmail, database.ownerEmail),
+              isNull(schema.contentDatabases.deletedAt),
+            ),
+          )
+          .returning({ id: schema.contentDatabases.id });
+        if (!lockedDatabase) throw new Error("Database is no longer active.");
+
+        const [lockedField] = await tx
+          .select()
+          .from(schema.contentDatabaseSourceFields)
+          .where(eq(schema.contentDatabaseSourceFields.id, field.id));
+        if (
+          !lockedField ||
+          lockedField.sourceId !== source.id ||
+          lockedField.mappingType === "title" ||
+          lockedField.mappingType === "system" ||
+          lockedField.writeOwner === "derived"
+        ) {
+          throw new Error(
+            "Source field changed or was deleted before it could be unbound.",
+          );
+        }
+        if (lockedField.propertyId) {
+          const sourceRows = await tx
+            .select({
+              documentId: schema.contentDatabaseSourceRows.documentId,
+            })
+            .from(schema.contentDatabaseSourceRows)
+            .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
+          const sourceDocumentIds = sourceRows
+            .map((row) => row.documentId)
+            .filter((id): id is string => Boolean(id));
+          if (sourceDocumentIds.length > 0) {
+            await tx
+              .delete(schema.documentPropertyValues)
+              .where(
+                and(
+                  eq(
+                    schema.documentPropertyValues.propertyId,
+                    lockedField.propertyId,
+                  ),
+                  inArray(
+                    schema.documentPropertyValues.documentId,
+                    sourceDocumentIds,
+                  ),
                 ),
-              ),
-            );
+              );
+          }
         }
-      }
-      await db
-        .update(schema.contentDatabaseSourceFields)
-        .set({
-          propertyId: null,
-          localFieldKey: field.sourceFieldKey,
-          updatedAt: now,
-        })
-        .where(eq(schema.contentDatabaseSourceFields.id, field.id));
-      await db
-        .update(schema.contentDatabaseSources)
-        .set({ updatedAt: now })
-        .where(eq(schema.contentDatabaseSources.id, source.id));
+        const [updatedField] = await tx
+          .update(schema.contentDatabaseSourceFields)
+          .set({
+            propertyId: null,
+            localFieldKey: lockedField.sourceFieldKey,
+            updatedAt: now,
+          })
+          .where(eq(schema.contentDatabaseSourceFields.id, lockedField.id))
+          .returning({ id: schema.contentDatabaseSourceFields.id });
+        if (!updatedField) {
+          throw new Error(
+            "Source field was deleted before its unbinding could be saved.",
+          );
+        }
+        const [updatedSource] = await tx
+          .update(schema.contentDatabaseSources)
+          .set({ updatedAt: now })
+          .where(
+            and(
+              eq(schema.contentDatabaseSources.id, source.id),
+              eq(schema.contentDatabaseSources.databaseId, database.id),
+            ),
+          )
+          .returning({ id: schema.contentDatabaseSources.id });
+        if (!updatedSource) {
+          throw new Error(
+            "Source was deleted before its field unbinding could be saved.",
+          );
+        }
+      });
       return getContentDatabaseResponse(database.id, { limit: 100, offset: 0 });
     }
 
@@ -183,23 +238,6 @@ export default defineAction({
       );
     }
 
-    await db
-      .update(schema.contentDatabaseSourceFields)
-      .set({
-        propertyId: property.id,
-        localFieldKey: property.id,
-        mappingType: "property",
-        updatedAt: now,
-      })
-      .where(eq(schema.contentDatabaseSourceFields.id, field.id));
-    await db
-      .update(schema.contentDatabaseSources)
-      .set({ updatedAt: now })
-      .where(eq(schema.contentDatabaseSources.id, source.id));
-
-    // Backfill the column with this source's per-row values. A federated
-    // secondary's rows carry no local document (the read path overlays them),
-    // so only materialize for document-backed sources.
     let federationRole: string | null = null;
     try {
       const parsed = JSON.parse(source.metadataJson ?? "{}") as {
@@ -209,57 +247,195 @@ export default defineAction({
     } catch {
       federationRole = null;
     }
-    if (federationRole !== "secondary") {
-      const sourceRows = await db
-        .select({
-          databaseItemId: schema.contentDatabaseSourceRows.databaseItemId,
-          documentId: schema.contentDatabaseSourceRows.documentId,
-          sourceValuesJson: schema.contentDatabaseSourceRows.sourceValuesJson,
+    await db.transaction(async (tx) => {
+      // Share the database-row lock used by stable-key upserts. This makes the
+      // claim check and source binding one atomic ownership transition: either
+      // the property remains caller-managed, or binding fails before backfill.
+      const [lockedDatabase] = await tx
+        .update(schema.contentDatabases)
+        .set({ updatedAt: sql`${schema.contentDatabases.updatedAt}` })
+        .where(
+          and(
+            eq(schema.contentDatabases.id, database.id),
+            eq(schema.contentDatabases.documentId, database.documentId),
+            eq(schema.contentDatabases.ownerEmail, database.ownerEmail),
+            isNull(schema.contentDatabases.deletedAt),
+          ),
+        )
+        .returning({ id: schema.contentDatabases.id });
+      if (!lockedDatabase) throw new Error("Database is no longer active.");
+
+      const [lockedProperty] = await tx
+        .update(schema.documentPropertyDefinitions)
+        .set({
+          updatedAt: sql`${schema.documentPropertyDefinitions.updatedAt}`,
         })
-        .from(schema.contentDatabaseSourceRows)
-        .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
-      const itemValues = sourceFieldPropertyValuesFromRows(
-        sourceRows,
-        field.sourceFieldKey,
-        property.type,
-      );
-      // Clear this column's values for ALL of this source's rows first — not
-      // just the rows that now have a value — so a row whose new bound field is
-      // empty doesn't keep showing a stale/previous value. Then write the
-      // non-empty ones. (This source owns these documents' values for the row-
-      // union, so clearing them is safe.)
-      const sourceDocumentIds = sourceRows
-        .map((row) => row.documentId)
-        .filter((id): id is string => Boolean(id));
-      if (sourceDocumentIds.length > 0) {
-        await db
-          .delete(schema.documentPropertyValues)
-          .where(
-            and(
-              eq(schema.documentPropertyValues.propertyId, property.id),
-              inArray(
-                schema.documentPropertyValues.documentId,
-                sourceDocumentIds,
-              ),
+        .where(
+          and(
+            eq(schema.documentPropertyDefinitions.id, property.id),
+            eq(schema.documentPropertyDefinitions.databaseId, database.id),
+            eq(
+              schema.documentPropertyDefinitions.ownerEmail,
+              database.ownerEmail,
             ),
-          );
+          ),
+        )
+        .returning();
+      if (
+        !lockedProperty ||
+        lockedProperty.type !== property.type ||
+        lockedProperty.systemRole !== property.systemRole ||
+        lockedProperty.name !== property.name
+      ) {
+        throw new Error(
+          "Target column changed or was deleted before the source field could be bound.",
+        );
       }
-      if (itemValues.length > 0) {
-        for (const chunk of chunks(itemValues, 200)) {
-          await db.insert(schema.documentPropertyValues).values(
-            chunk.map((row) => ({
-              id: nanoid(),
-              ownerEmail: database.ownerEmail,
-              documentId: row.documentId,
-              propertyId: property.id,
-              valueJson: serializePropertyValue(row.value),
-              createdAt: now,
-              updatedAt: now,
-            })),
-          );
+
+      const [lockedField] = await tx
+        .select()
+        .from(schema.contentDatabaseSourceFields)
+        .where(eq(schema.contentDatabaseSourceFields.id, field.id));
+      if (
+        !lockedField ||
+        lockedField.sourceId !== source.id ||
+        lockedField.mappingType === "title" ||
+        lockedField.mappingType === "system" ||
+        lockedField.writeOwner === "derived"
+      ) {
+        throw new Error(
+          "Source field changed or was deleted before it could be bound.",
+        );
+      }
+      if (
+        lockedField.propertyId &&
+        lockedField.propertyId !== lockedProperty.id
+      ) {
+        throw new Error(
+          "This source field is already bound to another column. Unbind it first.",
+        );
+      }
+      const [lockedConflictingField] = await tx
+        .select({ id: schema.contentDatabaseSourceFields.id })
+        .from(schema.contentDatabaseSourceFields)
+        .where(
+          and(
+            eq(schema.contentDatabaseSourceFields.sourceId, source.id),
+            eq(
+              schema.contentDatabaseSourceFields.propertyId,
+              lockedProperty.id,
+            ),
+            ne(schema.contentDatabaseSourceFields.id, lockedField.id),
+          ),
+        );
+      if (lockedConflictingField) {
+        throw new Error(
+          "This source already feeds this column from another field. Unbind it first.",
+        );
+      }
+
+      const [activeClaim] = await tx
+        .select({ id: schema.contentDatabaseItemKeyClaims.id })
+        .from(schema.contentDatabaseItemKeyClaims)
+        .where(
+          and(
+            eq(schema.contentDatabaseItemKeyClaims.databaseId, database.id),
+            eq(schema.contentDatabaseItemKeyClaims.propertyId, property.id),
+          ),
+        )
+        .limit(1);
+      if (activeClaim) {
+        throw new Error(
+          "A property with active stable-key claims cannot be bound to a source field.",
+        );
+      }
+
+      const [updatedField] = await tx
+        .update(schema.contentDatabaseSourceFields)
+        .set({
+          propertyId: property.id,
+          localFieldKey: property.id,
+          mappingType: "property",
+          updatedAt: now,
+        })
+        .where(eq(schema.contentDatabaseSourceFields.id, lockedField.id))
+        .returning({ id: schema.contentDatabaseSourceFields.id });
+      if (!updatedField) {
+        throw new Error(
+          "Source field was deleted before its binding could be saved.",
+        );
+      }
+      const [updatedSource] = await tx
+        .update(schema.contentDatabaseSources)
+        .set({ updatedAt: now })
+        .where(
+          and(
+            eq(schema.contentDatabaseSources.id, source.id),
+            eq(schema.contentDatabaseSources.databaseId, database.id),
+          ),
+        )
+        .returning({ id: schema.contentDatabaseSources.id });
+      if (!updatedSource) {
+        throw new Error(
+          "Source was deleted before its field binding could be saved.",
+        );
+      }
+
+      // Backfill the column with this source's per-row values. A federated
+      // secondary's rows carry no local document (the read path overlays them),
+      // so only materialize for document-backed sources.
+      if (federationRole !== "secondary") {
+        const sourceRows = await tx
+          .select({
+            databaseItemId: schema.contentDatabaseSourceRows.databaseItemId,
+            documentId: schema.contentDatabaseSourceRows.documentId,
+            sourceValuesJson: schema.contentDatabaseSourceRows.sourceValuesJson,
+          })
+          .from(schema.contentDatabaseSourceRows)
+          .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
+        const itemValues = sourceFieldPropertyValuesFromRows(
+          sourceRows,
+          lockedField.sourceFieldKey,
+          lockedProperty.type as DocumentPropertyType,
+        );
+        // Clear this column's values for ALL of this source's rows first — not
+        // just the rows that now have a value — so a row whose new bound field is
+        // empty doesn't keep showing a stale/previous value. Then write the
+        // non-empty ones. (This source owns these documents' values for the row-
+        // union, so clearing them is safe.)
+        const sourceDocumentIds = sourceRows
+          .map((row) => row.documentId)
+          .filter((id): id is string => Boolean(id));
+        if (sourceDocumentIds.length > 0) {
+          await tx
+            .delete(schema.documentPropertyValues)
+            .where(
+              and(
+                eq(schema.documentPropertyValues.propertyId, property.id),
+                inArray(
+                  schema.documentPropertyValues.documentId,
+                  sourceDocumentIds,
+                ),
+              ),
+            );
+        }
+        if (itemValues.length > 0) {
+          for (const chunk of chunks(itemValues, 200)) {
+            await tx.insert(schema.documentPropertyValues).values(
+              chunk.map((row) => ({
+                id: nanoid(),
+                ownerEmail: database.ownerEmail,
+                documentId: row.documentId,
+                propertyId: property.id,
+                valueJson: serializePropertyValue(row.value),
+                createdAt: now,
+                updatedAt: now,
+              })),
+            );
+          }
         }
       }
-    }
+    });
 
     return getContentDatabaseResponse(database.id, { limit: 100, offset: 0 });
   },