@drawnagency/primitives 0.1.113 → 0.1.115

package/dist/chunk-APIJPTFG.js

@@ -0,0 +1,64 @@
+// src/schemas/media.ts
+import { z } from "zod";
+var VariantSchema = z.object({
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  size: z.number().int().nonnegative()
+});
+var MediaFolderSchema = z.object({
+  name: z.string().min(1),
+  parentId: z.string().nullable()
+  // null = root
+});
+var MediaItemSchema = z.object({
+  id: z.string(),
+  hash: z.string(),
+  kind: z.enum(["image", "animated", "video"]),
+  originalName: z.string(),
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  mimeType: z.string(),
+  size: z.number().int().nonnegative(),
+  folder: z.string(),
+  variants: z.array(VariantSchema),
+  alt: z.string().default(""),
+  // Where the original bytes live. "github" = committed to the repo (images,
+  // small loops); "assets" = large original in the AssetStore bucket. Legacy
+  // manifests have no field — default keeps them on the git path.
+  storage: z.enum(["github", "assets"]).default("github"),
+  // Public CDN URL for assets-backed originals, baked at upload time so
+  // resolution needs no env access in the browser or at SSR.
+  url: z.string().optional(),
+  // Seconds; videos only. Informational (library UI).
+  duration: z.number().positive().optional(),
+  // Display folder (MediaFolderSchema key). Absent = root/unfiled. NOT the
+  // git storage dir — that's `folder` above, which never changes.
+  folderId: z.string().optional(),
+  // System-generated assets (e.g. the Phase 3 social-preview raster) set this
+  // so the media-library UI can exclude them. Absent on all user uploads.
+  hidden: z.boolean().optional()
+});
+var ImageManifestSchema = z.object({
+  images: z.record(z.string(), MediaItemSchema),
+  folders: z.record(z.string(), MediaFolderSchema).default({})
+});
+var MEDIA_GIT_MAX_BYTES = 5242880;
+var MEDIA_BUCKET_MAX_BYTES = 209715200;
+var MediaConfigSchema = z.object({
+  sizes: z.array(z.number()).default([640, 1080, 1920]),
+  maxFileSize: z.number().default(MEDIA_GIT_MAX_BYTES),
+  quality: z.number().min(1).max(100).default(85),
+  // Per-file cap for bucket-backed video uploads (bytes). The git-path cap is
+  // maxFileSize; anything between the two routes to the AssetStore.
+  maxAssetSize: z.number().default(MEDIA_BUCKET_MAX_BYTES)
+});
+
+export {
+  VariantSchema,
+  MediaFolderSchema,
+  MediaItemSchema,
+  ImageManifestSchema,
+  MEDIA_GIT_MAX_BYTES,
+  MEDIA_BUCKET_MAX_BYTES,
+  MediaConfigSchema
+};

package/dist/{chunk-WKZ7OENC.js → chunk-BQ5TZZUE.js}

@@ -2,7 +2,11 @@
 function env(key) {
   return import.meta.env?.[key] ?? (typeof process !== "undefined" ? process.env?.[key] : void 0) ?? "";
 }
+function isProd() {
+  return import.meta.env?.PROD === true;
+}
 
 export {
-  env
+  env,
+  isProd
 };

package/dist/chunk-CDBURDPX.js

@@ -0,0 +1,90 @@
+import {
+  slugifyPageSlug
+} from "./chunk-S7QRHUWO.js";
+
+// src/media/utils.ts
+async function hashFileBuffer(buffer) {
+  if (typeof crypto !== "undefined" && crypto.subtle) {
+    const hashBuffer = await crypto.subtle.digest("SHA-256", buffer);
+    const hashArray = new Uint8Array(hashBuffer);
+    return Array.from(hashArray.slice(0, 8)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  const bytes = new Uint8Array(buffer);
+  const seeds = [2166136261, 84696351];
+  let result = "";
+  for (const seed of seeds) {
+    let h = seed;
+    for (let i = 0; i < bytes.length; i++) {
+      h ^= bytes[i];
+      h = Math.imul(h, 16777619);
+    }
+    result += (h >>> 0).toString(16).padStart(8, "0");
+  }
+  return result;
+}
+function sanitizeMediaName(name) {
+  return slugifyPageSlug(name.replace(/\.[^.]+$/, ""));
+}
+var MIME_TO_EXT = {
+  "image/gif": "gif",
+  "image/apng": "apng",
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "image/svg+xml": "svg",
+  "video/mp4": "mp4",
+  "video/webm": "webm"
+};
+var EXT_TO_MIME = {
+  ...Object.fromEntries(
+    Object.entries(MIME_TO_EXT).map(([mime, ext]) => [`.${ext}`, mime])
+  ),
+  ".jpeg": "image/jpeg"
+};
+function mimeToExt(mime) {
+  return MIME_TO_EXT[mime] ?? "bin";
+}
+function mediaThumbnailUrl(item) {
+  if (item.mimeType === "image/svg+xml" || item.kind !== "image") {
+    return `/api/media/${item.id}/original.${mimeToExt(item.mimeType)}`;
+  }
+  if (item.variants.length === 0) return null;
+  const smallest = item.variants.reduce((a, b) => a.width < b.width ? a : b);
+  return `/api/media/${item.id}/${smallest.width}.webp`;
+}
+function imageThumbnailUrl(item) {
+  return item?.kind === "image" ? mediaThumbnailUrl(item) : null;
+}
+function displayFilenameExt(mime) {
+  const ext = MIME_TO_EXT[mime];
+  return ext ? `.${ext}` : "";
+}
+function displayFilename(originalName, mimeType) {
+  const ext = MIME_TO_EXT[mimeType];
+  if (!ext) return originalName;
+  const suffix = `.${ext}`;
+  if (originalName.toLowerCase().endsWith(suffix)) return originalName;
+  return `${originalName}${suffix}`;
+}
+function formatFileSize(bytes) {
+  if (bytes >= 1048576) return `${Math.round(bytes / 1048576)}MB`;
+  if (bytes >= 1024) return `${Math.round(bytes / 1024)}KB`;
+  return `${bytes}B`;
+}
+function displayName(item) {
+  return item.originalName;
+}
+
+export {
+  hashFileBuffer,
+  sanitizeMediaName,
+  MIME_TO_EXT,
+  EXT_TO_MIME,
+  mimeToExt,
+  mediaThumbnailUrl,
+  imageThumbnailUrl,
+  displayFilenameExt,
+  displayFilename,
+  formatFileSize,
+  displayName
+};

package/dist/chunk-DIMDRBFK.js

@@ -0,0 +1,11 @@
+// src/lib/reorder.ts
+function computeReorderTarget(fromIndex, overIndex, edge) {
+  let toIndex = overIndex;
+  if (edge === "bottom") toIndex = overIndex + 1;
+  if (fromIndex < toIndex) toIndex--;
+  return fromIndex === toIndex ? null : toIndex;
+}
+
+export {
+  computeReorderTarget
+};

package/dist/chunk-DJABADOO.js

@@ -0,0 +1,131 @@
+import {
+  reconcileNavReport
+} from "./chunk-DJOGPSRU.js";
+import {
+  mergeTags,
+  reconcileTagsReport
+} from "./chunk-4WQ36ZP7.js";
+import {
+  NavEntrySchema,
+  NavFileSchema,
+  TagEntrySchema,
+  TagsFileSchema
+} from "./chunk-4Y2JQQZL.js";
+
+// src/lib/sidecars.ts
+var NAV = {
+  name: "nav",
+  path: "src/content/nav.json",
+  fileKey: "entries",
+  entrySchema: NavEntrySchema,
+  fileSchema: NavFileSchema,
+  reconcile: (entries, index) => reconcileNavReport(entries, index.pages),
+  // Grouping is edited rarely and has no dirty tracking, so persisted remote
+  // state beats unsaved local edits. A remote without the Sidecar (an older
+  // server) keeps ours rather than flattening it.
+  rebase: ({ local, remote }) => remote !== void 0 ? remote : local,
+  words: {
+    entries: "navigation entries",
+    changes: "Page grouping changes",
+    valid: "a valid navigation tree",
+    shape: 'an array of {kind:"page",pageId} / {kind:"group",id,label,startCollapsed,pageIds} entries'
+  }
+};
+var TAGS = {
+  name: "tags",
+  path: "src/content/tags.json",
+  fileKey: "tags",
+  entrySchema: TagEntrySchema,
+  fileSchema: TagsFileSchema,
+  reconcile: (entries, index) => reconcileTagsReport(entries, index.sections),
+  // Tagging is edited from every section's chrome, so remote-wins would drop
+  // unsaved tagging whenever a peer saved anything. See mergeTags.
+  rebase: mergeTags,
+  words: {
+    entries: "tag entries",
+    changes: "Tag changes",
+    valid: "a valid tag list",
+    shape: "an array of {id,label,sectionIds} entries"
+  }
+};
+var SIDECARS = [NAV, TAGS];
+function readEntries(def, raw) {
+  if (!Array.isArray(raw)) {
+    console.warn(`[sidecars] ${def.name}: entry list is not a list; reading it as empty and degraded`);
+    return { entries: [], degraded: true };
+  }
+  const entries = [];
+  let dropped = 0;
+  for (const item of raw) {
+    const parsed = def.entrySchema.safeParse(item);
+    if (parsed.success) entries.push(parsed.data);
+    else dropped++;
+  }
+  if (dropped > 0) {
+    console.warn(`[sidecars] ${def.name}: dropped ${dropped} entr${dropped === 1 ? "y" : "ies"} this package version cannot represent; the read is degraded`);
+  }
+  return { entries, degraded: dropped > 0 };
+}
+function readSidecar(def, file) {
+  if (file === void 0 || file === null) return { entries: [], degraded: false };
+  return readEntries(def, file[def.fileKey]);
+}
+function readSidecarText(def, text) {
+  if (text === void 0) return { entries: [], degraded: false };
+  let file;
+  try {
+    file = JSON.parse(text);
+  } catch {
+    console.warn(`[sidecars] ${def.name}: ${def.path} is not valid JSON; the read is degraded`);
+    return { entries: [], degraded: true };
+  }
+  return readSidecar(def, file);
+}
+function liftSidecars(rawIndex) {
+  const raw = rawIndex !== null && typeof rawIndex === "object" ? rawIndex : {};
+  return {
+    ...raw.nav !== void 0 ? { nav: readEntries(NAV, raw.nav) } : {},
+    ...raw.tags !== void 0 ? { tags: readEntries(TAGS, raw.tags) } : {}
+  };
+}
+function planSidecarWrite(def, posted, branch, index) {
+  if (posted === void 0) return { action: "untouched" };
+  const skip = (reason) => ({
+    action: "skip",
+    warning: `${def.path} was left unchanged: ${reason} ${def.words.changes} from this save did not land. Upgrade the site's @drawnagency packages (or repair ${def.path} directly in the repo), then retry.`
+  });
+  if (posted.degraded) {
+    return {
+      action: "skip",
+      warning: `${def.name} was not ${def.words.valid}, so ${def.path} was left unchanged (it held entries this package version cannot read). Expected ${def.words.shape}.`
+    };
+  }
+  if (branch.kind === "unreadable") {
+    return skip("the current file could not be read to confirm the replacement loses nothing.");
+  }
+  if (branch.kind === "present") {
+    let existing;
+    try {
+      existing = JSON.parse(branch.text);
+    } catch {
+      return skip("the current file is not valid JSON, so this version cannot prove a replacement keeps its entries.");
+    }
+    if (!def.fileSchema.safeParse(existing).success) {
+      return skip(`the current file holds ${def.words.entries} this package version cannot represent (likely written by a newer version).`);
+    }
+  } else if (posted.entries.length === 0) {
+    return { action: "untouched" };
+  }
+  const { entries } = def.reconcile(posted.entries, index);
+  return { action: "write", path: def.path, content: JSON.stringify({ [def.fileKey]: entries }, null, 2) };
+}
+
+export {
+  NAV,
+  TAGS,
+  SIDECARS,
+  readSidecar,
+  readSidecarText,
+  liftSidecars,
+  planSidecarWrite
+};

package/dist/{chunk-NHN2LSIU.js → chunk-DJOGPSRU.js}

@@ -1,9 +1,13 @@
 import {
-  RESERVED_SLUGS
-} from "./chunk-AHALSCQH.js";
+  diagnosticsCollector
+} from "./chunk-GNF6KFQ7.js";
 
 // src/lib/nav-tree.ts
 function reconcileNav(entries, pages) {
+  return reconcileNavReport(entries, pages).entries;
+}
+function reconcileNavReport(entries, pages) {
+  const report = diagnosticsCollector();
   const entryList = Array.isArray(entries) ? entries : [];
   const pageList = Array.isArray(pages) ? pages : [];
   const validIds = /* @__PURE__ */ new Set();
@@ -15,18 +19,36 @@ function reconcileNav(entries, pages) {
   const result = [];
   for (const entry of entryList) {
     if (entry?.kind === "page") {
-      if (!validIds.has(entry.pageId) || placed.has(entry.pageId)) continue;
+      if (!validIds.has(entry.pageId)) {
+        report.add("dangling", entry.pageId);
+        continue;
+      }
+      if (placed.has(entry.pageId)) {
+        report.add("duplicate-member", entry.pageId);
+        continue;
+      }
       placed.add(entry.pageId);
       result.push({ ...entry });
       continue;
     }
     if (entry?.kind !== "group") continue;
     if (typeof entry.id !== "string" || entry.id === "") continue;
-    if (seenGroupIds.has(entry.id)) continue;
+    if (seenGroupIds.has(entry.id)) {
+      report.add("duplicate-id", entry.id);
+      continue;
+    }
     seenGroupIds.add(entry.id);
     const claimed = Array.isArray(entry.pageIds) ? entry.pageIds : [];
     const pageIds = claimed.filter((id) => {
-      if (typeof id !== "string" || !validIds.has(id) || placed.has(id)) return false;
+      if (typeof id !== "string") return false;
+      if (!validIds.has(id)) {
+        report.add("dangling", id);
+        return false;
+      }
+      if (placed.has(id)) {
+        report.add("duplicate-member", id);
+        return false;
+      }
       placed.add(id);
       return true;
     });
@@ -42,9 +64,10 @@ function reconcileNav(entries, pages) {
   for (const p of pageList) {
     if (!p?.id || placed.has(p.id)) continue;
     placed.add(p.id);
+    report.add("unlisted", p.id);
     result.push({ kind: "page", pageId: p.id });
   }
-  return result;
+  return { entries: result, diagnostics: report.list() };
 }
 function navEntries(index) {
   return reconcileNav(index.nav ?? [], index.pages);
@@ -132,64 +155,9 @@ function moveNavEntry(index, from, to) {
   return withNav(index, entries);
 }
 
-// src/lib/pages.ts
-function slugifyPageSlug(input) {
-  return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function uniquePageSlug(base, existing) {
-  const taken = new Set(existing);
-  const reserved = new Set(RESERVED_SLUGS);
-  let candidate = base || "page";
-  if (!taken.has(candidate) && !reserved.has(candidate)) return candidate;
-  let n = 2;
-  while (taken.has(`${candidate}-${n}`) || reserved.has(`${candidate}-${n}`)) n++;
-  return `${candidate}-${n}`;
-}
-function pageById(index, id) {
-  return index.pages.find((p) => p.id === id);
-}
-function audiencePasses(access, audience) {
-  if (access.length === 0) return true;
-  if (!audience) return true;
-  return access.includes(audience);
-}
-function addPage(index, id) {
-  const slug = uniquePageSlug("new-page", index.pages.map((p) => p.slug));
-  const page = {
-    id,
-    title: "",
-    slug,
-    isHome: false,
-    showInNav: true,
-    status: "live",
-    access: [],
-    order: []
-  };
-  return {
-    ...index,
-    pages: [...index.pages, page],
-    nav: [...navEntries(index), { kind: "page", pageId: id }]
-  };
-}
-function deletePage(index, pageId) {
-  const page = pageById(index, pageId);
-  if (!page || page.isHome) return { index, removedSectionIds: [] };
-  const removedSectionIds = [...page.order];
-  const nextSections = { ...index.sections };
-  for (const id of removedSectionIds) delete nextSections[id];
-  return {
-    index: {
-      ...index,
-      pages: index.pages.filter((p) => p.id !== pageId),
-      sections: nextSections,
-      nav: navEntries(index).filter((e) => !(e.kind === "page" && e.pageId === pageId)).map((e) => e.kind === "group" ? { ...e, pageIds: e.pageIds.filter((id) => id !== pageId) } : e)
-    },
-    removedSectionIds
-  };
-}
-
 export {
   reconcileNav,
+  reconcileNavReport,
   navEntries,
   pagesInNavOrder,
   groupOfPage,
@@ -198,10 +166,5 @@ export {
   renameGroup,
   setGroupStartCollapsed,
   deleteGroup,
-  moveNavEntry,
-  slugifyPageSlug,
-  uniquePageSlug,
-  audiencePasses,
-  addPage,
-  deletePage
+  moveNavEntry
 };