@agent-native/core 0.164.12 → 0.164.15

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 8473
+- template files: 8478

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

@@ -60,6 +60,10 @@ import {
   chunks,
   processWithConcurrency,
 } from "./_batch-utils.js";
+import {
+  LOCAL_FOLDER_SOURCE_TYPE,
+  localFolderSourceIdentityFromMetadata,
+} from "./_local-folder-source.js";
 export { bulkChunkSizeForColumnCount } from "./_batch-utils.js";
 import {
   readBuilderCmsContentEntry,
@@ -176,6 +180,9 @@ type SourceMetadataRecord = {
   connectionId?: string | null;
   connectionLabel?: string | null;
   truthPolicy?: ContentDatabaseSource["metadata"]["truthPolicy"];
+  syncPolicy?: "manual" | "keep_in_sync";
+  liveBridgeEnabled?: boolean;
+  localIdentity?: unknown;
   liveReadConfigured?: boolean;
   lastReadEntryCount?: number;
   lastReadMatchedRowCount?: number;
@@ -4572,14 +4579,19 @@ async function loadSourceSnapshot(
       ? metadata.writeMode
       : undefined;
   const capabilities = normalizeCapabilities(source.capabilitiesJson);
-  if (normalizedWriteMode) {
+  const sourceType = normalizeSourceType(source.sourceType);
+  if (sourceType === LOCAL_FOLDER_SOURCE_TYPE) {
+    capabilities.liveWritesEnabled =
+      metadata.liveBridgeEnabled === true &&
+      metadata.syncPolicy === "keep_in_sync";
+  } else if (normalizedWriteMode) {
     capabilities.liveWritesEnabled = normalizedWriteMode !== "read_only";
   }
 
   // A local-table source shows the target database's *live* title, so renaming
   // the underlying table is reflected here instead of the name frozen at attach.
   let displaySourceName = source.sourceName;
-  if (normalizeSourceType(source.sourceType) === "local-table") {
+  if (sourceType === "local-table") {
     const [target] = await db
       .select({ title: schema.contentDatabases.title })
       .from(schema.contentDatabases)
@@ -4626,6 +4638,17 @@ async function loadSourceSnapshot(
         metadata.truthPolicy === "reviewed_bidirectional"
           ? metadata.truthPolicy
           : undefined,
+      syncPolicy:
+        metadata.syncPolicy === "manual" ||
+        metadata.syncPolicy === "keep_in_sync"
+          ? metadata.syncPolicy
+          : undefined,
+      liveBridgeEnabled:
+        metadata.liveBridgeEnabled === true &&
+        metadata.syncPolicy === "keep_in_sync",
+      localIdentity: localFolderSourceIdentityFromMetadata(
+        metadata.localIdentity,
+      ),
       liveReadConfigured: metadata.liveReadConfigured === true,
       lastReadEntryCount:
         typeof metadata.lastReadEntryCount === "number"

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

@@ -50,6 +50,7 @@ import {
   getDatabaseMutationContract,
 } from "./_database-row-mutation.js";
 import { getAllContentDatabaseSourceSnapshots } from "./_database-source-utils.js";
+import { serializeDocumentSource } from "./_document-source.js";
 import {
   applyFederatedOverlayValues,
   federateSources,
@@ -443,6 +444,7 @@ function serializeDocument(
     databaseMembership: membership
       ? serializeDatabaseMembership(membership)
       : undefined,
+    source: serializeDocumentSource(doc),
     createdAt: doc.createdAt,
     updatedAt: doc.updatedAt,
   };

package/corpus/templates/content/actions/_local-folder-source.ts

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
 
+import { z } from "zod";
+
 import type {
   ContentDatabaseSourceCapabilities,
   ContentDatabaseSourceTruthPolicy,
@@ -7,6 +9,171 @@ import type {
 
 export const LOCAL_FOLDER_SOURCE_TYPE = "local-folder" as const;
 
+export const localFolderOpaqueIdentitySchema = z
+  .string()
+  .trim()
+  .min(1)
+  .max(300)
+  .refine(
+    (value) =>
+      !value.includes("/") &&
+      !value.includes("\\") &&
+      !value.includes("..") &&
+      !value.includes("\0"),
+    "Local source identities must be opaque IDs, not paths.",
+  );
+
+const labelSchema = z.string().trim().min(1).max(200);
+
+export const localFolderSourceConnectionMetadataSchema = z
+  .object({
+    repository: z
+      .object({
+        localId: localFolderOpaqueIdentitySchema,
+        providerBinding: z
+          .object({
+            provider: z.literal("github"),
+            repositoryId: localFolderOpaqueIdentitySchema,
+          })
+          .strict()
+          .optional(),
+      })
+      .strict()
+      .optional(),
+    workingCopy: z
+      .object({
+        id: localFolderOpaqueIdentitySchema,
+        repositoryId: localFolderOpaqueIdentitySchema.optional(),
+        kind: z.enum(["persistent", "temporary"]),
+        name: labelSchema,
+        branch: z.string().trim().min(1).max(300).optional(),
+        commit: z.string().trim().min(1).max(300).optional(),
+        deviceId: localFolderOpaqueIdentitySchema,
+      })
+      .strict()
+      .optional(),
+    liveBridgeEnabled: z.boolean().optional().default(false),
+  })
+  .strict();
+
+export type LocalFolderSourceConnectionMetadata = z.infer<
+  typeof localFolderSourceConnectionMetadataSchema
+>;
+
+export type LocalFolderSourceIdentity = {
+  repository?: {
+    localId: string;
+    providerBinding?: { provider: "github"; repositoryId: string };
+  };
+  workingCopy: {
+    id: string;
+    repositoryId?: string;
+    kind: "persistent" | "temporary";
+    name: string;
+    branch?: string;
+    commit?: string;
+    deviceId: string;
+    localOnly: boolean;
+    shareable: boolean;
+  };
+};
+
+export function localFolderSourceIdentityFromMetadata(
+  value: unknown,
+): LocalFolderSourceIdentity | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  const stored = value as {
+    repository?: unknown;
+    workingCopy?: Record<string, unknown>;
+  };
+  const connectionMetadata =
+    localFolderSourceConnectionMetadataSchema.safeParse({
+      repository: stored.repository,
+      workingCopy: stored.workingCopy
+        ? Object.fromEntries(
+            Object.entries(stored.workingCopy).filter(
+              ([key]) => key !== "localOnly" && key !== "shareable",
+            ),
+          )
+        : undefined,
+    });
+  if (!connectionMetadata.success || !connectionMetadata.data.workingCopy) {
+    return undefined;
+  }
+  try {
+    return normalizeLocalFolderSourceIdentity({
+      connectionId: "stored-local-source",
+      label: connectionMetadata.data.workingCopy.name,
+      connectionMetadata: connectionMetadata.data,
+    });
+  } catch {
+    // coercion-ok: invalid legacy metadata is represented as absent optional identity
+    return undefined;
+  }
+}
+
+export function normalizeLocalFolderSourceIdentity(input: {
+  connectionId: string;
+  label: string;
+  connectionMetadata?: LocalFolderSourceConnectionMetadata;
+}): LocalFolderSourceIdentity {
+  const metadata = localFolderSourceConnectionMetadataSchema.parse(
+    input.connectionMetadata ?? {},
+  );
+  const workingCopy = metadata.workingCopy ?? {
+    id: input.connectionId,
+    kind: "persistent" as const,
+    name: input.label,
+    deviceId: "unknown-device",
+  };
+  if (
+    workingCopy.repositoryId &&
+    (!metadata.repository ||
+      workingCopy.repositoryId !== metadata.repository.localId)
+  ) {
+    throw new Error(
+      "Working-copy repositoryId must match the supplied repository identity.",
+    );
+  }
+  return {
+    ...(metadata.repository ? { repository: metadata.repository } : {}),
+    workingCopy: {
+      ...workingCopy,
+      localOnly: workingCopy.kind === "temporary",
+      shareable: workingCopy.kind !== "temporary",
+    },
+  };
+}
+
+export function localFolderObservedRevision(input: {
+  contentHash: string;
+  metadataHash: string;
+}) {
+  return `sha256:${createHash("sha256")
+    .update(`${input.contentHash}:${input.metadataHash}`)
+    .digest("hex")}`;
+}
+
+export function localFolderSourceFileIdentity(input: {
+  workingCopyId: string;
+  relativePath: string;
+  observedRevision: string;
+}) {
+  const relativePath = input.relativePath.replace(/\\/g, "/");
+  if (
+    !relativePath ||
+    relativePath.startsWith("/") ||
+    relativePath.split("/").some((part) => part === "." || part === "..")
+  ) {
+    throw new Error(
+      "Local source file identity requires a safe relative path.",
+    );
+  }
+  return { ...input, relativePath };
+}
+
 export function localFolderSourceId(databaseId: string, connectionId: string) {
   return `content_database_source_local_folder_${createHash("sha256")
     .update(`${databaseId}:${connectionId}`)
@@ -14,7 +181,9 @@ export function localFolderSourceId(databaseId: string, connectionId: string) {
     .slice(0, 32)}`;
 }
 
-export function localFolderSourceCapabilities(): ContentDatabaseSourceCapabilities {
+export function localFolderSourceCapabilities(input?: {
+  liveBridgeEnabled?: boolean;
+}): ContentDatabaseSourceCapabilities {
   return {
     canRefresh: true,
     canCreateChangeSets: true,
@@ -25,7 +194,7 @@ export function localFolderSourceCapabilities(): ContentDatabaseSourceCapabiliti
     canPublish: false,
     canDelete: true,
     canStageLocalRevision: true,
-    liveWritesEnabled: false,
+    liveWritesEnabled: input?.liveBridgeEnabled === true,
     readOnlyRefresh: false,
     canRename: true,
     canReveal: true,
@@ -37,7 +206,16 @@ export function localFolderSourceMetadata(input: {
   connectionId: string;
   label: string;
   truthPolicy: ContentDatabaseSourceTruthPolicy;
+  connectionMetadata?: LocalFolderSourceConnectionMetadata;
 }) {
+  const connectionMetadata = localFolderSourceConnectionMetadataSchema.parse(
+    input.connectionMetadata ?? {},
+  );
+  const identity = normalizeLocalFolderSourceIdentity({
+    connectionId: input.connectionId,
+    label: input.label,
+    connectionMetadata,
+  });
   return {
     primaryKey: "relative_path",
     naturalKeyField: "relative_path",
@@ -47,6 +225,12 @@ export function localFolderSourceMetadata(input: {
     connectionLabel: input.label,
     truthPolicy: input.truthPolicy,
     writeMode: "stage_only" as const,
+    syncPolicy:
+      connectionMetadata.liveBridgeEnabled === true
+        ? ("keep_in_sync" as const)
+        : ("manual" as const),
+    liveBridgeEnabled: connectionMetadata.liveBridgeEnabled === true,
+    localIdentity: identity,
     notes:
       "The trusted local bridge owns the folder handle or path; SQL stores only this opaque connection identity.",
   };

package/corpus/templates/content/actions/connect-local-folder-source.ts

@@ -17,6 +17,8 @@ import {
 } from "./_content-spaces.js";
 import {
   LOCAL_FOLDER_SOURCE_TYPE,
+  localFolderSourceConnectionMetadataSchema,
+  localFolderOpaqueIdentitySchema,
   localFolderSourceCapabilities,
   localFolderSourceId,
   localFolderSourceMetadata,
@@ -30,12 +32,15 @@ export default defineAction({
   description:
     "Connect an opaque trusted local-folder handle to a canonical Files database. The browser or Desktop bridge keeps the real handle/path; Content stores only safe connection metadata.",
   schema: z.object({
-    connectionId: z
-      .string()
-      .min(1)
-      .max(300)
-      .describe("Stable opaque ID from the trusted browser/Desktop registry"),
+    connectionId: localFolderOpaqueIdentitySchema.describe(
+      "Stable opaque ID from the trusted browser/Desktop registry",
+    ),
     label: z.string().min(1).max(200).describe("User-visible folder label"),
+    connectionMetadata: localFolderSourceConnectionMetadataSchema
+      .optional()
+      .describe(
+        "Safe repository/working-copy identity from the trusted local bridge; raw paths and handles are not accepted.",
+      ),
     spaceId: z
       .string()
       .optional()
@@ -70,9 +75,10 @@ export default defineAction({
     }
 
     const db = getDb();
-    const connectionId = args.connectionId.trim();
+    const connectionId = args.connectionId;
     const label = args.label.trim();
     const truthPolicy = args.truthPolicy as ContentDatabaseSourceTruthPolicy;
+    const connectionMetadata = args.connectionMetadata;
     if (args.dryRun) {
       const [existing] = await db
         .select({
@@ -185,9 +191,18 @@ export default defineAction({
       sourceTable: connectionId,
       syncState: "linked",
       freshness: "unknown",
-      capabilitiesJson: JSON.stringify(localFolderSourceCapabilities()),
+      capabilitiesJson: JSON.stringify(
+        localFolderSourceCapabilities({
+          liveBridgeEnabled: connectionMetadata?.liveBridgeEnabled,
+        }),
+      ),
       metadataJson: JSON.stringify(
-        localFolderSourceMetadata({ connectionId, label, truthPolicy }),
+        localFolderSourceMetadata({
+          connectionId,
+          label,
+          truthPolicy,
+          connectionMetadata,
+        }),
       ),
       lastError: null,
       createdAt: now,

package/corpus/templates/content/actions/disconnect-local-folder-source.ts

@@ -80,7 +80,7 @@ export default defineAction({
         documentId: string;
         sourceDisplayKey: string | null;
         sourceValuesJson: string | null;
-        sourceName: string;
+        sourceTable: string;
       };
       const remainingLocalRows: RemainingLocalRow[] = documentIds.length
         ? await tx
@@ -90,7 +90,7 @@ export default defineAction({
                 schema.contentDatabaseSourceRows.sourceDisplayKey,
               sourceValuesJson:
                 schema.contentDatabaseSourceRows.sourceValuesJson,
-              sourceName: schema.contentDatabaseSources.sourceName,
+              sourceTable: schema.contentDatabaseSources.sourceTable,
             })
             .from(schema.contentDatabaseSourceRows)
             .innerJoin(
@@ -152,7 +152,7 @@ export default defineAction({
             sourceMode: "local-files",
             sourceKind: "file",
             sourcePath: relativePath,
-            sourceRootPath: remaining.sourceName,
+            sourceRootPath: remaining.sourceTable,
             sourceUpdatedAt: now,
             updatedAt: now,
           })

package/corpus/templates/content/actions/resolve-local-folder-conflict.ts

@@ -227,7 +227,7 @@ export default defineAction({
           .select({
             sourceDisplayKey: schema.contentDatabaseSourceRows.sourceDisplayKey,
             sourceValuesJson: schema.contentDatabaseSourceRows.sourceValuesJson,
-            sourceName: schema.contentDatabaseSources.sourceName,
+            sourceTable: schema.contentDatabaseSources.sourceTable,
           })
           .from(schema.contentDatabaseSourceRows)
           .innerJoin(
@@ -267,7 +267,7 @@ export default defineAction({
                   sourceMode: "local-files",
                   sourceKind: "file",
                   sourcePath: remainingPath ?? null,
-                  sourceRootPath: remainingLocalRow.sourceName,
+                  sourceRootPath: remainingLocalRow.sourceTable,
                   sourceUpdatedAt: now,
                   updatedAt: now,
                 }

package/corpus/templates/content/actions/sync-local-folder-source.ts

@@ -19,7 +19,13 @@ import { ensureDocumentsFilesMembership } from "./_content-files.js";
 import { resolveContentSpaceAccess } from "./_content-space-access.js";
 import { provisionContentSpaces } from "./_content-spaces.js";
 import { lockDatabaseMemberships } from "./_database-membership-lock.js";
-import { LOCAL_FOLDER_SOURCE_TYPE } from "./_local-folder-source.js";
+import {
+  LOCAL_FOLDER_SOURCE_TYPE,
+  localFolderObservedRevision,
+  localFolderSourceFileIdentity,
+  localFolderSourceIdentityFromMetadata,
+  normalizeLocalFolderSourceIdentity,
+} from "./_local-folder-source.js";
 
 const MAX_SOURCE_FILES = 500;
 const MAX_SOURCE_FILE_BYTES = 2 * 1024 * 1024;
@@ -75,13 +81,28 @@ function sourceValues(args: {
   title: string;
   hash: string;
   metadataHash: string;
+  workingCopyId: string;
+  bridgeFileIdentity?: string;
 }) {
+  const observedRevision = localFolderObservedRevision({
+    contentHash: args.hash,
+    metadataHash: args.metadataHash,
+  });
   return JSON.stringify({
     relativePath: args.path,
     extension: args.path.toLowerCase().endsWith(".mdx") ? ".mdx" : ".md",
     title: args.title,
     contentHash: args.hash,
     metadataHash: args.metadataHash,
+    observedRevision,
+    sourceFileIdentity: localFolderSourceFileIdentity({
+      workingCopyId: args.workingCopyId,
+      relativePath: args.path,
+      observedRevision,
+    }),
+    ...(args.bridgeFileIdentity
+      ? { bridgeFileIdentity: args.bridgeFileIdentity }
+      : {}),
   });
 }
 
@@ -142,9 +163,19 @@ export default defineAction({
       .refine((value) => Object.keys(value).length <= MAX_SOURCE_FILES, {
         message: `Sync is limited to ${MAX_SOURCE_FILES} files.`,
       }),
+    fileIdentities: z.record(z.string(), z.string().min(1).max(256)).optional(),
+    observedRevisions: z
+      .record(z.string(), z.string().regex(/^[a-f0-9]{64}$/i))
+      .optional(),
     dryRun: z.boolean().optional().default(false),
   }),
-  run: async ({ sourceId, files, dryRun }) => {
+  run: async ({
+    sourceId,
+    files,
+    fileIdentities = {},
+    observedRevisions,
+    dryRun,
+  }) => {
     const userEmail = getRequestUserEmail();
     if (!userEmail) throw new Error("no authenticated user");
     const builderPaths = Object.keys(files).filter(isBuilderMdxSourcePath);
@@ -154,6 +185,15 @@ export default defineAction({
       );
     }
     const entries = normalizedEntries(files);
+    if (observedRevisions) {
+      for (const [filePath, content] of entries) {
+        if (observedRevisions[filePath] !== contentHash(content)) {
+          throw new Error(
+            `Local file revision changed while reading "${filePath}"`,
+          );
+        }
+      }
+    }
     const db = getDb();
     const [target] = await db
       .select({
@@ -263,6 +303,12 @@ export default defineAction({
 
     const metadata = parseJson(target.source.metadataJson);
     const policy = truthPolicy(metadata.truthPolicy);
+    const localIdentity =
+      localFolderSourceIdentityFromMetadata(metadata.localIdentity) ??
+      normalizeLocalFolderSourceIdentity({
+        connectionId: target.source.sourceTable,
+        label: target.source.sourceName,
+      });
     const now = new Date().toISOString();
     const created: Array<{ id: string; path: string; title: string }> = [];
     const updated: Array<{ id: string; path: string; title: string }> = [];
@@ -271,16 +317,42 @@ export default defineAction({
     const conflicts: Array<{ id: string; path: string; title: string }> = [];
     const outbound: Array<{ id: string; path: string; title: string }> = [];
 
-    const buildPlans = (snapshot: Awaited<ReturnType<typeof loadSnapshot>>) =>
-      valid.map((file, index) => {
-        const pathRow = snapshot.rowByPath.get(file.path);
+    const buildPlans = (snapshot: Awaited<ReturnType<typeof loadSnapshot>>) => {
+      const rowByBridgeIdentity = new Map<
+        string,
+        (typeof snapshot.storedRows)[number]
+      >();
+      for (const row of snapshot.storedRows) {
+        const values = parseJson(row.sourceValuesJson);
+        if (typeof values.bridgeFileIdentity === "string") {
+          rowByBridgeIdentity.set(values.bridgeFileIdentity, row);
+        }
+      }
+
+      return valid.map((file, index) => {
+        const directPathRow = snapshot.rowByPath.get(file.path);
+        const incomingBridgeFileIdentity = fileIdentities[file.path];
+        const identityRow = incomingBridgeFileIdentity
+          ? rowByBridgeIdentity.get(incomingBridgeFileIdentity)
+          : undefined;
+        const incomingHash = contentHash(file.content);
+        const pathRow = directPathRow ?? identityRow;
+        const explicitId =
+          file.id && localIdentity.workingCopy.kind === "temporary"
+            ? opaqueId("content_local_file", `${sourceId}:${file.id}`)
+            : file.id;
         const id =
-          file.id ??
+          explicitId ??
           pathRow?.documentId ??
           opaqueId("content_local_file", `${sourceId}:${file.path}`);
         const existing = snapshot.documentById.get(id);
         const previousRow = snapshot.rowByDocumentId.get(id) ?? pathRow;
         const previousValues = parseJson(previousRow?.sourceValuesJson);
+        const bridgeFileIdentity =
+          incomingBridgeFileIdentity ??
+          (typeof previousValues.bridgeFileIdentity === "string"
+            ? previousValues.bridgeFileIdentity
+            : undefined);
         const previousHash =
           typeof previousValues.contentHash === "string"
             ? previousValues.contentHash
@@ -289,7 +361,6 @@ export default defineAction({
           typeof previousValues.metadataHash === "string"
             ? previousValues.metadataHash
             : null;
-        const incomingHash = contentHash(file.content);
         const incomingMetadataHash = metadataHash(file);
         const localHash = existing ? contentHash(existing.content) : null;
         const localMetadataHash = existing ? metadataHash(existing) : null;
@@ -332,8 +403,10 @@ export default defineAction({
           conflict,
           keepContent,
           applyIncoming,
+          bridgeFileIdentity,
         };
       });
+    };
 
     let plans = buildPlans(initialSnapshot);
     const initialDocumentIds = new Set(plans.map((plan) => plan.id));
@@ -348,7 +421,7 @@ export default defineAction({
       unchanged.length = 0;
       conflicts.length = 0;
       outbound.length = 0;
-      for (const row of missingRows) {
+      for (const row of policy === "source_primary" ? [] : missingRows) {
         const values = parseJson(row.sourceValuesJson);
         const path = String(values.relativePath ?? row.sourceDisplayKey ?? "");
         const document = snapshot.documentById.get(row.documentId);
@@ -375,7 +448,8 @@ export default defineAction({
         } else if (
           plan.applyIncoming ||
           plan.existing.title !== plan.file.title ||
-          plan.existing.sourcePath !== plan.file.path
+          plan.existing.sourcePath !== plan.file.path ||
+          plan.existing.sourceRootPath !== target.source.sourceTable
         ) {
           updated.push({
             id: plan.id,
@@ -518,7 +592,7 @@ export default defineAction({
               sourceMode: "local-files",
               sourceKind: "file",
               sourcePath: plan.file.path,
-              sourceRootPath: target.source.sourceName,
+              sourceRootPath: target.source.sourceTable,
               sourceUpdatedAt: now,
               visibility: target.database.orgId ? "org" : "private",
               createdAt: now,
@@ -526,7 +600,8 @@ export default defineAction({
             });
           } else if (
             plan.applyIncoming ||
-            plan.existing.sourcePath !== plan.file.path
+            plan.existing.sourcePath !== plan.file.path ||
+            plan.existing.sourceRootPath !== target.source.sourceTable
           ) {
             await tx
               .insert(schema.documentVersions)
@@ -557,7 +632,7 @@ export default defineAction({
                 sourceMode: "local-files",
                 sourceKind: "file",
                 sourcePath: plan.file.path,
-                sourceRootPath: target.source.sourceName,
+                sourceRootPath: target.source.sourceTable,
                 sourceUpdatedAt: now,
                 updatedAt: now,
               })
@@ -647,6 +722,8 @@ export default defineAction({
               title: plan.file.title,
               hash: plan.incomingHash,
               metadataHash: plan.incomingMetadataHash,
+              workingCopyId: localIdentity.workingCopy.id,
+              bridgeFileIdentity: plan.bridgeFileIdentity,
             }),
             provenance: "trusted local-folder bridge",
             syncState: "linked",
@@ -670,6 +747,47 @@ export default defineAction({
             .where(eq(schema.contentDatabaseSourceRows.id, rowId));
         }
         for (const row of missingRows) {
+          if (policy === "source_primary") {
+            await tx
+              .delete(schema.contentDatabaseSourceRows)
+              .where(eq(schema.contentDatabaseSourceRows.id, row.id));
+            const [remainingSourceRow] = await tx
+              .select({ id: schema.contentDatabaseSourceRows.id })
+              .from(schema.contentDatabaseSourceRows)
+              .where(
+                eq(
+                  schema.contentDatabaseSourceRows.databaseItemId,
+                  row.databaseItemId,
+                ),
+              )
+              .limit(1);
+            if (!remainingSourceRow) {
+              await tx
+                .delete(schema.contentDatabaseItems)
+                .where(eq(schema.contentDatabaseItems.id, row.databaseItemId));
+              await tx
+                .update(schema.documents)
+                .set({
+                  sourceMode: null,
+                  sourceKind: null,
+                  sourcePath: null,
+                  sourceRootPath: null,
+                  sourceUpdatedAt: now,
+                  updatedAt: now,
+                })
+                .where(
+                  and(
+                    eq(schema.documents.id, row.documentId),
+                    eq(schema.documents.spaceId, targetSpaceId),
+                    eq(
+                      schema.documents.sourceRootPath,
+                      target.source.sourceTable,
+                    ),
+                  ),
+                );
+            }
+            continue;
+          }
           const values = parseJson(row.sourceValuesJson);
           const path = String(
             values.relativePath ?? row.sourceDisplayKey ?? row.sourceRowId,