@drawnagency/primitives 0.1.113 → 0.1.115

package/src/media/worker.ts

@@ -1,3 +1,5 @@
+import { planImageVariants, type ImageVariantPlan } from "../lib/image-variant-plan";
+
 interface ProcessMessage {
   type: "process";
   id: string;
@@ -24,6 +26,8 @@ interface CompleteMessage {
   posterBlob?: Blob;
   width: number;
   height: number;
+  /** Static images only — the shared plan the variants were rendered from. */
+  plan?: ImageVariantPlan;
 }
 
 interface ErrorMessage {
@@ -77,13 +81,17 @@ self.onmessage = async (e: MessageEvent<ProcessMessage>) => {
 
     post({ type: "progress", id: msg.id, percent: 25 });
 
-    const applicableSizes = msg.sizes
-      .filter((s) => s <= origWidth)
-      .sort((a, b) => b - a);
-
-    if (applicableSizes.length === 0) {
-      applicableSizes.push(origWidth);
-    }
+    // Widths, names and paths come from the shared plan (the sharp path uses
+    // the same one); this worker only draws. Encoded largest first so the
+    // primary blob is the largest variant.
+    const plan = planImageVariants({
+      hash: msg.hash,
+      fileName: msg.originalName,
+      width: origWidth,
+      height: origHeight,
+      media: { sizes: msg.sizes, quality: msg.quality },
+    });
+    const applicableSizes = plan.variants.map((v) => v.width).reverse();
 
     const variants: { width: number; height: number; size: number; blob: Blob }[] = [];
     const totalVariants = applicableSizes.length;
@@ -97,7 +105,7 @@ self.onmessage = async (e: MessageEvent<ProcessMessage>) => {
       const ctx = canvas.getContext("2d")!;
       ctx.drawImage(bitmap, 0, 0, targetWidth, targetHeight);
 
-      const blob = await canvas.convertToBlob({ type: "image/webp", quality: msg.quality / 100 });
+      const blob = await canvas.convertToBlob({ type: "image/webp", quality: plan.quality / 100 });
       variants.push({ width: targetWidth, height: targetHeight, size: blob.size, blob });
 
       const percent = 25 + Math.round(((i + 1) / totalVariants) * 75);
@@ -114,6 +122,7 @@ self.onmessage = async (e: MessageEvent<ProcessMessage>) => {
       primaryBlob,
       width: origWidth,
       height: origHeight,
+      plan,
     });
   } catch (err) {
     const message = err instanceof Error ? err.message : "Processing failed";

package/src/schemas/index.ts

@@ -2,6 +2,7 @@ export * from "./shared";
 export * from "./sections";
 export * from "./site-config";
 export * from "./nav";
+export * from "./tags";
 export * from "./media";
 export * from "./audience";
 export * from "./media-grid-options";

package/src/schemas/media.ts

@@ -55,13 +55,18 @@ export const ImageManifestSchema = z.object({
 
 export type MediaManifest = z.infer<typeof ImageManifestSchema>;
 
+/** Default git-tier cap for media (bytes); a site may override it as `media.maxFileSize`. */
+export const MEDIA_GIT_MAX_BYTES = 5_242_880;
+/** Default bucket-tier cap for media (bytes); a site may override it as `media.maxAssetSize`. */
+export const MEDIA_BUCKET_MAX_BYTES = 209_715_200;
+
 export const MediaConfigSchema = z.object({
   sizes: z.array(z.number()).default([640, 1080, 1920]),
-  maxFileSize: z.number().default(5242880),
+  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(209_715_200),
+  maxAssetSize: z.number().default(MEDIA_BUCKET_MAX_BYTES),
 });
 
 export type MediaConfig = z.infer<typeof MediaConfigSchema>;

package/src/schemas/shared.ts

@@ -38,7 +38,7 @@ const BaseMediaRef = z.object({
     .union([z.string(), z.array(z.string())])
     .optional()
     .describe("Optional caption: a single string, or multiple lines as an array of strings."),
-  background: z.string().optional().describe("Optional CSS background color/value shown behind a transparent image."),
+  background: z.string().optional().describe("Legacy; not rendered. For a backdrop behind a media section's image, use the section's options.background."),
   invertFrom: z
     .string()
     .optional()
@@ -91,6 +91,29 @@ export const HexColorSchema = z
   .string()
   .regex(/^#[0-9a-fA-F]{6}$/, "must be a 6-digit hex color");
 
+const ImageBackgroundSurfaceSchema = z.enum(["none", "light", "dark"]);
+export type ImageBackgroundSurface = z.infer<typeof ImageBackgroundSurfaceSchema>;
+
+/** Per-placement backdrop painted behind an image (e.g. a dark plate under a
+ *  white transparent logo). Absent = no backdrop. */
+export const ImageBackgroundSchema = z.discriminatedUnion("mode", [
+  z.object({
+    mode: z.literal("theme").describe("Pick a site surface separately for light and dark mode."),
+    light: ImageBackgroundSurfaceSchema.describe(
+      "Backdrop in light mode: 'none', the site's light surface, or its dark surface.",
+    ),
+    dark: ImageBackgroundSurfaceSchema.describe(
+      "Backdrop in dark mode: 'none', the site's light surface, or its dark surface.",
+    ),
+  }),
+  z.object({
+    mode: z.literal("custom").describe("Use one custom color in both modes."),
+    color: HexColorSchema.describe("One backdrop color for both light and dark mode, as a 6-digit hex."),
+  }),
+]);
+
+export type ImageBackground = z.infer<typeof ImageBackgroundSchema>;
+
 // Font-family names are interpolated raw into the `style` attribute on <html>
 // (`--font-heading: ${headingFont}, ...`). Astro HTML-escapes the attribute, so
 // the residual risk is CSS-declaration injection via `;`/`{}`. Allow only the

package/src/schemas/site-config.ts

@@ -7,6 +7,7 @@ import { CORNER_RADIUS_OPTIONS } from "../lib/corner-radius";
 // document options block onto PageSchema.
 import { documentOptionsSchema } from "../document/engine/settings";
 import type { NavEntry } from "./nav";
+import type { TagEntry } from "./tags";
 
 export const StatusSchema = z.enum(["draft", "live", "archived", "published"]).transform(
   (val) => val === "published" ? "live" as const : val,
@@ -176,8 +177,12 @@ export const IndexSchema = RawIndexSchema.transform(normalizeRawIndex).pipe(Cano
  * index.json. It is optional because most SiteIndex values (tests, legacy
  * content, partial writes) have no nav — reads go through navEntries(), which
  * reconciles a missing nav into a flat one.
+ *
+ * `tags` follows the same rules for the src/content/tags.json sidecar; read it
+ * only through siteTags() (lib/tags.ts). Absent means "not loaded", which every
+ * writer treats as "leave tags.json alone" — not as "no tags".
  */
-export type SiteIndex = z.infer<typeof CanonicalIndexSchema> & { nav?: NavEntry[] };
+export type SiteIndex = z.infer<typeof CanonicalIndexSchema> & { nav?: NavEntry[]; tags?: TagEntry[] };
 
 /** Parse + normalize any raw index (legacy or canonical) to the canonical shape. */
 export function normalizeSiteIndex(raw: unknown): SiteIndex {

package/src/schemas/tags.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+
+/**
+ * The site's section tags, persisted to `src/content/tags.json`.
+ *
+ * A sidecar for the same reason nav.json is (see schemas/nav.ts): an older
+ * writer re-serializes the Zod-parsed index and silently deletes any key it
+ * does not know, so tags must never be a key on index.json or a section file.
+ *
+ * Each tag owns its assignments (`sectionIds`), so deleting a tag removes it
+ * from every section by construction; a deleted section is pruned by
+ * `reconcileTags` (lib/tags.ts). Array order is the registry's display order.
+ */
+export const TagEntrySchema = z.object({
+  id: z.string().min(1),
+  /** May be blank — agent-authored files can omit it; UI falls back to "Untitled tag". */
+  label: z.string().catch(""),
+  // Everything but `id` repairs rather than rejects. A rejected entry marks the
+  // read degraded, and a degraded tags.json refuses EVERY tags write until
+  // someone fixes the file by hand — far too heavy a price for one blank id in
+  // one tag's list, which reconcileTags would drop anyway.
+  sectionIds: z
+    .array(z.unknown())
+    .catch([])
+    .transform((ids) => ids.filter((id): id is string => typeof id === "string" && id !== "")),
+});
+
+export const TagsFileSchema = z.object({
+  tags: z.array(TagEntrySchema),
+});
+
+export type TagEntry = z.infer<typeof TagEntrySchema>;
+export type TagsFile = z.infer<typeof TagsFileSchema>;

package/src/storage/memory.ts

@@ -0,0 +1,178 @@
+import {
+  IDEMPOTENCY_TRAILER,
+  NothingToPublishError,
+  StorageConflictError,
+  type FileWrite,
+  type StorageProvider,
+} from "./types";
+
+// An in-memory StorageProvider with real commit history: a `main` branch, an
+// optional draft branch, and commits addressable by sha. It exists so the write
+// path can be tested end to end without mocking it, which is only worth
+// anything if it behaves like the GitHub adapter — the storage contract suite
+// runs the same cases against both. Anything that differs from GitHub here is a
+// bug in this file.
+
+type Tree = Map<string, Uint8Array>;
+type Commit = { tree: Tree; parent: string | null; message: string };
+type Files = Record<string, string | Uint8Array | null>;
+
+// Mirrors promoteDraft in the GitHub adapter: only these subtrees publish;
+// everything else on main is inherited from main.
+const PUBLISHED_PREFIXES = ["src/content/", "assets/"];
+
+export type MemoryStorage = StorageProvider & {
+  /**
+   * Commit straight to a branch as another writer would — a concurrent editor
+   * save on the draft (created from main if absent), or a merge onto main.
+   * Returns the new commit's sha.
+   */
+  commit(branch: "main" | "draft", files: Files, message?: string): string;
+  /**
+   * Run `fn` once at the start of the next `writeFiles`, before its
+   * `baseVersion` check: a writer landing between a caller's read and its write.
+   */
+  beforeNextWrite(fn: () => void): void;
+};
+
+export function createMemoryStorage(seed: { main?: Files; draft?: Files } = {}): MemoryStorage {
+  const commits = new Map<string, Commit>();
+  let counter = 0;
+  let mainHead: string;
+  let draftHead: string | null = null;
+  let pendingHook: (() => void) | null = null;
+
+  function newCommit(tree: Tree, parent: string | null, message: string): string {
+    counter += 1;
+    const sha = counter.toString(16).padStart(40, "0");
+    commits.set(sha, { tree, parent, message });
+    return sha;
+  }
+
+  function applyFiles(base: Tree, files: Files): Tree {
+    const tree = new Map(base);
+    for (const [path, content] of Object.entries(files)) {
+      if (content === null) tree.delete(path);
+      else tree.set(path, toBytes(content));
+    }
+    return tree;
+  }
+
+  function commitTo(branch: "main" | "draft", files: Files, message = "commit"): string {
+    if (branch === "main") {
+      mainHead = newCommit(applyFiles(commits.get(mainHead)!.tree, files), mainHead, message);
+      return mainHead;
+    }
+    const parent = draftHead ?? mainHead;
+    draftHead = newCommit(applyFiles(commits.get(parent)!.tree, files), parent, message);
+    return draftHead;
+  }
+
+  // Unknown branch or sha reads as absent, as GitHub's 404 does.
+  function treeFor(options?: { draft?: boolean; at?: string }): Tree | null {
+    if (options?.at !== undefined) return commits.get(options.at)?.tree ?? null;
+    if (options?.draft) return draftHead === null ? null : commits.get(draftHead)!.tree;
+    return commits.get(mainHead)!.tree;
+  }
+
+  function checkBase(options?: { baseVersion?: string | null }): void {
+    if (options && "baseVersion" in options) {
+      const expected = options.baseVersion ?? null;
+      if (expected !== draftHead) throw new StorageConflictError(draftHead);
+    }
+  }
+
+  mainHead = newCommit(applyFiles(new Map(), seed.main ?? {}), null, "initial");
+  if (seed.draft) commitTo("draft", seed.draft, "seed draft");
+
+  return {
+    commit: commitTo,
+
+    beforeNextWrite(fn) {
+      pendingHook = fn;
+    },
+
+    async writeFiles(files: FileWrite[], message: string, options?: { baseVersion?: string | null }) {
+      const hook = pendingHook;
+      pendingHook = null;
+      hook?.();
+
+      checkBase(options);
+      if (files.length === 0) return { version: draftHead ?? mainHead };
+
+      const parentTree = commits.get(draftHead ?? mainHead)!.tree;
+      const changes: Files = {};
+      for (const file of files) {
+        // GitHub's createTree rejects deleting a path its base tree does not hold.
+        if (file.content === null && !parentTree.has(file.path)) {
+          throw new Error(`Cannot delete ${file.path}: it is not on the branch`);
+        }
+        changes[file.path] =
+          file.content === null || file.content instanceof Uint8Array || file.encoding !== "base64"
+            ? file.content
+            : fromBase64(file.content);
+      }
+      return { version: commitTo("draft", changes, message) };
+    },
+
+    async readFile(path, options) {
+      return treeFor(options)?.get(path) ?? null;
+    },
+
+    async listDirectory(path, options) {
+      const tree = treeFor(options);
+      if (!tree) return [];
+      const prefix = path.endsWith("/") ? path : `${path}/`;
+      const names: string[] = [];
+      for (const key of tree.keys()) {
+        if (!key.startsWith(prefix)) continue;
+        const rest = key.slice(prefix.length);
+        if (!rest.includes("/")) names.push(rest);
+      }
+      return names;
+    },
+
+    async getVersion() {
+      return mainHead;
+    },
+
+    async getDraftVersion() {
+      return draftHead;
+    },
+
+    async promoteDraft() {
+      if (draftHead === null) throw new NothingToPublishError();
+      const draft = commits.get(draftHead)!.tree;
+      const main = commits.get(mainHead)!.tree;
+      const published = (p: string) => PUBLISHED_PREFIXES.some((prefix) => p.startsWith(prefix));
+      if (![...draft.keys(), ...main.keys()].some(published)) {
+        throw new Error("No editor-managed content found on the saved branch — refusing to publish.");
+      }
+      const tree = new Map([...main].filter(([p]) => !published(p)));
+      for (const [p, bytes] of draft) if (published(p)) tree.set(p, bytes);
+      mainHead = newCommit(tree, mainHead, "Publish content via Brand Portal");
+      draftHead = null;
+      return { version: mainHead };
+    },
+
+    async findCommitByIdempotencyKey(key, options) {
+      const limit = Math.min(Math.max(options?.limit ?? 30, 1), 100);
+      const trailer = `${IDEMPOTENCY_TRAILER}: ${key}`;
+      let sha = draftHead;
+      for (let seen = 0; sha !== null && seen < limit; seen += 1) {
+        const commit = commits.get(sha)!;
+        if (commit.message.split("\n").some((line) => line.trim() === trailer)) return sha;
+        sha = commit.parent;
+      }
+      return null;
+    },
+  };
+}
+
+function toBytes(content: string | Uint8Array): Uint8Array {
+  return typeof content === "string" ? new TextEncoder().encode(content) : content;
+}
+
+function fromBase64(content: string): Uint8Array {
+  return Uint8Array.from(atob(content), (c) => c.charCodeAt(0));
+}

package/src/storage/types.ts

@@ -34,16 +34,29 @@ export interface StorageProvider {
     options?: { baseVersion?: string | null },
   ): Promise<{ version: string }>;
 
+  // `draft` reads the draft branch by name: null when there is no draft — a
+  // caller that wants "draft, else main" falls back itself. `at` reads as of a
+  // commit and wins over `draft`. Two reads by branch name can see two different
+  // commits moments after a write, so a read that must agree with another read
+  // (an index and the listing it is diffed against) pins both to one commit.
   readFile(
     path: string,
-    options?: { draft?: boolean },
+    options?: { draft?: boolean; at?: string },
   ): Promise<Uint8Array | null>;
 
   promoteDraft(): Promise<{ version: string }>;
 
+  /** The published branch's head. Never a valid `baseVersion`. */
   getVersion(): Promise<string>;
 
-  listDirectory(path: string, options?: { draft?: boolean }): Promise<string[]>;
+  /**
+   * The draft branch's head, or null when no draft exists — exactly the value
+   * `writeFiles` accepts as `baseVersion`.
+   */
+  getDraftVersion(): Promise<string | null>;
+
+  /** File basenames directly under `path` (no subdirectories); `[]` when absent. Same options as `readFile`. */
+  listDirectory(path: string, options?: { draft?: boolean; at?: string }): Promise<string[]>;
 
   /**
    * Find a recent commit on the draft branch whose message carries the given
@@ -86,7 +99,7 @@ export interface StorageProvider {
  */
 export class IdempotencyLookupUnavailableError extends Error {
   constructor(override readonly cause?: unknown) {
-    super("Could not search draft history for the idempotency key");
+    super("Couldn't search draft history for the idempotency key");
     this.name = "IdempotencyLookupUnavailableError";
   }
 }

package/src/types/database.ts

@@ -1,3 +1,5 @@
+// GENERATED by Supabase CLI — do not edit by hand.
+// Regenerate with `pnpm generate-types` after every migration.
 export type Json =
   | string
   | number

package/dist/chunk-DNY72JZN.js

@@ -1,86 +0,0 @@
-import {
-  getContainerChildren
-} from "./chunk-CXZ5YJG4.js";
-import {
-  getSection
-} from "./chunk-FTPETWXE.js";
-
-// src/lib/nav.ts
-function toSectionId(text) {
-  const slug = text.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/^-+|-+$/g, "");
-  if (slug) return slug;
-  let hash = 0;
-  for (let i = 0; i < text.length; i++) {
-    hash = (hash << 5) - hash + text.charCodeAt(i) | 0;
-  }
-  return `section-${Math.abs(hash).toString(36)}`;
-}
-function flattenForNav(sections) {
-  const flat = [];
-  const walk = (loaded) => {
-    flat.push(loaded);
-    for (const child of getContainerChildren(loaded.section)) {
-      walk({ section: child, meta: loaded.meta });
-    }
-  };
-  sections.forEach(walk);
-  return flat;
-}
-function generateNavLinks(sections, registry) {
-  const nav = [];
-  let currentParent = null;
-  let currentChild = null;
-  const lookupRole = (type) => {
-    const def = registry ? registry.getSection(type) : getSection(type);
-    return def?.navRole;
-  };
-  for (const { section, meta } of flattenForNav(sections)) {
-    const content = section.content;
-    if (!content.heading) continue;
-    const role = lookupRole(section.type);
-    if (!role) continue;
-    if (role === "h1") {
-      if (content.excludeFromNav) {
-        currentParent = null;
-        currentChild = null;
-        continue;
-      }
-      currentParent = {
-        href: `#${toSectionId(content.heading)}`,
-        label: content.heading,
-        status: meta.status,
-        children: []
-      };
-      currentChild = null;
-      nav.push(currentParent);
-    } else if (role === "h2") {
-      if (content.excludeFromNav) {
-        currentChild = null;
-        continue;
-      }
-      if (!currentParent) continue;
-      currentChild = {
-        href: `#${toSectionId(content.heading)}`,
-        label: content.heading,
-        status: meta.status,
-        children: []
-      };
-      currentParent.children.push(currentChild);
-    } else if (role === "h3") {
-      if (content.excludeFromNav) continue;
-      if (!currentChild) continue;
-      currentChild.children.push({
-        href: `#${toSectionId(content.heading)}`,
-        label: content.heading,
-        status: meta.status,
-        children: []
-      });
-    }
-  }
-  return nav;
-}
-
-export {
-  toSectionId,
-  generateNavLinks
-};

package/dist/chunk-F2LYQPXV.js

@@ -1,77 +0,0 @@
-import {
-  cn
-} from "./chunk-7EOSDFS3.js";
-
-// src/components/shared/Checkbox.tsx
-import { useId } from "react";
-import { Check } from "lucide-react";
-import { jsx, jsxs } from "react/jsx-runtime";
-function Checkbox({
-  checked,
-  onChange,
-  label,
-  description,
-  disabled,
-  className,
-  startAdornment,
-  align = "start"
-}) {
-  const id = useId();
-  return /* @__PURE__ */ jsxs(
-    "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__ */ jsxs(
-          "span",
-          {
-            className: cn(
-              "relative flex h-5 w-5 shrink-0 items-center justify-center",
-              align === "start" && "mt-0.5"
-            ),
-            children: [
-              /* @__PURE__ */ jsx(
-                "input",
-                {
-                  id,
-                  type: "checkbox",
-                  checked,
-                  disabled,
-                  onChange: (e) => onChange(e.target.checked),
-                  className: "sr-only"
-                }
-              ),
-              /* @__PURE__ */ jsx(
-                "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__ */ jsx(Check, { size: 14, strokeWidth: 3 })
-                }
-              )
-            ]
-          }
-        ),
-        startAdornment,
-        /* @__PURE__ */ jsxs("div", { className: "text-sm", children: [
-          /* @__PURE__ */ jsx("span", { className: "font-medium text-base-contrast", children: label }),
-          description && /* @__PURE__ */ jsx("span", { className: "block text-base-contrast-light", children: description })
-        ] })
-      ]
-    }
-  );
-}
-
-export {
-  Checkbox
-};