@drawnagency/primitives 0.1.76 → 0.1.77

package/src/hooks/useEditorPublish.ts

@@ -1,9 +1,11 @@
 import { useState, useCallback, useRef, useEffect } from "react";
 import type { SiteIndex, SiteConfig } from "../schemas/site-config";
+import type { SectionContent } from "../schemas/sections";
 import type { LoadedSection } from "../lib/loader";
 import type { MediaManifest, MediaItem } from "../media/types";
-import { getDirtySectionRows, hasLocalChanges, discardSavedChanges, cacheContent, clearContentCache, getPendingMediaBlobs, clearPendingMediaByIds } from "../lib/dexie";
+import { getDirtySectionRows, hasLocalChanges, discardSavedChanges, cacheContent, clearContentCache, getCachedContent, getPendingMediaBlobs, clearPendingMediaByIds } from "../lib/dexie";
 import { packUploads, type MediaUploadPayload } from "../lib/save-chunks";
+import { buildCommittedBaseline } from "../collab/recovery";
 
 function blobToBase64(blob: Blob): Promise<string> {
   return new Promise((resolve, reject) => {
@@ -58,7 +60,14 @@ interface PublishDeps {
   siteConfig: SiteConfig | null;
   sections: LoadedSection[];
   deletedSectionIds?: string[];
-  onSuccess: () => void;
+  /** Receives the ids that were actually committed this save (so the caller can
+   *  release exactly those sections' locks), plus:
+   *  - editToken: the edit-generation captured at save BEGIN. The caller's
+   *    post-save clears must be guarded on it — any edit with a newer generation
+   *    happened while this save was in flight and was NOT carried by it.
+   *  - sentDeletedIds: the deletion ids this save actually sent, so the caller
+   *    clears only those (a deletion scheduled mid-save must stay scheduled). */
+  onSuccess: (savedSectionIds: string[], meta: { editToken: number; sentDeletedIds: string[] }) => void;
   mediaManifest: MediaManifest;
   manifestDirty: boolean;
   clearManifestDirty: () => void;
@@ -71,8 +80,30 @@ interface PublishDeps {
   // no draft exists yet). Sent with saves so the server can 409 on a concurrent
   // edit instead of silently overwriting it. Read at save time (latest value).
   getBaseVersion: () => string | null;
+  /** Injected by EditorShell. On a 409 (concurrent edit) the save calls this to
+   *  re-fetch the fresh draft, rebase local unsaved work on top, and refresh the
+   *  optimistic-concurrency base (savedShaRef). Returns true when recovery
+   *  succeeded and the save should be retried once; false (or undefined) means
+   *  fall through to the honest conflict toast. */
+  recoverConflict?: () => Promise<boolean>;
+  /** Injected by EditorShell. After every successful plain save, receives the
+   *  COMMITTED snapshot (sent content substituted into the previous clean
+   *  baseline, plus the sent index) so the shell can re-prime the content-cache
+   *  baseline that recoverConflict diffs against. Without this, the baseline
+   *  dies at the first save (discardSavedChanges clears it) and later 409
+   *  recoveries would silently merge local-wins. */
+  onBaselineCommitted?: (args: { sha: string; sections: LoadedSection[]; index: SiteIndex; savedIds: string[] }) => Promise<void>;
   /** Test hook: overrides the per-request payload budget (default 4MB). */
   saveChunkBudget?: number;
+  /** Injected by EditorShell. Mirrors this hook's in-flight-save state out to the
+   *  shell so background collaboration handlers (e.g. the remote saved-event
+   *  rebase) can defer while our own save's response path owns the state. */
+  savingRef?: React.MutableRefObject<boolean>;
+  /** Injected by EditorShell (persistence.currentGeneration). Read at save begin
+   *  to mint the editToken passed back through onSuccess. Absent (tests without
+   *  collab wiring): the token degrades to MAX_SAFE_INTEGER, i.e. "nothing was
+   *  edited after capture" — the pre-generation wholesale-clear behavior. */
+  getEditGeneration?: () => number;
 }
 
 interface GatheredMedia {
@@ -102,7 +133,11 @@ export function useEditorPublish({
   onShasUpdated,
   onPublishComplete,
   getBaseVersion,
+  recoverConflict,
+  onBaselineCommitted,
   saveChunkBudget,
+  savingRef,
+  getEditGeneration,
 }: PublishDeps) {
   const [publishAction, setPublishAction] = useState<PublishAction>("idle");
   const [publishFeedback, setPublishFeedback] = useState<string | null>(null);
@@ -163,6 +198,11 @@ export function useEditorPublish({
 
     let updatedManifest: MediaManifest | undefined;
     if (hasMediaChanges) {
+      // KNOWN LIMITATION (deferred): the manifest is rebuilt from THIS editor's
+      // view of manifest.images, so concurrent media changes by another editor
+      // are last-writer-wins — a manifest entry they added since our load is
+      // dropped from the write (their files remain; the entry orphans). Fixing
+      // this needs a merge against the remote manifest at save time.
       const images = { ...manifest.images };
       for (const upload of mediaUploads) {
         images[upload.item.id] = upload.item;
@@ -186,7 +226,16 @@ export function useEditorPublish({
     mediaManifest: MediaManifest;
     manifestDirty: boolean;
     saveChunkBudget?: number;
-  }): Promise<{ sha: string; savedSections: { sectionId: string; updatedAt: string }[]; uploadedItems: MediaItem[] }> {
+  }): Promise<{
+    sha: string;
+    // sectionId+updatedAt for compare-and-clear cleanup, plus the SENT content —
+    // the committed-baseline re-prime needs exactly what went to the server (not
+    // the current view state, which may carry mid-flight edits).
+    savedSections: { sectionId: string; updatedAt: string; content: SectionContent }[];
+    uploadedItems: MediaItem[];
+    // The index actually sent (deletions applied) — the committed index state.
+    sentIndex: SiteIndex;
+  }> {
     const dirty = await getDirtySectionRows();
     const gathered = await gatherMediaPayload(
       args.pendingMediaItems,
@@ -233,56 +282,69 @@ export function useEditorPublish({
     const committedImages: Record<string, MediaItem> = {};
     let sent = 0;
 
-    for (const chunk of leadChunks) {
-      setSaveProgress(`Saving images ${sent + chunk.length}/${totalUploads}…`);
-      for (const upload of chunk) committedImages[upload.item.id] = upload.item;
-      const manifest: MediaManifest = { images: { ...args.mediaManifest.images, ...committedImages } };
-      const data = await postSave({
-        baseVersion,
-        media: { uploads: chunk, deletions: [], manifest },
-      });
-      baseVersion = data.sha;
-      sent += chunk.length;
-      const chunkItems = chunk.map((u) => u.item);
-      uploadedItems.push(...chunkItems);
-      // Promote committed items immediately so a later failure can't re-send
-      // them. A failure HERE is tolerable: re-sending identical blobs on the
-      // next save is harmless (same content, same paths).
-      try {
-        await clearPendingMediaByIds(chunkItems.map((i) => i.id), []);
-        onMediaPublished(chunkItems, []);
-      } catch (promoteError) {
-        console.error("Failed to promote committed media chunk locally:", promoteError);
+    try {
+      for (const chunk of leadChunks) {
+        setSaveProgress(`Saving images ${sent + chunk.length}/${totalUploads}…`);
+        for (const upload of chunk) committedImages[upload.item.id] = upload.item;
+        const manifest: MediaManifest = { images: { ...args.mediaManifest.images, ...committedImages } };
+        const data = await postSave({
+          baseVersion,
+          media: { uploads: chunk, deletions: [], manifest },
+        });
+        baseVersion = data.sha;
+        sent += chunk.length;
+        const chunkItems = chunk.map((u) => u.item);
+        uploadedItems.push(...chunkItems);
+        // Promote committed items immediately so a later failure can't re-send
+        // them. A failure HERE is tolerable: re-sending identical blobs on the
+        // next save is harmless (same content, same paths).
+        try {
+          await clearPendingMediaByIds(chunkItems.map((i) => i.id), []);
+          onMediaPublished(chunkItems, []);
+        } catch (promoteError) {
+          console.error("Failed to promote committed media chunk locally:", promoteError);
+        }
       }
-    }
 
-    if (leadChunks.length > 0) {
-      setSaveProgress(finalUploads.length > 0 ? `Saving images ${totalUploads}/${totalUploads}…` : null);
-    }
+      if (leadChunks.length > 0) {
+        setSaveProgress(finalUploads.length > 0 ? `Saving images ${totalUploads}/${totalUploads}…` : null);
+      }
 
-    const responseData = await postSave({
-      sections: dirty.map(({ sectionId, content }) => ({ id: sectionId, content })),
-      siteIndex,
-      baseVersion,
-      ...(args.deletedSectionIds?.length ? { deletedSectionIds: args.deletedSectionIds } : {}),
-      ...(args.isConfigDirty() ? { siteConfig: args.siteConfig } : {}),
-      ...(gathered.hasMediaChanges ? {
-        media: {
-          uploads: finalUploads,
-          deletions: args.pendingMediaDeletions.map((id) => ({
-            id,
-            folder: args.mediaManifest.images[id]?.folder,
-          })).filter((d) => d.folder),
-          manifest: gathered.updatedManifest,
-        },
-      } : {}),
-    });
+      const responseData = await postSave({
+        sections: dirty.map(({ sectionId, content }) => ({ id: sectionId, content })),
+        siteIndex,
+        baseVersion,
+        ...(args.deletedSectionIds?.length ? { deletedSectionIds: args.deletedSectionIds } : {}),
+        ...(args.isConfigDirty() ? { siteConfig: args.siteConfig } : {}),
+        ...(gathered.hasMediaChanges ? {
+          media: {
+            uploads: finalUploads,
+            deletions: args.pendingMediaDeletions.map((id) => ({
+              id,
+              folder: args.mediaManifest.images[id]?.folder,
+            })).filter((d) => d.folder),
+            manifest: gathered.updatedManifest,
+          },
+        } : {}),
+      });
 
-    return {
-      sha: responseData.sha,
-      savedSections: dirty.map(({ sectionId, updatedAt }) => ({ sectionId, updatedAt })),
-      uploadedItems: [...uploadedItems, ...finalUploads.map((u) => u.item)],
-    };
+      return {
+        sha: responseData.sha,
+        savedSections: dirty.map(({ sectionId, updatedAt, content }) => ({ sectionId, updatedAt, content })),
+        uploadedItems: [...uploadedItems, ...finalUploads.map((u) => u.item)],
+        sentIndex: siteIndex,
+      };
+    } catch (error) {
+      // I2: once a lead chunk has committed (advancing the draft head), a 409
+      // must NOT trigger auto-recovery — the retry would rebuild the manifest
+      // from this invocation's stale closure, dropping the just-promoted items
+      // and orphaning their committed files. Mark the error so the recovery
+      // wrapper falls through to the honest toast instead.
+      if (sent > 0 && error && typeof error === "object") {
+        (error as { leadChunksCommitted?: boolean }).leadChunksCommitted = true;
+      }
+      throw error;
+    }
   }
 
   // --- Shared save orchestration ---
@@ -290,9 +352,24 @@ export function useEditorPublish({
   // change-detection, the /api/save request, and the post-save cleanup stay in
   // one place and can't drift between the two paths.
 
+  // Whether THIS save invocation's recoverConflict actually rebased the view —
+  // gates the 409 toast copy: "your view has been updated" must only be claimed
+  // when it is true. Reset at the start of every save.
+  const recoveredRef = useRef(false);
+
+  // Edit-generation captured at save begin. Edits with a newer generation
+  // happened mid-save (after the payload snapshot) — onSuccess receives this
+  // token so the shell's post-save clears can spare them. Captured BEFORE the
+  // flush: an edit landing during the flush itself then reads as "after the
+  // token" and is kept — erring toward a stale dirty badge, never lost work.
+  const editTokenRef = useRef(Number.MAX_SAFE_INTEGER);
+
   function tryBeginSave(): boolean {
     if (!siteConfig || inFlightRef.current) return false;
     inFlightRef.current = true;
+    if (savingRef) savingRef.current = true;
+    recoveredRef.current = false;
+    editTokenRef.current = getEditGeneration?.() ?? Number.MAX_SAFE_INTEGER;
     setPublishAction("saving");
     setPublishFeedback(null);
     return true;
@@ -315,6 +392,30 @@ export function useEditorPublish({
     });
   }
 
+  // Wraps a save attempt with single-shot 409 auto-recovery: when the server
+  // rejects the save because another editor moved the draft head, ask
+  // recoverConflict() to re-fetch + rebase local work and refresh savedShaRef,
+  // then retry exactly once. Any other error (or a declined/absent recovery)
+  // propagates to reportSaveError. At most one retry per save invocation — never
+  // a loop, since the retry runs runPerformSave() directly, not this wrapper.
+  async function saveWithConflictRecovery(): ReturnType<typeof runPerformSave> {
+    try {
+      return await runPerformSave();
+    } catch (error) {
+      const status = (error as { status?: number })?.status;
+      // I2: no recovery once lead media chunks committed this invocation — see
+      // the flag's source in performSave.
+      const leadCommitted = (error as { leadChunksCommitted?: boolean })?.leadChunksCommitted === true;
+      if (status === 409 && !leadCommitted && recoverConflict && (await recoverConflict())) {
+        // recoverConflict rebased local state and refreshed savedShaRef —
+        // getBaseVersion() now returns the fresh draft head. One retry only.
+        recoveredRef.current = true;
+        return await runPerformSave();
+      }
+      throw error;
+    }
+  }
+
   // Clear the Dexie rows + pending media for what was actually committed. In the
   // publish path this MUST run before cacheContent: discardSavedChanges clears
   // only the rows we sent (preserving edits typed during the request) AND
@@ -330,17 +431,27 @@ export function useEditorPublish({
     await clearPendingMediaByIds(uploadedItems.map((i) => i.id), pendingMediaDeletions);
   }
 
-  function finishSave(uploadedItems: MediaItem[]): void {
+  function finishSave(uploadedItems: MediaItem[], savedSectionIds: string[]): void {
     clearConfigDirty();
     clearManifestDirty();
-    onSuccess();
+    onSuccess(savedSectionIds, {
+      editToken: editTokenRef.current,
+      sentDeletedIds: deletedSectionIds ?? [],
+    });
     onMediaPublished(uploadedItems, pendingMediaDeletions);
   }
 
   function reportSaveError(error: unknown, failLabel: string): void {
     console.error(`${failLabel} failed:`, error);
-    const message = error instanceof Error && error.message ? error.message : `${failLabel} failed`;
     const isConflict = (error as { status?: number })?.status === 409;
+    // M1 honesty: only claim the view was updated when recovery actually
+    // rebased it this invocation (i.e. the RETRY 409'd). A failed/absent/
+    // skipped recovery left the view untouched — say so.
+    const message = isConflict
+      ? recoveredRef.current
+        ? "Someone else saved while you were editing — your view has been updated; try saving again."
+        : "This site was changed elsewhere — reload to get the latest, then re-apply your edits."
+      : error instanceof Error && error.message ? error.message : `${failLabel} failed`;
     showFeedback(message, isConflict ? 8000 : 6000);
   }
 
@@ -356,12 +467,31 @@ export function useEditorPublish({
         return;
       }
 
-      const { sha, savedSections, uploadedItems } = await runPerformSave();
+      const { sha, savedSections, uploadedItems, sentIndex } = await saveWithConflictRecovery();
       onShasUpdated(sha, null);
 
       try {
+        // C1: read the previous clean baseline BEFORE commitSavedRows clears the
+        // content cache, then re-prime it with the COMMITTED snapshot keyed at
+        // the new sha. Post-recovery the cache holds the fetched remote snapshot,
+        // so this correctly layers only the retried dirty rows on top of it.
+        const prevBaseline = onBaselineCommitted ? await getCachedContent() : null;
         await commitSavedRows(savedSections, uploadedItems);
-        finishSave(uploadedItems);
+        if (onBaselineCommitted) {
+          const baselineSections = buildCommittedBaseline({
+            baselineSections: prevBaseline?.sections ?? null,
+            fallbackSections: sections,
+            savedRows: savedSections,
+            sentIndex,
+          });
+          await onBaselineCommitted({
+            sha,
+            sections: baselineSections,
+            index: sentIndex,
+            savedIds: savedSections.map((s) => s.sectionId),
+          });
+        }
+        finishSave(uploadedItems, savedSections.map((s) => s.sectionId));
       } catch (cleanupError) {
         console.error("Save succeeded but local cleanup failed:", cleanupError);
         showFeedback("Saved, but the local cache couldn't be updated — reload the editor.", 8000);
@@ -373,10 +503,11 @@ export function useEditorPublish({
       reportSaveError(error, "Save");
     } finally {
       inFlightRef.current = false;
+      if (savingRef) savingRef.current = false;
       setPublishAction("idle");
       setSaveProgress(null);
     }
-  }, [flushNow, cancelPendingFlush, isConfigDirty, clearConfigDirty, siteIndexRef, siteConfig, deletedSectionIds, onSuccess, mediaManifest, manifestDirty, clearManifestDirty, pendingMediaItems, pendingMediaDeletions, onMediaPublished, onShasUpdated, showFeedback, saveChunkBudget]);
+  }, [flushNow, cancelPendingFlush, isConfigDirty, clearConfigDirty, siteIndexRef, siteConfig, sections, deletedSectionIds, onSuccess, mediaManifest, manifestDirty, clearManifestDirty, pendingMediaItems, pendingMediaDeletions, onMediaPublished, onShasUpdated, showFeedback, recoverConflict, onBaselineCommitted, saveChunkBudget, getEditGeneration]);
 
   const handlePublish = useCallback(async () => {
     setPublishAction("publishing");
@@ -422,10 +553,11 @@ export function useEditorPublish({
 
       const hasLocalEdits = await hasPendingEdits();
 
-      let savedSections: { sectionId: string; updatedAt: string }[] = [];
+      let savedSections: { sectionId: string; updatedAt: string; content: SectionContent }[] = [];
       let uploadedItems: MediaItem[] = [];
+      let sentIndex: SiteIndex | null = null;
       if (hasLocalEdits) {
-        ({ savedSections, uploadedItems } = await runPerformSave());
+        ({ savedSections, uploadedItems, sentIndex } = await saveWithConflictRecovery());
       }
 
       setPublishAction("publishing");
@@ -448,12 +580,21 @@ export function useEditorPublish({
 
       if (hasLocalEdits) {
         try {
+          // C1 parity with handleSave: read the previous clean baseline before
+          // the invalidation, then re-cache the COMMITTED snapshot (sent content
+          // + sent index — never the live view state, which may carry mid-flight
+          // edits) against the PUBLISHED sha; the draft branch is gone after
+          // publish, so this is the snapshot a later cache hit restores.
+          const prevBaseline = await getCachedContent();
           await commitSavedRows(savedSections, uploadedItems);
-          // Re-cache against the PUBLISHED sha (commitSavedRows just invalidated the
-          // cache); the draft branch is gone after publish, so this is the snapshot a
-          // later cache hit restores.
-          await cacheContent(sha, sections, siteIndexRef.current, siteConfig!);
-          finishSave(uploadedItems);
+          const baselineSections = buildCommittedBaseline({
+            baselineSections: prevBaseline?.sections ?? null,
+            fallbackSections: sections,
+            savedRows: savedSections,
+            sentIndex: sentIndex!,
+          });
+          await cacheContent(sha, baselineSections, sentIndex!, siteConfig!);
+          finishSave(uploadedItems, savedSections.map((s) => s.sectionId));
         } catch (cleanupError) {
           console.error("Publish succeeded but local cleanup failed:", cleanupError);
           onShasUpdated(null, sha);
@@ -469,10 +610,11 @@ export function useEditorPublish({
       reportSaveError(error, "Publish");
     } finally {
       inFlightRef.current = false;
+      if (savingRef) savingRef.current = false;
       setPublishAction("idle");
       setSaveProgress(null);
     }
-  }, [flushNow, cancelPendingFlush, isConfigDirty, clearConfigDirty, siteIndexRef, siteConfig, sections, deletedSectionIds, onSuccess, mediaManifest, manifestDirty, clearManifestDirty, pendingMediaItems, pendingMediaDeletions, onMediaPublished, onShasUpdated, showFeedback, onPublishComplete, saveChunkBudget]);
+  }, [flushNow, cancelPendingFlush, isConfigDirty, clearConfigDirty, siteIndexRef, siteConfig, sections, deletedSectionIds, onSuccess, mediaManifest, manifestDirty, clearManifestDirty, pendingMediaItems, pendingMediaDeletions, onMediaPublished, onShasUpdated, showFeedback, onPublishComplete, recoverConflict, saveChunkBudget, getEditGeneration]);
 
   return { publishAction, publishFeedback, saveProgress, handleSave, handlePublish, handleSaveAndPublish };
 }

package/src/index.ts

@@ -4,3 +4,5 @@ export * from "./auth";
 export * from "./media";
 export * from "./deploy";
 export * from "./storage";
+export * from "./collab/types";
+export { setCollabProvider, getCollabProvider } from "./collab/provider-registry";

package/src/lib/dexie.ts

@@ -67,6 +67,14 @@ interface PendingMediaDeletionRow {
   deletedAt: string;
 }
 
+export interface PreservedEditRow {
+  id: string;
+  sectionId: string;
+  content: SectionContent;
+  reason: "takeover" | "conflict";
+  preservedAt: string;
+}
+
 class EditorDatabase extends Dexie {
   sections!: Dexie.Table<SectionRow, string>;
   siteIndex!: Dexie.Table<SiteIndexRow, string>;
@@ -76,6 +84,7 @@ class EditorDatabase extends Dexie {
   mediaManifest!: Dexie.Table<MediaManifestRow, string>;
   pendingMedia!: Dexie.Table<PendingMediaRow, string>;
   pendingMediaDeletions!: Dexie.Table<PendingMediaDeletionRow, string>;
+  preservedEdits!: Dexie.Table<PreservedEditRow, string>;
 
   constructor(siteId: string) {
     super(`brand-portal-${siteId}`);
@@ -164,6 +173,20 @@ class EditorDatabase extends Dexie {
       await tx.table("siteIndex").clear();
       await tx.table("contentCache").clear();
     });
+    // v9: preservedEdits store — snapshots of local edits about to be
+    // superseded by a takeover or conflict resolution, so nothing is silently
+    // destroyed.
+    this.version(9).stores({
+      sections: "sectionId",
+      siteIndex: "key",
+      meta: "key",
+      siteConfig: "key",
+      contentCache: "key",
+      mediaManifest: "key",
+      pendingMedia: "id",
+      pendingMediaDeletions: "id",
+      preservedEdits: "id, sectionId",
+    });
   }
 }
 
@@ -539,3 +562,24 @@ export async function clearPendingMediaByIds(
     if (deletionIds.length > 0) await database.pendingMediaDeletions.bulkDelete(deletionIds);
   });
 }
+
+/** Snapshot a local edit that is about to be superseded (takeover or conflict
+ *  resolution) so it is recoverable rather than silently destroyed. */
+export async function preserveEdit(
+  sectionId: string,
+  content: SectionContent,
+  reason: "takeover" | "conflict",
+): Promise<string> {
+  const preservedAt = new Date().toISOString();
+  const id = `${sectionId}:${preservedAt}`;
+  await getDb().preservedEdits.put({ id, sectionId, content, reason, preservedAt });
+  return id;
+}
+
+export async function listPreservedEdits(): Promise<PreservedEditRow[]> {
+  return getDb().preservedEdits.toArray();
+}
+
+export async function removePreservedEdit(id: string): Promise<void> {
+  await getDb().preservedEdits.delete(id);
+}

package/src/lib/registry.ts

@@ -109,6 +109,14 @@ export interface WrapperProps {
   mainStatus?: string | null;
   contentDiffersFromMain?: boolean;
   isLocalOnly?: boolean;
+  /** Collaboration: when another editor holds this section's lock, their identity.
+   *  Renders a lock badge, makes content inert, and suppresses mutation chrome. */
+  lockedBy?: { email: string } | null;
+  /** Collaboration: request the lock be stolen from the current holder. */
+  onTakeover?: () => void;
+  /** Collaboration: fired on focus-in to request the lock. Resolves false when
+   *  denied (caller keeps the section read-only via `lockedBy`). */
+  onEditIntent?: () => Promise<boolean>;
   children: React.ReactNode;
 }
 

package/src/types/database.ts

@@ -223,6 +223,41 @@ export type Database = {
           },
         ]
       }
+      editor_locks: {
+        Row: {
+          acquired_at: string
+          email: string
+          heartbeat_at: string
+          section_id: string
+          site_id: string
+          user_id: string
+        }
+        Insert: {
+          acquired_at?: string
+          email: string
+          heartbeat_at?: string
+          section_id: string
+          site_id: string
+          user_id: string
+        }
+        Update: {
+          acquired_at?: string
+          email?: string
+          heartbeat_at?: string
+          section_id?: string
+          site_id?: string
+          user_id?: string
+        }
+        Relationships: [
+          {
+            foreignKeyName: "editor_locks_site_id_fkey"
+            columns: ["site_id"]
+            isOneToOne: false
+            referencedRelation: "sites"
+            referencedColumns: ["id"]
+          },
+        ]
+      }
       github_installations: {
         Row: {
           created_at: string | null
@@ -680,6 +715,17 @@ export type Database = {
       [_ in never]: never
     }
     Functions: {
+      acquire_section_lock: {
+        Args: { p_section_id: string; p_site_id: string; p_steal?: boolean }
+        Returns: {
+          acquired_at: string
+          email: string
+          heartbeat_at: string
+          section_id: string
+          site_id: string
+          user_id: string
+        }[]
+      }
       chat_usage_hit: {
         Args: {
           p_day: string
@@ -690,7 +736,12 @@ export type Database = {
         }
         Returns: undefined
       }
+      collab_site_member: { Args: { p_site_id: string }; Returns: boolean }
       get_user_id_by_email: { Args: { lookup_email: string }; Returns: string }
+      heartbeat_section_locks: {
+        Args: { p_section_ids: string[]; p_site_id: string }
+        Returns: undefined
+      }
       is_site_member: { Args: { p_site_id: string }; Returns: boolean }
       is_site_owner: { Args: { p_site_id: string }; Returns: boolean }
       oauth_cleanup: { Args: { p_max_age_ms: number }; Returns: undefined }
@@ -716,6 +767,10 @@ export type Database = {
           retry_after_ms: number
         }[]
       }
+      release_section_locks: {
+        Args: { p_section_ids: string[]; p_site_id: string }
+        Returns: undefined
+      }
       revoke_site_user: {
         Args: { p_site_id: string; p_user_id: string }
         Returns: undefined

package/dist/{chunk-Q3T23HVW.js → chunk-B2DLHZKC.js}

@@ -1,12 +1,12 @@
-import {
-  Button,
-  usePages
-} from "./chunk-ZSPCE6MZ.js";
 import {
   Checkbox,
   FormLabel,
   Input
 } from "./chunk-5THS4K5D.js";
+import {
+  Button,
+  usePages
+} from "./chunk-ZSPCE6MZ.js";
 import {
   DeleteIcon,
   DragHandle,

package/dist/{chunk-ZRWGV5O6.js → chunk-XFDEUK37.js}

@@ -7,12 +7,12 @@ import {
 import {
   getSectionSchema
 } from "./chunk-TZQPOR5A.js";
-import {
-  getAllSchemas
-} from "./chunk-VKAGMEKE.js";
 import {
   IndexSchema
 } from "./chunk-SWIHUIFT.js";
+import {
+  getAllSchemas
+} from "./chunk-VKAGMEKE.js";
 import {
   MAX_BLOCK_DEPTH,
   blockDepth