@drawnagency/primitives 0.1.106 → 0.1.108

package/src/lib/dexie.ts

@@ -50,19 +50,21 @@ interface ContentCacheRow {
   savedBranchSha?: string | null;
   changedSectionIds?: string[];
   mainIndex?: SiteIndex | null;
-  // The document sidecar at this sha. Optional for rows written by older
-  // packages; readers fall back to {} (same posture as the fetch path's
-  // `data.documentManifest ?? {}`). Without this, a cache-hit editor load left
-  // documentManifest null and the whole documents feature dead for the session.
+  // Both sidecars AT THIS SHA. They live HERE and nowhere else, and cacheContent
+  // takes them as a required argument, because every way of storing them apart
+  // from the sha drifted: the media manifest was a separate singleton row and the
+  // document manifest was an optional extra, and both were written only by the
+  // cache-miss load path — so every save/publish that re-primed this row advanced
+  // the sha and left them behind. A later cache hit then restored pre-upload
+  // media (freshly uploaded images rendered "No Image" in the editor while the
+  // published site was correct) and an empty document manifest (committed
+  // documents read "File missing"). Optional in the TYPE only because Dexie rows
+  // are not schema-enforced; readers treat absence as a MISS (getCachedContent),
+  // never as "nothing here".
+  mediaManifest?: MediaManifest | null;
   documentManifest?: DocumentManifest | null;
 }
 
-interface MediaManifestRow {
-  key: string;
-  manifest: MediaManifest;
-  updatedAt: string;
-}
-
 interface PendingMediaRow {
   id: string;
   item: MediaItem;
@@ -101,7 +103,6 @@ class EditorDatabase extends Dexie {
   meta!: Dexie.Table<MetaRow, string>;
   siteConfig!: Dexie.Table<SiteConfigRow, string>;
   contentCache!: Dexie.Table<ContentCacheRow, string>;
-  mediaManifest!: Dexie.Table<MediaManifestRow, string>;
   pendingMedia!: Dexie.Table<PendingMediaRow, string>;
   pendingMediaDeletions!: Dexie.Table<PendingMediaDeletionRow, string>;
   preservedEdits!: Dexie.Table<PreservedEditRow, string>;
@@ -223,6 +224,28 @@ class EditorDatabase extends Dexie {
       preservedEdits: "id, sectionId",
       pendingDocuments: "id",
     });
+    // v11: the media manifest moved onto the sha-keyed contentCache row and the
+    // standalone `mediaManifest` store is deleted. It was written by the
+    // cache-miss load path ONLY, so every save/publish that re-primed
+    // contentCache advanced the cached sha while leaving the manifest at its
+    // older value — and the next cache hit served that stale manifest, blanking
+    // every image uploaded since. Dropping the store makes the drift
+    // unrepresentable. contentCache is cleared because no pre-v11 row carries a
+    // manifest; the next load re-fetches and writes both together.
+    this.version(11).stores({
+      sections: "sectionId",
+      siteIndex: "key",
+      meta: "key",
+      siteConfig: "key",
+      contentCache: "key",
+      mediaManifest: null,
+      pendingMedia: "id",
+      pendingMediaDeletions: "id",
+      preservedEdits: "id, sectionId",
+      pendingDocuments: "id",
+    }).upgrade(async (tx) => {
+      await tx.table("contentCache").clear();
+    });
   }
 }
 
@@ -478,12 +501,28 @@ export async function getDeletedSections(): Promise<string[]> {
   return row?.deletedSections ?? [];
 }
 
+/**
+ * Write the content snapshot for one commit.
+ *
+ * `manifests` is REQUIRED, and that is the whole point: both sidecars belong to
+ * this sha, so every writer that advances the row must restate them. They used to
+ * be optional (the media one lived in a separate store entirely), and every
+ * save/publish that re-primed this row left them behind at an older sha — a later
+ * cache hit then served pre-upload media ("No Image" on images the published site
+ * rendered fine) and an empty document manifest ("File missing" on committed
+ * documents). Passing them positionally makes forgetting a compile error.
+ */
 export async function cacheContent(
   sha: string,
   sections: LoadedSection[],
   index: SiteIndex,
   siteConfig: Record<string, unknown>,
-  diff?: { savedBranchSha: string | null; changedSectionIds: string[]; mainIndex: SiteIndex | null; documentManifest?: DocumentManifest },
+  manifests: { media: MediaManifest; documents: DocumentManifest },
+  diff?: {
+    savedBranchSha?: string | null;
+    changedSectionIds?: string[];
+    mainIndex?: SiteIndex | null;
+  },
 ): Promise<void> {
   const now = new Date().toISOString();
   await getDb().contentCache.put({
@@ -496,7 +535,8 @@ export async function cacheContent(
     savedBranchSha: diff?.savedBranchSha ?? null,
     changedSectionIds: diff?.changedSectionIds ?? [],
     mainIndex: diff?.mainIndex ?? null,
-    documentManifest: diff?.documentManifest ?? null,
+    mediaManifest: manifests.media,
+    documentManifest: manifests.documents,
   });
 }
 
@@ -508,7 +548,13 @@ export async function getCachedContent(): Promise<{
   savedBranchSha: string | null;
   changedSectionIds: string[];
   mainIndex: SiteIndex | null;
-  documentManifest: DocumentManifest;
+  /** Both are null ONLY for a row written before the sidecars moved onto it.
+   *  Callers must treat null as an unusable cache and re-fetch — substituting an
+   *  empty manifest would blank every image ("No Image") or every committed
+   *  document ("File missing") on the page. An EMPTY manifest is a legitimate
+   *  value and is not null. */
+  mediaManifest: MediaManifest | null;
+  documentManifest: DocumentManifest | null;
 } | null> {
   const row = await getDb().contentCache.get("current");
   if (!row) return null;
@@ -522,10 +568,8 @@ export async function getCachedContent(): Promise<{
     // No stored mainIndex (e.g. legacy or post-publish cache) means "no draft",
     // so the published index equals the current index.
     mainIndex: row.mainIndex ?? row.index,
-    // Legacy row (pre-documents package): {} matches the fetch path's posture.
-    // The narrow stale edge — an old row at a sha that DOES hold a manifest —
-    // heals on the next fresh load or save.
-    documentManifest: row.documentManifest ?? {},
+    mediaManifest: row.mediaManifest ?? null,
+    documentManifest: row.documentManifest ?? null,
   };
 }
 
@@ -536,16 +580,6 @@ export async function clearContentCache(): Promise<void> {
   await getDb().contentCache.clear();
 }
 
-export async function persistMediaManifest(manifest: MediaManifest): Promise<void> {
-  const now = new Date().toISOString();
-  await getDb().mediaManifest.put({ key: "current", manifest, updatedAt: now });
-}
-
-export async function getMediaManifest(): Promise<MediaManifest | null> {
-  const row = await getDb().mediaManifest.get("current");
-  return row?.manifest ?? null;
-}
-
 export async function addPendingMediaItem(
   item: MediaItem,
   localUrls: Record<string, string> = {},

package/src/lib/insert-menu.ts

@@ -12,9 +12,43 @@ export interface InsertMenuOption {
   icon?: ReactNode;
 }
 
-/** Every non-spacer section type, followed by presets contributed by registered
- *  sections. Presets appear only when their owning section is registered, so a
- *  core-only build (no brand-guide sections) shows no brand-guide presets. */
+/** Authored display order for the Add-section menu, most-reached-for first.
+ *  `container` leads because the picker gives it its own full-width row above a
+ *  divider. Anything absent — client-repo custom sections and their presets —
+ *  sorts alphabetically after these. */
+const INSERT_MENU_ORDER = [
+  "container",
+  "link_heading",
+  "sub_heading",
+  "sub_sub_heading",
+  "prose",
+  "media",
+  "video",
+  "button",
+  "colors",
+  "document",
+  "icon_list",
+  `${PRESET_PREFIX}do_dont_list`,
+  "dodont_media",
+];
+
+/** Sort insert-menu entries into `INSERT_MENU_ORDER`, with unlisted entries
+ *  (custom sections) alphabetical by label at the end. Pure; returns a copy. */
+export function sortInsertMenuOptions<T extends InsertMenuOption>(options: T[]): T[] {
+  return [...options].sort((a, b) => {
+    const ai = INSERT_MENU_ORDER.indexOf(a.type);
+    const bi = INSERT_MENU_ORDER.indexOf(b.type);
+    if (ai !== -1 && bi !== -1) return ai - bi;
+    if (ai !== -1) return -1;
+    if (bi !== -1) return 1;
+    return a.label.localeCompare(b.label);
+  });
+}
+
+/** Every non-spacer section type, plus presets contributed by registered
+ *  sections, in `INSERT_MENU_ORDER`. Presets appear only when their owning
+ *  section is registered, so a core-only build (no brand-guide sections) shows
+ *  no brand-guide presets. */
 export function buildInsertMenuOptions(sections: SectionDefinition[]): InsertMenuOption[] {
   const typeOptions = sections
     .filter((def) => def.type !== "spacer")
@@ -22,7 +56,7 @@ export function buildInsertMenuOptions(sections: SectionDefinition[]): InsertMen
   const presetOptions = sections
     .flatMap((def) => def.presets ?? [])
     .map((p) => ({ type: `${PRESET_PREFIX}${p.id}`, label: p.label, icon: p.icon }));
-  return [...typeOptions, ...presetOptions];
+  return sortInsertMenuOptions([...typeOptions, ...presetOptions]);
 }
 
 /** Resolve an Add-menu selection to ready-to-insert content. `newId` mints ids for