@drawnagency/primitives 0.1.107 → 0.1.109

package/src/components/shared/LinkField.tsx

@@ -35,7 +35,7 @@ export function LinkField({ label, value, onChange }: Props) {
     <div className="flex flex-col gap-3">
       <FormLabel>{label}</FormLabel>
       <div className="flex gap-2" role="tablist">
-        {(["external", "internal"] as const).map((kind) => (
+        {(["internal", "external"] as const).map((kind) => (
           <button
             key={kind}
             type="button"

package/src/components/shell/EditorShell.tsx

@@ -67,8 +67,6 @@ import {
   discardLocalChanges,
   getCachedContent,
   cacheContent,
-  persistMediaManifest,
-  getMediaManifest,
   getPendingMediaItems,
   getPendingMediaBlobs,
   getPendingMediaDeletions,
@@ -311,6 +309,13 @@ export default function EditorShell({
   // immediate 409 retry assembles the saved manifest against the rebased copy.
   const mediaManifestRef = useRef<MediaManifest>(mediaManifest);
   useEffect(() => { mediaManifestRef.current = mediaManifest; }, [mediaManifest]);
+  // Same reason, for the document sidecar: the collab handlers cache it against a
+  // remote sha, and reading the state directly there would either capture a stale
+  // closure copy (writing an outdated sidecar for that sha — "File missing" on the
+  // next cache hit) or force documentManifest into their dep arrays, churning the
+  // callback identity the collab wiring subscribes with.
+  const documentManifestRef = useRef<DocumentManifest | null>(documentManifest);
+  useEffect(() => { documentManifestRef.current = documentManifest; }, [documentManifest]);
   // Guards the debounced preview-image composition effect (below): skips
   // recomposing on the very first run when a preview already exists, and
   // dedupes concurrent runs against the same composition signature.
@@ -603,13 +608,22 @@ export default function EditorShell({
       // snapshot, never the rebased result. Caching the rebase (local dirty
       // overlays folded in) would poison the next recovery's diff: dirty
       // sections would read as remote-unchanged (silent local-wins) and a
-      // locally-added section would read as "deleted remotely".
+      // locally-added section would read as "deleted remotely". The manifest
+      // follows the same rule: the remote one, not the rebased view.
       await cacheContent(
         remote.sha ?? remote.savedBranchSha ?? headSha,
         remote.sections,
         remote.index,
         remote.siteConfig,
-        { savedBranchSha: remote.savedBranchSha, changedSectionIds: remote.changedSectionIds, mainIndex: remote.mainIndex },
+        {
+          media: remote.mediaManifest ?? mediaManifestRef.current,
+          documents: remote.documentManifest ?? documentManifestRef.current ?? {},
+        },
+        {
+          savedBranchSha: remote.savedBranchSha,
+          changedSectionIds: remote.changedSectionIds,
+          mainIndex: remote.mainIndex,
+        },
       );
       return true;
     } catch (err) {
@@ -698,13 +712,21 @@ export default function EditorShell({
       // ...but the CLEAN fetched remote snapshot is what gets cached as the
       // baseline (amendment 1: caching the rebased result would poison the next
       // 409 recovery — dirty sections would read as remote-unchanged and a ghost
-      // race would never surface).
+      // race would never surface). Same for the manifest: remote, not rebased.
       await cacheContent(
         remote.sha ?? remote.savedBranchSha ?? headSha,
         remote.sections,
         remote.index,
         remote.siteConfig,
-        { savedBranchSha: remote.savedBranchSha, changedSectionIds: remote.changedSectionIds, mainIndex: remote.mainIndex },
+        {
+          media: remote.mediaManifest ?? mediaManifestRef.current,
+          documents: remote.documentManifest ?? documentManifestRef.current ?? {},
+        },
+        {
+          savedBranchSha: remote.savedBranchSha,
+          changedSectionIds: remote.changedSectionIds,
+          mainIndex: remote.mainIndex,
+        },
       );
     } catch (err) {
       console.error("Remote saved-event sync failed:", err);
@@ -947,17 +969,24 @@ export default function EditorShell({
     // just-saved sections now differ from main, so fold them into
     // changedSectionIds (state + ref + cache stay consistent, and a reload that
     // hits this cache shows the same badges the server would report).
-    onBaselineCommitted: async ({ sha, sections: baselineSections, index, savedIds }) => {
+    onBaselineCommitted: async ({ sha, sections: baselineSections, index, savedIds, mediaManifest: committedManifest, documentManifest: committedDocumentManifest }) => {
       const changed = new Set(
         [...changedSectionIdsRef.current, ...savedIds].filter((id) => id in index.sections),
       );
       changedSectionIdsRef.current = changed;
       setChangedSectionIds(changed);
-      await cacheContent(sha, baselineSections, index, (siteConfig ?? {}) as Record<string, unknown>, {
-        savedBranchSha: sha,
-        changedSectionIds: [...changed],
-        mainIndex: mainIndexRef.current,
-      });
+      await cacheContent(
+        sha, baselineSections, index, (siteConfig ?? {}) as Record<string, unknown>,
+        // What the save actually committed — NOT the refs/state, which the
+        // onMediaPublished / onDocumentsPublished callbacks only refresh through a
+        // state effect and can still lag by a render at this point.
+        { media: committedManifest, documents: committedDocumentManifest },
+        {
+          savedBranchSha: sha,
+          changedSectionIds: [...changed],
+          mainIndex: mainIndexRef.current,
+        },
+      );
     },
     savingRef: inFlightSaveRef,
     getEditGeneration: persistence.currentGeneration,
@@ -1148,36 +1177,40 @@ export default function EditorShell({
       // deliberately don't block every load on a freshness fetch to validate this.
       const cacheKeySha = draftHeadSha ?? headSha;
 
+      // A row missing either sidecar predates them moving onto it (v11); it is
+      // not a usable snapshot — serving it would render every image as "No Image"
+      // and every committed document as "File missing" — so treat it as a miss
+      // and re-fetch. An EMPTY manifest is a legitimate value, not an absence.
       const cached = await getCachedContent();
-      if (cached && cached.sha === cacheKeySha) {
+      if (cached && cached.sha === cacheKeySha && cached.mediaManifest && cached.documentManifest) {
         loadedSections = cached.sections;
         loadedIndex = cached.index;
         loadedConfig = SiteConfigSchema.parse(cached.siteConfig);
-        const savedManifest = await getMediaManifest();
-        if (savedManifest) loadedManifest = savedManifest;
+        loadedManifest = cached.mediaManifest;
         setSavedSha(cached.savedBranchSha ?? null);
         setMainSha(headSha);
         setChangedSectionIds(new Set(cached.changedSectionIds ?? []));
         setMainIndex(cached.mainIndex ?? loadedIndex);
         // Without this, a cache-hit load left documentManifest null forever —
         // the siteDocuments memo's null-guard then never lifted and every
-        // document row (committed or staged) read "File missing".
-        setDocumentManifest(cached.documentManifest ?? {});
+        // document row (committed or staged) read "File missing". The row's copy
+        // is authoritative: the hit gate above rejected a row without one.
+        setDocumentManifest(cached.documentManifest);
       } else {
         const data = await fetchSavedContent();
         loadedSections = data.sections;
         loadedIndex = data.index;
         loadedConfig = SiteConfigSchema.parse(data.siteConfig);
-        await cacheContent(data.sha, data.sections, data.index, data.siteConfig, {
-          savedBranchSha: data.savedBranchSha,
-          changedSectionIds: data.changedSectionIds,
-          mainIndex: data.mainIndex,
-          documentManifest: data.documentManifest ?? {},
-        });
-        if (data.mediaManifest) {
-          loadedManifest = data.mediaManifest;
-          await persistMediaManifest(loadedManifest);
-        }
+        if (data.mediaManifest) loadedManifest = data.mediaManifest;
+        await cacheContent(
+          data.sha, data.sections, data.index, data.siteConfig,
+          { media: loadedManifest, documents: data.documentManifest ?? {} },
+          {
+            savedBranchSha: data.savedBranchSha,
+            changedSectionIds: data.changedSectionIds,
+            mainIndex: data.mainIndex,
+          },
+        )
         setDocumentManifest(data.documentManifest ?? {});
         setSavedSha(data.savedBranchSha);
         setMainSha(headSha);
@@ -1343,9 +1376,11 @@ export default function EditorShell({
         setSiteConfig(parsed.data);
         applySiteConfigPreview(parsed.data);
       }
+      // Discard restores the cached snapshot, so the sidecars must come from that
+      // same row — anything else could disagree with the sections we just set.
+      if (cached.mediaManifest) setMediaManifest(cached.mediaManifest);
+      if (cached.documentManifest) setDocumentManifest(cached.documentManifest);
     }
-    const savedManifest = await getMediaManifest();
-    setMediaManifest(savedManifest ?? { images: {}, folders: {} });
     persistence.clearConfigDirty();
     // Discard wiped the Dexie siteIndex row — no unsaved structure remains.
     // Tokenless: discard is unconditional, unlike the save-success clear.

package/src/hooks/useEditorPublish.ts

@@ -98,7 +98,7 @@ interface PublishDeps {
    *  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>;
+  onBaselineCommitted?: (args: { sha: string; sections: LoadedSection[]; index: SiteIndex; savedIds: string[]; mediaManifest: MediaManifest; documentManifest: DocumentManifest }) => Promise<void>;
   /** Injected by EditorShell. Receives non-fatal server warnings from a
    *  successful save (e.g. the nav.json replacement was declined by the
    *  degraded-nav guard) so the shell can surface them instead of the save
@@ -291,6 +291,15 @@ export function useEditorPublish({
     uploadedItems: MediaItem[];
     // The index actually sent (deletions applied) — the committed index state.
     sentIndex: SiteIndex;
+    // The media manifest as committed by this save: the assembled manifest when
+    // media changed, otherwise the (unchanged) manifest we saved against. The
+    // content-cache re-prime writes it alongside the new sha, so the two can
+    // never drift.
+    committedManifest: MediaManifest;
+    // The document sidecar as committed by this save — the view we saved against,
+    // plus the entries this save committed, minus the ids it deleted. Same
+    // contract as committedManifest: it rides the cache write for this sha.
+    committedDocumentManifest: DocumentManifest;
     committedDocumentIds: string[];
     // The deleted ids the final request actually carried — empty when nothing
     // was staged, and never populated on a failure (see the catch below).
@@ -499,6 +508,10 @@ export function useEditorPublish({
         savedSections: dirty.map(({ sectionId, updatedAt, content }) => ({ sectionId, updatedAt, content })),
         uploadedItems: [...uploadedItems, ...finalUploads.map((u) => u.item)],
         sentIndex: siteIndex,
+        committedManifest: gathered.updatedManifest ?? args.mediaManifest,
+        // Read AFTER the final request: committedDocuments is complete and the
+        // deletions (which ride only that request) have landed.
+        committedDocumentManifest: documentManifestToSend(),
         committedDocumentIds,
         committedDocumentDeletions: args.pendingDocumentDeletions,
       };
@@ -659,7 +672,7 @@ export function useEditorPublish({
         return;
       }
 
-      const { sha, savedSections, uploadedItems, sentIndex, committedDocumentIds, committedDocumentDeletions } = await saveWithConflictRecovery();
+      const { sha, savedSections, uploadedItems, sentIndex, committedManifest, committedDocumentManifest, committedDocumentIds, committedDocumentDeletions } = await saveWithConflictRecovery();
       onShasUpdated(sha, null);
 
       try {
@@ -681,6 +694,8 @@ export function useEditorPublish({
             sections: baselineSections,
             index: sentIndex,
             savedIds: savedSections.map((s) => s.sectionId),
+            mediaManifest: committedManifest,
+            documentManifest: committedDocumentManifest,
           });
         }
         finishSave(uploadedItems, savedSections.map((s) => s.sectionId));
@@ -750,10 +765,12 @@ export function useEditorPublish({
       let savedSections: { sectionId: string; updatedAt: string; content: SectionContent }[] = [];
       let uploadedItems: MediaItem[] = [];
       let sentIndex: SiteIndex | null = null;
+      let committedManifest: MediaManifest | null = null;
+      let committedDocumentManifest: DocumentManifest | null = null;
       let committedDocumentIds: string[] = [];
       let committedDocumentDeletions: string[] = [];
       if (hasLocalEdits) {
-        ({ savedSections, uploadedItems, sentIndex, committedDocumentIds, committedDocumentDeletions } = await saveWithConflictRecovery());
+        ({ savedSections, uploadedItems, sentIndex, committedManifest, committedDocumentManifest, committedDocumentIds, committedDocumentDeletions } = await saveWithConflictRecovery());
       }
 
       setPublishAction("publishing");
@@ -789,7 +806,15 @@ export function useEditorPublish({
             savedRows: savedSections,
             sentIndex: sentIndex!,
           });
-          await cacheContent(sha, baselineSections, sentIndex!, siteConfig!);
+          // Both sidecars ride the same write as the sha they belong to: publish
+          // deleted the draft, so main's head IS this sha and the next load hits
+          // this row. Omitting them here is what blanked freshly uploaded images
+          // ("No Image", while the published site was correct) and freshly
+          // committed documents ("File missing").
+          await cacheContent(sha, baselineSections, sentIndex!, siteConfig!, {
+            media: committedManifest!,
+            documents: committedDocumentManifest!,
+          });
           finishSave(uploadedItems, savedSections.map((s) => s.sectionId));
           if (committedDocumentIds.length > 0) onDocumentsPublished?.(committedDocumentIds);
           if (committedDocumentDeletions.length > 0) onDocumentsDeleted?.(committedDocumentDeletions);

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/schemas/link.ts

@@ -43,4 +43,7 @@ export const LinkValueSchema = z.discriminatedUnion("kind", [
 
 export type LinkValue = z.infer<typeof LinkValueSchema>;
 
-export const DEFAULT_LINK: LinkValue = { kind: "external", href: "", target: "_self" };
+// Defaults to an (empty) internal link so the picker opens on the Internal-page
+// tab everywhere it is used; an empty pageId resolves to no href, same as an
+// empty external link, so this stays a safe "unset" sentinel.
+export const DEFAULT_LINK: LinkValue = { kind: "internal", pageId: "", anchorSectionId: null, target: "_self" };

package/dist/chunk-5THS4K5D.js

@@ -1,123 +0,0 @@
-import {
-  cn
-} from "./chunk-7EOSDFS3.js";
-
-// src/components/shared/FormLabel.tsx
-import { jsx } from "react/jsx-runtime";
-function FormLabel({ htmlFor, children, className }) {
-  return /* @__PURE__ */ jsx(
-    "label",
-    {
-      htmlFor,
-      className: cn("mb-1.5 block text-sm font-medium text-base-contrast", className),
-      children
-    }
-  );
-}
-
-// src/components/shared/Input.tsx
-import { forwardRef, useId } from "react";
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
-var Input = forwardRef(function Input2({ label, value, onChange, type = "text", className, disabled, error, ...rest }, ref) {
-  const id = useId();
-  const errorId = `${id}-error`;
-  return /* @__PURE__ */ jsxs("div", { className, children: [
-    /* @__PURE__ */ jsx2(FormLabel, { htmlFor: id, children: label }),
-    /* @__PURE__ */ jsx2(
-      "input",
-      {
-        ref,
-        id,
-        type,
-        value,
-        onChange: (e) => onChange(e.target.value),
-        disabled,
-        "aria-invalid": error ? true : void 0,
-        "aria-describedby": error ? errorId : void 0,
-        className: cn(
-          "w-full rounded border bg-base px-3 py-2 text-sm text-base-contrast focus:outline-none focus:ring-1",
-          error ? "border-red-600 focus:border-red-600 focus:ring-red-600" : "border-base-200 focus:border-base-contrast focus:ring-base-contrast",
-          disabled && "cursor-not-allowed opacity-50"
-        ),
-        ...rest
-      }
-    ),
-    error && /* @__PURE__ */ jsx2("p", { id: errorId, className: "mt-1 text-xs text-red-600", children: error })
-  ] });
-});
-
-// src/components/shared/Checkbox.tsx
-import { useId as useId2 } from "react";
-import { Check } from "lucide-react";
-import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-function Checkbox({
-  checked,
-  onChange,
-  label,
-  description,
-  disabled,
-  className,
-  startAdornment,
-  align = "start"
-}) {
-  const id = useId2();
-  return /* @__PURE__ */ jsxs2(
-    "label",
-    {
-      htmlFor: id,
-      className: cn(
-        "flex cursor-pointer gap-3 select-none hover:opacity-80",
-        align === "start" ? "items-start" : "items-center",
-        disabled && "cursor-not-allowed opacity-50",
-        className
-      ),
-      children: [
-        /* @__PURE__ */ jsxs2(
-          "span",
-          {
-            className: cn(
-              "relative flex h-5 w-5 shrink-0 items-center justify-center",
-              align === "start" && "mt-0.5"
-            ),
-            children: [
-              /* @__PURE__ */ jsx3(
-                "input",
-                {
-                  id,
-                  type: "checkbox",
-                  checked,
-                  disabled,
-                  onChange: (e) => onChange(e.target.checked),
-                  className: "sr-only"
-                }
-              ),
-              /* @__PURE__ */ jsx3(
-                "span",
-                {
-                  "aria-hidden": "true",
-                  className: cn(
-                    "flex h-5 w-5 items-center justify-center rounded border transition-colors",
-                    checked ? "border-primary bg-primary text-primary-contrast" : "border-base-300 bg-base hover:border-primary",
-                    disabled && "pointer-events-none"
-                  ),
-                  children: checked && /* @__PURE__ */ jsx3(Check, { size: 14, strokeWidth: 3 })
-                }
-              )
-            ]
-          }
-        ),
-        startAdornment,
-        /* @__PURE__ */ jsxs2("div", { className: "text-sm", children: [
-          /* @__PURE__ */ jsx3("span", { className: "font-medium text-base-contrast", children: label }),
-          description && /* @__PURE__ */ jsx3("span", { className: "block text-base-contrast-light", children: description })
-        ] })
-      ]
-    }
-  );
-}
-
-export {
-  FormLabel,
-  Input,
-  Checkbox
-};

package/dist/chunk-ZSPCE6MZ.js

@@ -1,70 +0,0 @@
-import {
-  cn
-} from "./chunk-7EOSDFS3.js";
-
-// src/components/shared/Button.tsx
-import { forwardRef } from "react";
-import { jsx } from "react/jsx-runtime";
-var boxSize = {
-  sm: "rounded px-3 py-1.5 text-xs font-medium",
-  md: "rounded px-4 py-2 text-sm font-medium"
-};
-var ghostSize = {
-  sm: "text-xs font-medium",
-  md: "text-sm font-medium"
-};
-var variantClasses = {
-  primary: "bg-base-contrast text-base-accent hover:bg-base-contrast/90",
-  brand: "bg-primary text-primary-contrast hover:opacity-90",
-  secondary: "border border-base-200 text-base-contrast hover:bg-base-accent",
-  destructive: "border border-red-600 text-red-600 hover:bg-red-600 hover:text-white"
-};
-var ghostToneClasses = {
-  neutral: "text-base-contrast-light hover:text-base-contrast",
-  destructive: "text-red-600 hover:text-red-800"
-};
-var Button = forwardRef(function Button2({
-  variant = "primary",
-  size = "sm",
-  tone = "neutral",
-  fullWidth = false,
-  isLoading = false,
-  loadingLabel,
-  disabled,
-  className,
-  children,
-  ...rest
-}, ref) {
-  const isGhost = variant === "ghost";
-  const resolvedDisabled = disabled || isLoading;
-  const label = isLoading && loadingLabel ? loadingLabel : children;
-  return /* @__PURE__ */ jsx(
-    "button",
-    {
-      ref,
-      disabled: resolvedDisabled,
-      className: cn(
-        "inline-flex items-center justify-center transition-colors",
-        isGhost ? ghostSize[size] : boxSize[size],
-        isGhost ? ghostToneClasses[tone] : variantClasses[variant],
-        fullWidth && "w-full",
-        resolvedDisabled ? "cursor-not-allowed opacity-50" : "cursor-pointer",
-        className
-      ),
-      ...rest,
-      children: label
-    }
-  );
-});
-
-// src/components/shared/PagesContext.tsx
-import { createContext, useContext } from "react";
-var PagesContext = createContext({ pages: [], getPageHeadings: () => [] });
-function usePages() {
-  return useContext(PagesContext);
-}
-
-export {
-  Button,
-  usePages
-};