@drawnagency/primitives 0.1.113 → 0.1.115

package/src/hooks/useSortableRow.ts

@@ -11,6 +11,17 @@ interface UseSortableRowOptions {
 }
 
 /**
+ * One of three sibling drag-and-drop position hooks, split by location type
+ * rather than unified behind a generic `useSortable({ axis })`: this one (flat
+ * index — section-ordering lists, `EditableList`), `useSortableNavRow`
+ * (NavLocation — the Pages modal's group-aware nav tree), and `useBlockDnd`
+ * (block/container id + index — the section canvas, root and nested). A
+ * fourth location type earns its own hook on the same shape (rowRef/handleRef,
+ * lazy atlaskit import, closest-edge state, a ref for the latest callback)
+ * rather than a parameter bag bolted onto an existing one — see
+ * docs/superpowers/specs/2026-09-04-editor-ui-primitives-consolidation.md § D6
+ * for why a shared `useSortable` was deferred.
+ *
  * Closest-edge drag-to-reorder wiring for a single list row, shared by the
  * section- and page-ordering modals. Attach `rowRef` to the row element and
  * `handleRef` to the drag handle, and render
@@ -30,6 +41,15 @@ export function useSortableRow<R extends HTMLElement, H extends HTMLElement>({
   const [isDragging, setIsDragging] = useState(false);
   const [closestEdge, setClosestEdge] = useState<"top" | "bottom" | null>(null);
 
+  // Read through a ref so a changed `onReorder` identity doesn't re-register
+  // the atlaskit bindings mid-drag (which cancels the drag) — the same class
+  // of bug EditableList's `onReorderRef` fixed (2026-08-03). `index` stays a
+  // real effect dependency: a stale index would report the wrong
+  // `fromIndex`/`toIndex` on drop, the hazard useSortableNavRow's `locationOf`
+  // comment warns about for its own (non-re-subscribing) case.
+  const onReorderRef = useRef(onReorder);
+  onReorderRef.current = onReorder;
+
   useEffect(() => {
     if (!enabled) return;
     const row = rowRef.current;
@@ -79,7 +99,7 @@ export function useSortableRow<R extends HTMLElement, H extends HTMLElement>({
           const rawEdge = extractClosestEdge(self.data);
           const edge = rawEdge === "top" || rawEdge === "bottom" ? rawEdge : null;
           const toIndex = computeReorderTarget(fromIndex, index, edge);
-          if (toIndex !== null) onReorder(fromIndex, toIndex);
+          if (toIndex !== null) onReorderRef.current(fromIndex, toIndex);
         },
       });
 
@@ -93,7 +113,7 @@ export function useSortableRow<R extends HTMLElement, H extends HTMLElement>({
       cancelled = true;
       cleanup?.();
     };
-  }, [index, dragType, onReorder, enabled]);
+  }, [index, dragType, enabled]);
 
   return { rowRef, handleRef, isDragging, closestEdge };
 }

package/src/hooks/useStackedEscape.ts

@@ -0,0 +1,62 @@
+import { useEffect, useRef, type RefObject } from "react";
+
+export interface UseStackedEscapeOptions {
+  enabled: boolean;
+  /**
+   * Runs first, before the layer check would otherwise fall through to
+   * `onEscape`; returning `true` swallows the keypress entirely (the document
+   * editor overlay's blur-a-focused-field-first step).
+   */
+  before?: (e: KeyboardEvent) => boolean;
+}
+
+/**
+ * Shared "a modal above me owns Escape" rule. `EditorModal` marks its
+ * outermost layer with `data-modal-layer`; anything that might render BELOW
+ * one — a `Popover`, the doc file pane, the document editor overlay, and
+ * `EditorModal` itself (relative to another `EditorModal` opened on top of
+ * it) — must not react to an Escape meant for that layer instead.
+ *
+ * Attach the returned ref to your own `data-modal-layer` element (only
+ * `EditorModal` does) so the check can exclude it — otherwise it would always
+ * find itself and never fire. Callers that aren't a layer themselves (Popover,
+ * DocFilePane, the overlay) just ignore the return value: any layer at all
+ * then means something is stacked above them.
+ *
+ * For a tagged caller, "above" means a layer that FOLLOWS its own layer in
+ * DOM order (`compareDocumentPosition` + `DOCUMENT_POSITION_FOLLOWING`), not
+ * just "any other layer" — modals are appended later in DOM order than the
+ * ones already open, so this is what lets two stacked `EditorModal`s (e.g.
+ * Site Settings opening the Media Library over itself) resolve Escape to the
+ * topmost one only, then the next one down once that one closes.
+ */
+export function useStackedEscape<T extends HTMLElement = HTMLElement>(
+  onEscape: () => void,
+  { enabled, before }: UseStackedEscapeOptions,
+): RefObject<T | null> {
+  const layerRef = useRef<T | null>(null);
+
+  useEffect(() => {
+    if (!enabled) return;
+
+    const onKeyDown = (e: KeyboardEvent) => {
+      if (e.key !== "Escape") return;
+      const own = layerRef.current;
+      const layers = document.querySelectorAll<HTMLElement>("[data-modal-layer]");
+      const above = Array.from(layers).some((el) => {
+        if (el === own) return false;
+        if (!own) return true;
+        return Boolean(own.compareDocumentPosition(el) & Node.DOCUMENT_POSITION_FOLLOWING);
+      });
+      if (above) return;
+      if (before?.(e)) return;
+      e.preventDefault();
+      onEscape();
+    };
+
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [enabled, onEscape, before]);
+
+  return layerRef;
+}

package/src/lib/block-dnd.ts

@@ -11,6 +11,8 @@ export interface BlockDragData {
   index: number;
   /** True if the dragged block is itself a container (used for the depth guard). */
   isContainer: boolean;
+  /** True if the dragged block is a Reference, which only expands at the page root. */
+  isReference?: boolean;
   [key: string | symbol]: unknown;
 }
 
@@ -27,6 +29,7 @@ export function buildBlockDragData(args: {
   containerId: string;
   index: number;
   isContainer: boolean;
+  isReference?: boolean;
 }): BlockDragData {
   return { dragType: "block", ...args };
 }
@@ -43,11 +46,13 @@ export function isBlockDragData(data: Record<string | symbol, unknown>): data is
  * May `source` drop into `dropContainerId`?
  * - A container block may only land at the page root (v1 one-level nesting → no
  *   container-in-container; MAX_BLOCK_DEPTH=2).
+ * - So may a Reference: it is expanded into its sources only at the page root,
+ *   so inside a container it would render nothing.
  * - Nothing may drop onto itself.
  */
 export function canDropBlock(source: BlockDragData, dropContainerId: string): boolean {
   if (source.blockId === dropContainerId) return false;
-  if (source.isContainer && dropContainerId !== ROOT_CONTAINER_ID) return false;
+  if ((source.isContainer || source.isReference) && dropContainerId !== ROOT_CONTAINER_ID) return false;
   return true;
 }
 

package/src/lib/block-move.ts

@@ -2,6 +2,7 @@ import type { LoadedSection } from "./loader";
 import type { Section } from "../schemas/sections";
 import type { SiteIndex, SectionMeta } from "../schemas/site-config";
 import { ROOT_CONTAINER_ID, canDropBlock } from "./block-dnd";
+import { REFERENCE_TYPE } from "./reference-type";
 import { getContainerChildren, reorderChild, insertChildAt, removeChildAt, placeBlockAtColumn, trimTrailingSpacers } from "./container-ops";
 import { reorderVisibleSectionInPage, visibleInsertPosition, addSectionToPage, removeSectionFromPages } from "./pages";
 
@@ -96,6 +97,7 @@ export function applyBlockMove(
     containerId: fromContainerId,
     index: fromIndex,
     isContainer: isContainerSection(draggedSection),
+    isReference: draggedSection.type === REFERENCE_TYPE,
   };
   if (!canDropBlock(dragData, toContainerId)) return noop(state);
 
@@ -200,6 +202,7 @@ function applyColumnPlacement(
     containerId: fromContainerId,
     index: fromIndex,
     isContainer: isContainerSection(draggedSection),
+    isReference: draggedSection.type === REFERENCE_TYPE,
   };
   if (!canDropBlock(dragData, toContainerId)) return noop(state);
 

package/src/lib/brand-swatches.ts

@@ -0,0 +1,32 @@
+import type { Section } from "../schemas/sections";
+import type { ColorItem } from "../components/sections/Colors/schema";
+
+export interface BrandSwatch {
+  hex: string;
+  name: string | undefined;
+}
+
+type Block = { type?: unknown; content?: unknown };
+
+/**
+ * Every hex value from every Colors section, walking container children, in
+ * page order and deduped case-insensitively. Swatches are offered as plain hex
+ * values: color items carry no stable id, so a picked swatch is copied, not linked.
+ */
+export function collectBrandSwatches(sections: Section[]): BrandSwatch[] {
+  const seen = new Map<string, BrandSwatch>();
+  const visit = (block: Block) => {
+    const content = (block.content ?? {}) as { colors?: unknown; children?: unknown };
+    if (block.type === "colors" && Array.isArray(content.colors)) {
+      for (const item of content.colors as ColorItem[]) {
+        for (const space of item.spaces) {
+          const hex = space.hex?.toLowerCase();
+          if (hex && !seen.has(hex)) seen.set(hex, { hex, name: item.name });
+        }
+      }
+    }
+    if (Array.isArray(content.children)) (content.children as Block[]).forEach(visit);
+  };
+  sections.forEach(visit);
+  return [...seen.values()];
+}

package/src/lib/container-ops.ts

@@ -2,6 +2,7 @@ import type { ReactNode } from "react";
 import type { Section } from "../schemas/sections";
 import { getAllSections } from "./registry";
 import { sortInsertMenuOptions } from "./insert-menu";
+import { REFERENCE_TYPE } from "./reference-type";
 
 interface ContainerContent {
   columns: number;
@@ -37,13 +38,14 @@ export function reorderChild(container: Section, from: number, to: number): Sect
 
 /**
  * Block types insertable as a container CHILD — excludes `container` itself
- * (v1 enforces one level of container nesting). Shared so the depth guard has a
- * single, testable source of truth (the container toolbar's "+" picker uses it).
+ * (v1 enforces one level of container nesting) and `reference`, which only
+ * expands at the top level of a page. Shared so the depth guard has a single,
+ * testable source of truth (the container toolbar's "+" picker uses it).
  */
 export function childInsertableTypes(): { type: string; label: string; icon: ReactNode }[] {
   return sortInsertMenuOptions(
     getAllSections()
-      .filter((d) => d.type !== "container" && d.type !== "spacer")
+      .filter((d) => d.type !== "container" && d.type !== "spacer" && d.type !== REFERENCE_TYPE)
       .map((d) => ({ type: d.type, label: d.label, icon: d.icon })),
   );
 }

package/src/lib/dexie.ts

@@ -1,7 +1,13 @@
+// The editor's offline draft store (IndexedDB via Dexie): unsaved section
+// edits, the working index/nav, site config, pending media, and a sha-keyed
+// cache of the last loaded content. Nothing here is authoritative — GitHub is.
+// Schema versions only ever append; an EMPTY `version(N)` bump is intentional
+// (see the per-version notes in the constructor), never a leftover to remove.
 import Dexie from "dexie";
 import type { SectionContent } from "../schemas/sections";
 import type { SiteIndex, SectionMeta, SiteConfig, Page } from "../schemas/site-config";
 import type { NavEntry } from "../schemas/nav";
+import type { TagEntry } from "../schemas/tags";
 import type { LoadedSection } from "./loader";
 import type { MediaManifest, MediaItem } from "../media/types";
 import type { DocumentManifest, DocumentManifestEntry } from "../schemas/documents";
@@ -19,6 +25,9 @@ interface SiteIndexRow {
   sections: Record<string, SectionMeta>;
   /** Optional: rows written before page groups shipped have no nav. */
   nav?: NavEntry[];
+  /** Optional: rows written before section tags shipped have none. Restored
+   *  as absent (not []), which writers read as "leave tags.json alone". */
+  tags?: TagEntry[];
   deletedSections: string[];
   updatedAt: string;
 }
@@ -311,7 +320,10 @@ export async function restoreLocalChanges(): Promise<{
     const siteId = metaRow?.siteId || getDb().siteId;
     return {
       sections,
-      siteIndex: { siteId, pages: indexRow.pages, sections: indexRow.sections, nav: indexRow.nav },
+      siteIndex: {
+        siteId, pages: indexRow.pages, sections: indexRow.sections, nav: indexRow.nav,
+        ...(indexRow.tags !== undefined ? { tags: indexRow.tags } : {}),
+      },
       siteConfig: configRow?.config,
       deletedSections: indexRow.deletedSections ?? [],
     };
@@ -345,6 +357,7 @@ export async function persistSiteIndex(index: SiteIndex, deletedSections: string
       pages: index.pages,
       sections: index.sections,
       nav: index.nav,
+      tags: index.tags,
       deletedSections,
       updatedAt: now,
     });
@@ -465,6 +478,7 @@ export async function persistAll(
           pages: siteIndex.pages,
           sections: siteIndex.sections,
           nav: siteIndex.nav,
+          tags: siteIndex.tags,
           // Record the deletion INTENT, not just its effect on the order. The
           // restore path reads this back; when it was hardcoded `[]` that path
           // had to re-derive deletions by diffing this snapshot against a fresh
@@ -497,6 +511,12 @@ export async function persistAll(
  * 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.
+ *
+ * `tagsDegraded` is required for the same reason. A degraded tags read caches
+ * as "not loaded" (the index without `tags`), so a later cache-hit load stays
+ * read-only for tags instead of trusting the partial list. Only the cold load
+ * used to strip it, so a conflict recovery, remote sync or save re-primed the
+ * row with the partial list and the next cache hit re-enabled tag editing.
  */
 export async function cacheContent(
   sha: string,
@@ -504,6 +524,7 @@ export async function cacheContent(
   index: SiteIndex,
   siteConfig: Record<string, unknown>,
   manifests: { media: MediaManifest; documents: DocumentManifest },
+  tagsDegraded: boolean,
   diff?: {
     savedBranchSha?: string | null;
     changedSectionIds?: string[];
@@ -512,11 +533,12 @@ export async function cacheContent(
   },
 ): Promise<void> {
   const now = new Date().toISOString();
+  const { tags: _partialTags, ...untaggedIndex } = index;
   await getDb().contentCache.put({
     key: "current",
     sha,
     sections,
-    index,
+    index: tagsDegraded ? untaggedIndex : index,
     siteConfig,
     updatedAt: now,
     savedBranchSha: diff?.savedBranchSha ?? null,

package/src/lib/env.ts

@@ -1,3 +1,5 @@
+// env() is a byte-for-byte twin of packages/platform/src/env.ts: platform cannot
+// import primitives without dragging it into apps/admin's bundle, so keep both.
 declare global {
   interface ImportMeta {
     readonly env?: Record<string, string | undefined>;
@@ -11,3 +13,10 @@ export function env(key: string): string {
     ""
   );
 }
+
+/** Vite replaces `import.meta.env.PROD` with a boolean literal at build time
+ *  (packages are `noExternal`, so that covers this file too), which is why the
+ *  declared string type above is bypassed here. False under Node and vitest. */
+export function isProd(): boolean {
+  return (import.meta.env?.PROD as unknown) === true;
+}

package/src/lib/events.ts

@@ -1,4 +1,4 @@
-import type { NavItem, SiteNav } from "./nav";
+import type { SiteNav } from "./nav";
 
 export interface TypedEvent<T> {
   dispatch(detail: T): void;
@@ -19,7 +19,6 @@ export function createEvent<T>(name: string): TypedEvent<T> {
 }
 
 export const editModeEvent = createEvent<{ isEditMode: boolean }>("editmodechange");
-export const navChangeEvent = createEvent<NavItem[]>("sitenavchange");
 export const darkModeEvent = createEvent<string>("sitedarkmode");
 export const siteNameChangeEvent = createEvent<string>("sitenamechange");
 export const historySelectEvent = createEvent<{ sha: string; date: string }>("history-select");

package/src/lib/image-background.ts

@@ -0,0 +1,31 @@
+import type { CSSProperties } from "react";
+import type { ImageBackground, ImageBackgroundSurface } from "../schemas/shared";
+
+// Class names are spelled out in full so Tailwind's source scan emits them.
+// The surface-light/-dark tokens deliberately do NOT flip under `.dark`: a dark
+// plate chosen for light mode must stay dark. The per-mode switch comes from the
+// `dark:` variant instead, so it follows the theme toggle with no JS. An unset
+// dark mode clears a light-mode plate rather than inheriting it.
+const LIGHT_MODE: Record<ImageBackgroundSurface, string | undefined> = {
+  none: undefined,
+  light: "bg-surface-light",
+  dark: "bg-surface-dark",
+};
+const DARK_MODE: Record<ImageBackgroundSurface, string | undefined> = {
+  none: "dark:bg-transparent",
+  light: "dark:bg-surface-light",
+  dark: "dark:bg-surface-dark",
+};
+
+export interface ImageBackdrop {
+  className?: string;
+  style?: CSSProperties;
+}
+
+export function imageBackdrop(bg: ImageBackground | undefined): ImageBackdrop | undefined {
+  if (!bg) return undefined;
+  if (bg.mode === "custom") return { style: { backgroundColor: bg.color } };
+  const light = LIGHT_MODE[bg.light];
+  if (!light && bg.dark === "none") return undefined;
+  return { className: [light, DARK_MODE[bg.dark]].filter(Boolean).join(" ") };
+}

package/src/lib/image-variant-plan.ts

@@ -0,0 +1,92 @@
+import { sanitizeMediaName } from "../media/utils";
+import type { MediaConfig, MediaItem, Variant } from "../schemas/media";
+
+// The one place an uploaded image's identity, storage folder, variant widths,
+// variant paths and manifest entry are decided. Two pixel adapters sit behind
+// it: the editor's OffscreenCanvas worker (media/worker.ts) and the sharp path
+// (authoring processImageBuffers, which the MCP connector calls). They used to
+// build all of this separately and agree only because a comment said so; the
+// site's media settings and dedup each drifted between them once. Pure and
+// browser-safe — the worker imports it.
+
+export interface MediaIdentity {
+  id: string;
+  hash: string;
+  originalName: string;
+  /** Storage dir under assets/images/. Never changes once committed. */
+  folder: string;
+}
+
+/** `hash` is the 16-hex content hash both sides compute (hashFileBuffer / hashBuffer). */
+export function mediaIdentity(hash: string, fileName: string): MediaIdentity {
+  const originalName = sanitizeMediaName(fileName);
+  return { id: hash, hash, originalName, folder: `${originalName}-${hash}` };
+}
+
+/** Repo path of one stored file in a media folder: a variant width, or `poster`. */
+export function imageVariantPath(folder: string, key: number | string): string {
+  return `assets/images/${folder}/${key}.webp`;
+}
+
+export interface ImageVariantPlan extends MediaIdentity {
+  width: number;
+  height: number;
+  /** WebP quality, 1-100. */
+  quality: number;
+  /** Ascending by width. */
+  variants: { width: number; path: string }[];
+}
+
+export function planImageVariants(input: {
+  hash: string;
+  fileName: string;
+  width: number;
+  height: number;
+  media: Pick<MediaConfig, "sizes" | "quality">;
+}): ImageVariantPlan {
+  const identity = mediaIdentity(input.hash, input.fileName);
+  // Never upscale; an image narrower than every configured size still gets one
+  // variant, at its own width.
+  const widths = input.media.sizes.filter((s) => s <= input.width).sort((a, b) => a - b);
+  if (widths.length === 0) widths.push(input.width);
+  return {
+    ...identity,
+    width: input.width,
+    height: input.height,
+    quality: input.media.quality,
+    variants: widths.map((width) => ({ width, path: imageVariantPath(identity.folder, width) })),
+  };
+}
+
+export type ImageManifestEntry = Omit<MediaItem, "kind" | "storage" | "url" | "duration" | "folderId" | "hidden"> & {
+  kind: "image";
+  storage: "github";
+};
+
+/**
+ * `rendered` is what the adapter measured for each planned width (heights come
+ * from the encoder, not the plan). `size` is the adapter's byte count for the
+ * item: the editor records its largest variant, the sharp path the original's
+ * length — they differ today and this module does not decide that.
+ */
+export function imageManifestEntry(plan: ImageVariantPlan, rendered: Variant[], size: number): ImageManifestEntry {
+  const variants = plan.variants.map(({ width }) => {
+    const out = rendered.find((r) => r.width === width);
+    if (!out) throw new Error(`[image-variant-plan] no rendered variant for planned width ${width}`);
+    return { width, height: out.height, size: out.size };
+  });
+  return {
+    id: plan.id,
+    hash: plan.hash,
+    kind: "image",
+    originalName: plan.originalName,
+    width: plan.width,
+    height: plan.height,
+    mimeType: "image/webp",
+    size,
+    folder: plan.folder,
+    variants,
+    alt: "",
+    storage: "github",
+  };
+}

package/src/lib/index-ops.ts

@@ -1,11 +1,12 @@
 import { z } from "zod";
 import { IndexSchema, PageStatusSchema, RESERVED_SLUGS, SLUG_RE, type SiteIndex, type SectionMeta } from "../schemas/site-config";
-import type { NavEntry, NavGroupEntry } from "../schemas/nav";
+import type { NavGroupEntry } from "../schemas/nav";
 import type { NavLocation } from "./nav-tree";
 // Page and nav mutations are shared with the editor rather than reimplemented:
 // both surfaces must agree on what "delete a page" or "remove a group" means, and
 // a second implementation here is how they would drift.
 import { addPage as addPageToIndex, deletePage, slugifyPageSlug, uniquePageSlug } from "./pages";
+import { liftSidecars } from "./sidecars";
 import {
   addGroup, deleteGroup, groupOfPage, moveNavEntry, navEntries, reconcileNav,
   renameGroup, setGroupStartCollapsed,
@@ -254,11 +255,12 @@ export function applyIndexOps(
     };
   }
 
-  // IndexSchema strips `nav` (that strip is what keeps the sidecar out of
-  // index.json), so the authored nav has to be lifted off the RAW input to be
-  // available to the nav ops below. reconcileNav is total, so an unparseable
-  // shape here degrades to a flat nav rather than failing.
-  const rawNav = (rawIndex as { nav?: unknown } | null | undefined)?.nav;
+  // IndexSchema strips `nav` (that strip is what keeps the Sidecar out of
+  // index.json), so the authored nav is lifted off the RAW input to be
+  // available to the nav ops below — as fresh entries, so no op can mutate the
+  // caller's index. reconcileNav is total, so an unreadable nav degrades to a
+  // flat one rather than failing.
+  const lifted = liftSidecars(rawIndex);
 
   // Own copy: the caller's index is also its knownSiteTypes source and may be
   // logged, so nothing here mutates it. Reassigned by the page/nav ops, which
@@ -267,18 +269,7 @@ export function applyIndexOps(
     ...base.data,
     pages: base.data.pages.map((p) => ({ ...p, order: [...p.order] })),
     sections: Object.fromEntries(Object.entries(base.data.sections).map(([k, v]) => [k, { ...v }])),
-    // COPIED, not aliased. Taking the caller's array by reference meant any nav
-    // op that spliced in place would mutate the caller's index — the one thing
-    // this function's own comment promises it never does.
-    ...(Array.isArray(rawNav)
-      ? {
-          nav: (rawNav as NavEntry[]).map((entry) =>
-            entry && typeof entry === "object" && "pageIds" in entry
-              ? { ...entry, pageIds: [...(entry as { pageIds: string[] }).pageIds] }
-              : { ...entry },
-          ),
-        }
-      : {}),
+    ...(lifted.nav ? { nav: lifted.nav.entries } : {}),
   };
 
   const removed = new Set<string>();

package/src/lib/index.ts

@@ -4,6 +4,23 @@ export { audiencePasses } from "./pages";
 export { resolveChatbotName, resolveThinkingPhrases, DEFAULT_CHATBOT_NAME } from "./chatbot";
 export { generateNavLinks, toSectionId, type NavItem } from "./nav";
 export { navEntries, pagesInNavOrder, groupOfPage, groupDisplayLabel, reconcileNav } from "./nav-tree";
+export { siteTags, tagDisplayLabel, reconcileTags } from "./tags";
+export {
+  NAV,
+  TAGS,
+  SIDECARS,
+  readSidecar,
+  readSidecarText,
+  liftSidecars,
+  planSidecarWrite,
+  type SidecarDefinition,
+  type SidecarFileState,
+  type SidecarWritePlan,
+  type SidecarRead,
+  type SidecarDiagnostic,
+} from "./sidecars";
+export { resolveReference, type ReferenceContent } from "./references";
+export { REFERENCE_TYPE } from "./reference-type";
 export {
   deriveContrast,
   contrastColor,
@@ -15,12 +32,11 @@ export {
 } from "./contrast";
 export { primaryVarValue, accentVarValue, onPrimaryVarValue } from "./theme-vars";
 export { sanitizeHtml, ensureSanitizer } from "./sanitize";
-export { gridColsClass } from "./grid";
 export { getIcon, curatedIcons, type IconEntry } from "./icons";
 export { buildGoogleFontsUrl } from "./google-fonts";
 export { formatTimestamp } from "./timestamp";
-export { safeRedirect } from "./safeRedirect";
-export { createEvent, editModeEvent, navChangeEvent, darkModeEvent, type TypedEvent } from "./events";
+export { safeRedirect } from "./safe-redirect";
+export { createEvent, editModeEvent, darkModeEvent, type TypedEvent } from "./events";
 export {
   createRegistry,
   defineSection,
@@ -42,7 +58,7 @@ export {
 export {
   mergeSiteContent,
   loadStaticSiteContent,
-  loadSiteContent,
   type LoadedSection,
   type SiteContent,
+  type SidecarReads,
 } from "./loader";