@omniharmonic/openspace-ops 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,2503 @@
+// src/apply.ts
+import { produce } from "immer";
+
+// src/doc.ts
+import {
+  GRID_COLUMNS,
+  resolve
+} from "@omniharmonic/openspace-schema";
+
+// src/ops.ts
+import {
+  BlockIdSchema,
+  BlockSchema,
+  BlockStyleSchema,
+  CollectionConfigSchema,
+  CollectionItemSchema,
+  CollectionNameSchema,
+  GridItemSchema,
+  GridRectSchema,
+  MAX_GRID_ROWS,
+  MediaMetaSchema,
+  MediaPathSchema,
+  NavItemSchema,
+  PageIdSchema,
+  PageSchema,
+  responsive,
+  SectionIdSchema,
+  SectionSchema,
+  SlugSchema,
+  VariantNameSchema
+} from "@omniharmonic/openspace-schema";
+import { z } from "zod";
+var OpMetaShape = {
+  id: z.string().min(1).max(128),
+  actor: z.string().min(1).max(128),
+  ts: z.number().finite().min(0)
+};
+var FOOTER = "footer";
+var ContainerIdSchema = z.union([PageIdSchema, z.literal(FOOTER)]);
+var PositionSchema = z.union([
+  z.int().min(0),
+  z.literal("start"),
+  z.literal("end"),
+  z.strictObject({ before: z.string().min(1) }),
+  z.strictObject({ after: z.string().min(1) })
+]);
+var PathSchema = z.string().min(1).max(300).regex(/^[^.]+(?:\.[^.]+)*$/, { message: "Expected a dot-separated path" });
+var PatchShape = {
+  set: z.record(PathSchema, z.unknown()).optional(),
+  unset: z.array(PathSchema).max(500).optional()
+};
+var RowsSchema = responsive(z.int().min(1).max(MAX_GRID_ROWS));
+var BreakpointSchema = z.enum(["d", "t", "m"]);
+var op = (name2, shape) => z.strictObject({ op: z.literal(name2), ...OpMetaShape, ...shape });
+var BlockUpdateOpSchema = op("block.update", {
+  page: ContainerIdSchema,
+  block: BlockIdSchema,
+  /** Field values to set (top-level field keys). */
+  set: z.record(z.string().min(1).max(100), z.unknown()).optional(),
+  /** Field keys to remove. */
+  unset: z.array(z.string().min(1).max(100)).max(200).optional(),
+  /** New variant; `null` removes it. */
+  variant: VariantNameSchema.nullable().optional(),
+  /** New style overrides (replaced whole); `null` removes them. */
+  style: BlockStyleSchema.nullable().optional(),
+  /** Stack column; `null` removes it. */
+  column: z.int().min(0).max(3).nullable().optional(),
+  /** Layers label; `null` removes it. */
+  label: z.string().max(80).nullable().optional(),
+  /** Hide the block on the published site; `null` (or `false`) shows it again. */
+  hidden: z.boolean().nullable().optional()
+});
+var BlockInsertOpSchema = op("block.insert", {
+  page: ContainerIdSchema,
+  section: SectionIdSchema,
+  at: PositionSchema,
+  block: BlockSchema,
+  /** Grid placement when inserting into a grid section (auto-placed at the bottom if absent). */
+  place: GridItemSchema.optional(),
+  /** Exact grid rows to set afterwards (used by inverses); otherwise rows auto-grow to fit. */
+  rows: RowsSchema.optional()
+});
+var BlockMoveOpSchema = op("block.move", {
+  page: ContainerIdSchema,
+  block: BlockIdSchema,
+  to: z.strictObject({
+    section: SectionIdSchema,
+    at: PositionSchema,
+    /** Grid placement in the destination (kept/auto-placed if absent). */
+    place: GridItemSchema.optional(),
+    /** Stack column in the destination; `null` removes it. */
+    column: z.int().min(0).max(3).nullable().optional(),
+    /** Exact rows for the destination grid (used by inverses). */
+    rows: RowsSchema.optional()
+  }),
+  /** Exact rows for the source grid section after the block leaves (used by inverses). */
+  fromRows: RowsSchema.optional()
+});
+var BlockDeleteOpSchema = op("block.delete", {
+  page: ContainerIdSchema,
+  block: BlockIdSchema,
+  /** Exact rows for the grid section afterwards (used by inverses). */
+  rows: RowsSchema.optional()
+});
+var GridPlaceOpSchema = op("grid.place", {
+  page: ContainerIdSchema,
+  section: SectionIdSchema,
+  block: BlockIdSchema,
+  bp: BreakpointSchema,
+  /** The placement; `null` removes a tablet/mobile override (desktop is required). */
+  rect: GridRectSchema.nullable(),
+  /** Exact rows to set (used by inverses); otherwise rows auto-grow to fit the placement. */
+  rows: RowsSchema.optional()
+});
+var SectionInsertOpSchema = op("section.insert", {
+  page: PageIdSchema,
+  at: PositionSchema,
+  section: SectionSchema
+});
+var SectionMoveOpSchema = op("section.move", {
+  page: PageIdSchema,
+  section: SectionIdSchema,
+  at: PositionSchema
+});
+var SectionDeleteOpSchema = op("section.delete", {
+  page: PageIdSchema,
+  section: SectionIdSchema
+});
+var SectionUpdateOpSchema = op("section.update", {
+  page: ContainerIdSchema,
+  section: SectionIdSchema,
+  ...PatchShape
+});
+var StylesPatchOpSchema = op("styles.patch", {
+  patch: z.strictObject(PatchShape)
+});
+var PageCreateOpSchema = op("page.create", {
+  page: PageSchema,
+  /** Optionally replace the navigation tree in the same step (e.g. to add the new page). */
+  nav: z.array(NavItemSchema).optional()
+});
+var PageUpdateOpSchema = op("page.update", {
+  page: PageIdSchema,
+  ...PatchShape
+});
+var PageDeleteOpSchema = op("page.delete", {
+  page: PageIdSchema,
+  /** Optionally replace the navigation tree in the same step (e.g. to drop links to the page). */
+  nav: z.array(NavItemSchema).optional()
+});
+var NavUpdateOpSchema = op("nav.update", {
+  tree: z.array(NavItemSchema)
+});
+var SiteUpdateOpSchema = op("site.update", { ...PatchShape });
+var MediaAddOpSchema = op("media.add", {
+  path: MediaPathSchema,
+  meta: MediaMetaSchema
+});
+var MediaRemoveOpSchema = op("media.remove", {
+  path: MediaPathSchema
+});
+var CollectionUpsertOpSchema = op("collection.upsert", {
+  collection: CollectionNameSchema,
+  item: CollectionItemSchema
+});
+var CollectionDeleteOpSchema = op("collection.delete", {
+  collection: CollectionNameSchema,
+  slug: SlugSchema,
+  /**
+   * Keep the collection's (now empty) entry. By default a collection with no items left is
+   * removed from `collections` (its settings in `collectionConfigs` are untouched).
+   */
+  keepEmpty: z.boolean().optional()
+});
+var CollectionConfigUpsertOpSchema = op("collectionConfig.upsert", {
+  collection: CollectionNameSchema,
+  config: CollectionConfigSchema.nullable(),
+  /** With `config: null`: keep an empty `collectionConfigs` object instead of dropping it. */
+  keepEmpty: z.boolean().optional()
+});
+var OpSchema = z.discriminatedUnion("op", [
+  BlockUpdateOpSchema,
+  BlockInsertOpSchema,
+  BlockMoveOpSchema,
+  BlockDeleteOpSchema,
+  GridPlaceOpSchema,
+  SectionInsertOpSchema,
+  SectionMoveOpSchema,
+  SectionDeleteOpSchema,
+  SectionUpdateOpSchema,
+  StylesPatchOpSchema,
+  PageCreateOpSchema,
+  PageUpdateOpSchema,
+  PageDeleteOpSchema,
+  NavUpdateOpSchema,
+  SiteUpdateOpSchema,
+  MediaAddOpSchema,
+  MediaRemoveOpSchema,
+  CollectionUpsertOpSchema,
+  CollectionDeleteOpSchema,
+  CollectionConfigUpsertOpSchema
+]);
+var OP_TYPES = OpSchema.options.map((o) => o.shape.op.value);
+function stamp(body, meta) {
+  return { ...body, id: meta.id, actor: meta.actor, ts: meta.ts };
+}
+function parseOp(value) {
+  const r = OpSchema.safeParse(value);
+  if (r.success) return { ok: true, op: r.data };
+  return {
+    ok: false,
+    errors: r.error.issues.map((i) => ({
+      path: i.path.map((p) => typeof p === "symbol" ? String(p) : p),
+      message: i.message
+    }))
+  };
+}
+
+// src/doc.ts
+var OpError = class extends Error {
+  path;
+  constructor(message, path = []) {
+    super(message);
+    this.name = "OpError";
+    this.path = path;
+  }
+};
+function containerPath(container) {
+  return container === FOOTER ? ["site", "footer"] : ["pages", container];
+}
+function sectionsOf(doc, container) {
+  if (container === FOOTER) return [doc.site.footer];
+  return doc.pages[container]?.sections;
+}
+function getPage(doc, id) {
+  return Object.hasOwn(doc.pages, id) ? doc.pages[id] : void 0;
+}
+function findSection(doc, container, sectionId) {
+  const sections = sectionsOf(doc, container);
+  if (!sections) return void 0;
+  const index = sections.findIndex((s) => s.id === sectionId);
+  if (index < 0) return void 0;
+  return { section: sections[index], index };
+}
+function findBlock(doc, container, blockId) {
+  const sections = sectionsOf(doc, container);
+  if (!sections) return void 0;
+  for (let i = 0; i < sections.length; i++) {
+    const section = sections[i];
+    const index = section.blocks.findIndex((b) => b.id === blockId);
+    if (index >= 0)
+      return { section, sectionIndex: i, block: section.blocks[index], index };
+  }
+  return void 0;
+}
+function locateSection(doc, sectionId) {
+  if (doc.site.footer.id === sectionId)
+    return { container: FOOTER, index: 0, section: doc.site.footer };
+  for (const page of Object.values(doc.pages)) {
+    const index = page.sections.findIndex((s) => s.id === sectionId);
+    if (index >= 0) return { container: page.id, index, section: page.sections[index] };
+  }
+  return void 0;
+}
+function locateBlock(doc, blockId) {
+  const inFooter = findBlock(doc, FOOTER, blockId);
+  if (inFooter) return { container: FOOTER, ...inFooter };
+  for (const page of Object.values(doc.pages)) {
+    const loc = findBlock(doc, page.id, blockId);
+    if (loc) return { container: page.id, ...loc };
+  }
+  return void 0;
+}
+function indexIds(doc) {
+  const sections = /* @__PURE__ */ new Map();
+  const blocks = /* @__PURE__ */ new Map();
+  const add = (container, s) => {
+    sections.set(s.id, container);
+    for (const b of s.blocks) blocks.set(b.id, container);
+  };
+  add(FOOTER, doc.site.footer);
+  for (const page of Object.values(doc.pages)) for (const s of page.sections) add(page.id, s);
+  return { sections, blocks };
+}
+function resolvePosition(ids, at, path) {
+  if (typeof at === "number") {
+    if (at > ids.length)
+      throw new OpError(`Position ${at} is out of range (0\u2013${ids.length})`, [...path, "at"]);
+    return at;
+  }
+  if (at === "start") return 0;
+  if (at === "end") return ids.length;
+  const anchor = "before" in at ? at.before : at.after;
+  const i = ids.indexOf(anchor);
+  if (i < 0) throw new OpError(`Position anchor ${anchor} is not a sibling here`, [...path, "at"]);
+  return "before" in at ? i : i + 1;
+}
+function effectiveRect(item, bp) {
+  if (bp === "t") return item.t ?? item.d;
+  return item[bp];
+}
+function usedRows(layout, bp) {
+  let max = 0;
+  for (const item of Object.values(layout.items)) {
+    const r = effectiveRect(item, bp);
+    if (r) max = Math.max(max, r.y + r.h - 1);
+  }
+  return max;
+}
+function raiseRows(layout) {
+  for (const bp of ["d", "t", "m"]) {
+    const need2 = usedRows(layout, bp);
+    if (need2 > resolve(layout.rows, bp)) layout.rows[bp] = need2;
+  }
+}
+var AUTO_PLACE = { w: 12, h: 4 };
+function autoPlace(layout) {
+  const item = {
+    d: {
+      x: 1,
+      y: usedRows(layout, "d") + 1,
+      w: Math.min(AUTO_PLACE.w, GRID_COLUMNS.d),
+      h: AUTO_PLACE.h
+    }
+  };
+  if (Object.values(layout.items).some((i) => i.m !== void 0)) {
+    item.m = { x: 1, y: usedRows(layout, "m") + 1, w: GRID_COLUMNS.m, h: AUTO_PLACE.h };
+  }
+  return item;
+}
+function copyRows(rows) {
+  const out = { d: rows.d };
+  if (rows.t !== void 0) out.t = rows.t;
+  if (rows.m !== void 0) out.m = rows.m;
+  return out;
+}
+
+// src/paths.ts
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function findForbiddenKey(value, depth = 0) {
+  if (depth > 64 || value === null || typeof value !== "object") return void 0;
+  if (Array.isArray(value)) {
+    for (const v of value) {
+      const k = findForbiddenKey(v, depth + 1);
+      if (k) return k;
+    }
+    return void 0;
+  }
+  for (const key2 of Object.keys(value)) {
+    if (FORBIDDEN_SEGMENTS.has(key2)) return key2;
+    const k = findForbiddenKey(value[key2], depth + 1);
+    if (k) return k;
+  }
+  return void 0;
+}
+function isForbiddenKey(key2) {
+  return FORBIDDEN_SEGMENTS.has(key2);
+}
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b || a === null || b === null) return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+    return true;
+  }
+  if (Array.isArray(b)) return false;
+  if (typeof a === "object") {
+    const ao = a;
+    const bo = b;
+    const ak = Object.keys(ao).filter((k) => ao[k] !== void 0);
+    const bk = Object.keys(bo).filter((k) => bo[k] !== void 0);
+    if (ak.length !== bk.length) return false;
+    for (const k of ak) {
+      if (!Object.hasOwn(bo, k) || !deepEqual(ao[k], bo[k])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function clone(value) {
+  if (Array.isArray(value)) return value.map((v) => clone(v));
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) if (v !== void 0) out[k] = clone(v);
+    return out;
+  }
+  return value;
+}
+function splitPath(path) {
+  return path.split(".");
+}
+function checkPath(path) {
+  if (path.length === 0) return "Empty path";
+  for (const seg of splitPath(path)) {
+    if (seg.length === 0) return `Empty segment in path "${path}"`;
+    if (FORBIDDEN_SEGMENTS.has(seg)) return `Forbidden path segment "${seg}"`;
+  }
+  return void 0;
+}
+function isPathPrefix(a, b) {
+  return a === b || b.startsWith(`${a}.`);
+}
+function pathsOverlap(a, b) {
+  return isPathPrefix(a, b) || isPathPrefix(b, a);
+}
+function overlappingPaths(paths) {
+  const out = /* @__PURE__ */ new Set();
+  for (let i = 0; i < paths.length; i++)
+    for (let j = i + 1; j < paths.length; j++) {
+      const a = paths[i];
+      const b = paths[j];
+      if (pathsOverlap(a, b)) out.add(a.length >= b.length ? a : b);
+    }
+  return [...out];
+}
+function lookupPath(root, path) {
+  const segs = splitPath(path);
+  let cur = root;
+  for (let i = 0; i < segs.length; i++) {
+    const seg = segs[i];
+    if (!isPlainObject(cur)) return { exists: false, value: void 0, blocked: true };
+    if (!Object.hasOwn(cur, seg) || cur[seg] === void 0) {
+      return {
+        exists: false,
+        value: void 0,
+        missingAt: segs.slice(0, i + 1).join("."),
+        blocked: false
+      };
+    }
+    cur = cur[seg];
+  }
+  return { exists: true, value: cur, blocked: false };
+}
+function setPath(root, path, value) {
+  const segs = splitPath(path);
+  let cur = root;
+  for (let i = 0; i < segs.length - 1; i++) {
+    const seg = segs[i];
+    const next = cur[seg];
+    if (next === void 0) {
+      const created = {};
+      cur[seg] = created;
+      cur = cur[seg];
+    } else if (isPlainObject(next)) {
+      cur = next;
+    } else {
+      throw new Error(`Cannot set "${path}": "${segs.slice(0, i + 1).join(".")}" is not an object`);
+    }
+  }
+  cur[segs[segs.length - 1]] = clone(value);
+}
+function unsetPath(root, path) {
+  const segs = splitPath(path);
+  let cur = root;
+  for (let i = 0; i < segs.length - 1; i++) {
+    if (!isPlainObject(cur)) return;
+    cur = cur[segs[i]];
+  }
+  if (isPlainObject(cur)) delete cur[segs[segs.length - 1]];
+}
+function applyPatch(root, patch) {
+  for (const p of patch.unset ?? []) unsetPath(root, p);
+  for (const [p, v] of Object.entries(patch.set ?? {})) setPath(root, p, v);
+}
+function invertPatch(root, patch) {
+  const set = {};
+  const unset = /* @__PURE__ */ new Set();
+  for (const p of patch.unset ?? []) {
+    const l = lookupPath(root, p);
+    if (l.exists) set[p] = clone(l.value);
+  }
+  for (const p of Object.keys(patch.set ?? {})) {
+    const l = lookupPath(root, p);
+    if (l.exists) set[p] = clone(l.value);
+    else if (l.missingAt !== void 0) unset.add(l.missingAt);
+  }
+  return { set, unset: [...unset] };
+}
+function diffObjects(before, after, skip = [], prefix = "") {
+  const set = {};
+  const unset = [];
+  const walk2 = (a, b, base, top) => {
+    for (const k of Object.keys(a)) {
+      if (top && skip.includes(k)) continue;
+      if (a[k] === void 0) continue;
+      if (b[k] === void 0) unset.push(base + k);
+    }
+    for (const k of Object.keys(b)) {
+      if (top && skip.includes(k)) continue;
+      const bv = b[k];
+      if (bv === void 0) continue;
+      const av = a[k];
+      if (av === void 0) set[base + k] = clone(bv);
+      else if (isPlainObject(av) && isPlainObject(bv)) walk2(av, bv, `${base + k}.`, false);
+      else if (!deepEqual(av, bv)) set[base + k] = clone(bv);
+    }
+  };
+  walk2(before, after, prefix, true);
+  return { set, unset };
+}
+function isEmptyPatch(patch) {
+  return Object.keys(patch.set ?? {}).length === 0 && (patch.unset ?? []).length === 0;
+}
+function patchPaths(patch) {
+  return [...patch.unset ?? [], ...Object.keys(patch.set ?? {})];
+}
+function isJson(value, depth = 0) {
+  if (depth > 64) return false;
+  if (value === null) return true;
+  switch (typeof value) {
+    case "boolean":
+    case "string":
+      return true;
+    case "number":
+      return Number.isFinite(value);
+    case "object":
+      if (Array.isArray(value)) return value.every((v) => isJson(v, depth + 1));
+      if (!isPlainObject(value)) return false;
+      return Object.values(value).every((v) => isJson(v, depth + 1));
+    default:
+      return false;
+  }
+}
+
+// src/apply.ts
+var PROTECTED_PATHS = {
+  page: ["id", "sections"],
+  section: ["id", "blocks"],
+  site: ["nav"],
+  styles: []
+};
+function checkPatch(patch, protectedKeys, path, what) {
+  const paths = patchPaths(patch);
+  for (const p of paths) {
+    const problem = checkPath(p);
+    if (problem) throw new OpError(problem, path);
+    const top = p.split(".")[0];
+    if (protectedKeys.includes(top)) {
+      const hint = top === "nav" ? "use nav.update" : top === "sections" || top === "blocks" ? "use the section/block ops" : "ids never change";
+      throw new OpError(`Cannot patch ${what} "${top}" directly (${hint})`, path);
+    }
+  }
+  const overlaps2 = overlappingPaths(paths);
+  if (overlaps2.length > 0)
+    throw new OpError(`Overlapping patch paths: ${overlaps2.join(", ")}`, path);
+}
+function requireSections(doc, container) {
+  const sections = sectionsOf(doc, container);
+  if (!sections) throw new OpError(`Page ${container} does not exist`, ["pages", container]);
+  return sections;
+}
+function requireSection(doc, container, id) {
+  requireSections(doc, container);
+  const loc = findSection(doc, container, id);
+  if (!loc)
+    throw new OpError(`Section ${id} is not on ${describe(container)}`, containerPath(container));
+  return loc.section;
+}
+function describe(container) {
+  return container === FOOTER ? "the footer" : `page ${container}`;
+}
+function requirePage(doc, id, op2) {
+  if (id === FOOTER) throw new OpError(`${op2} is not allowed on the footer`, ["site", "footer"]);
+  const page = getPage(doc, id);
+  if (!page) throw new OpError(`Page ${id} does not exist`, ["pages", id]);
+  return page;
+}
+function placeInGrid(section, blockId, item) {
+  if (section.layout.mode !== "grid") return;
+  section.layout.items[blockId] = item ? clone(item) : autoPlace(section.layout);
+}
+function mutate(doc, op2) {
+  switch (op2.op) {
+    case "block.update": {
+      for (const k of [...op2.unset ?? [], ...Object.keys(op2.set ?? {})])
+        if (isForbiddenKey(k)) throw new OpError(`Forbidden field key "${k}"`, ["set", k]);
+      requireSections(doc, op2.page);
+      const loc = findBlock(doc, op2.page, op2.block);
+      if (!loc)
+        throw new OpError(
+          `Block ${op2.block} is not on ${describe(op2.page)}`,
+          containerPath(op2.page)
+        );
+      const b = loc.block;
+      for (const k of op2.unset ?? []) delete b.fields[k];
+      for (const [k, v] of Object.entries(op2.set ?? {})) b.fields[k] = clone(v);
+      if (op2.variant !== void 0) {
+        if (op2.variant === null) delete b.variant;
+        else b.variant = op2.variant;
+      }
+      if (op2.style !== void 0) {
+        if (op2.style === null) delete b.style;
+        else b.style = clone(op2.style);
+      }
+      if (op2.label !== void 0) {
+        if (op2.label === null) delete b.label;
+        else b.label = op2.label;
+      }
+      if (op2.hidden !== void 0) {
+        if (!op2.hidden) delete b.hidden;
+        else b.hidden = true;
+      }
+      if (op2.column !== void 0) {
+        if (op2.column === null) delete b.column;
+        else b.column = op2.column;
+      }
+      return;
+    }
+    case "block.insert": {
+      const section = requireSection(doc, op2.page, op2.section);
+      const at = resolvePosition(
+        section.blocks.map((b) => b.id),
+        op2.at,
+        [...containerPath(op2.page), "sections", op2.section]
+      );
+      if (section.blocks.some((b) => b.id === op2.block.id))
+        throw new OpError(`Block ${op2.block.id} already exists`, ["block", "id"]);
+      section.blocks.splice(at, 0, clone(op2.block));
+      if (section.layout.mode === "grid") {
+        placeInGrid(section, op2.block.id, op2.place);
+        if (op2.rows) section.layout.rows = copyRows(op2.rows);
+        else raiseRows(section.layout);
+      }
+      return;
+    }
+    case "block.move": {
+      requireSections(doc, op2.page);
+      const from = findBlock(doc, op2.page, op2.block);
+      if (!from)
+        throw new OpError(
+          `Block ${op2.block} is not on ${describe(op2.page)}`,
+          containerPath(op2.page)
+        );
+      const dest = requireSection(doc, op2.page, op2.to.section);
+      const src = from.section;
+      const same = src.id === dest.id;
+      const [block] = src.blocks.splice(from.index, 1);
+      if (src.layout.mode === "grid" && !same) {
+        delete src.layout.items[block.id];
+        if (op2.fromRows) src.layout.rows = copyRows(op2.fromRows);
+      }
+      const at = resolvePosition(
+        dest.blocks.map((b) => b.id),
+        op2.to.at,
+        [...containerPath(op2.page), "sections", dest.id]
+      );
+      dest.blocks.splice(at, 0, block);
+      const moved = dest.blocks[at];
+      if (dest.layout.mode === "grid") {
+        if (!same || op2.to.place || !dest.layout.items[block.id])
+          placeInGrid(dest, block.id, op2.to.place);
+        if (op2.to.rows) dest.layout.rows = copyRows(op2.to.rows);
+        else raiseRows(dest.layout);
+      }
+      if (op2.to.column !== void 0) {
+        if (op2.to.column === null) delete moved.column;
+        else moved.column = op2.to.column;
+      } else if (dest.layout.mode === "stack" && moved.column !== void 0) {
+        const cols = dest.layout.columns.d.length;
+        if (moved.column >= cols) moved.column = cols - 1;
+      }
+      return;
+    }
+    case "block.delete": {
+      requireSections(doc, op2.page);
+      const loc = findBlock(doc, op2.page, op2.block);
+      if (!loc)
+        throw new OpError(
+          `Block ${op2.block} is not on ${describe(op2.page)}`,
+          containerPath(op2.page)
+        );
+      loc.section.blocks.splice(loc.index, 1);
+      if (loc.section.layout.mode === "grid") {
+        delete loc.section.layout.items[op2.block];
+        if (op2.rows) loc.section.layout.rows = copyRows(op2.rows);
+      }
+      return;
+    }
+    case "grid.place": {
+      const section = requireSection(doc, op2.page, op2.section);
+      const base = [...containerPath(op2.page), "sections", op2.section];
+      if (section.layout.mode !== "grid")
+        throw new OpError(`Section ${op2.section} is not a grid section`, [
+          ...base,
+          "layout",
+          "mode"
+        ]);
+      if (!section.blocks.some((b) => b.id === op2.block))
+        throw new OpError(`Block ${op2.block} is not in section ${op2.section}`, [...base, "blocks"]);
+      const item = section.layout.items[op2.block];
+      if (op2.rect === null) {
+        if (op2.bp === "d")
+          throw new OpError("The desktop placement cannot be removed", [
+            ...base,
+            "layout",
+            "items",
+            op2.block,
+            "d"
+          ]);
+        if (item) delete item[op2.bp];
+      } else if (item) {
+        item[op2.bp] = clone(op2.rect);
+      } else {
+        if (op2.bp !== "d")
+          throw new OpError(`Block ${op2.block} needs a desktop placement first`, [
+            ...base,
+            "layout",
+            "items",
+            op2.block
+          ]);
+        section.layout.items[op2.block] = { d: clone(op2.rect) };
+      }
+      if (op2.rows) section.layout.rows = copyRows(op2.rows);
+      else raiseRows(section.layout);
+      return;
+    }
+    case "section.insert": {
+      const page = requirePage(doc, op2.page, "section.insert");
+      const at = resolvePosition(
+        page.sections.map((s) => s.id),
+        op2.at,
+        ["pages", op2.page]
+      );
+      if (page.sections.some((s) => s.id === op2.section.id))
+        throw new OpError(`Section ${op2.section.id} already exists`, ["section", "id"]);
+      page.sections.splice(at, 0, clone(op2.section));
+      return;
+    }
+    case "section.move": {
+      const page = requirePage(doc, op2.page, "section.move");
+      const from = page.sections.findIndex((s) => s.id === op2.section);
+      if (from < 0)
+        throw new OpError(`Section ${op2.section} is not on page ${op2.page}`, ["pages", op2.page]);
+      const [section] = page.sections.splice(from, 1);
+      const at = resolvePosition(
+        page.sections.map((s) => s.id),
+        op2.at,
+        ["pages", op2.page]
+      );
+      page.sections.splice(at, 0, section);
+      return;
+    }
+    case "section.delete": {
+      const page = requirePage(doc, op2.page, "section.delete");
+      const from = page.sections.findIndex((s) => s.id === op2.section);
+      if (from < 0)
+        throw new OpError(`Section ${op2.section} is not on page ${op2.page}`, ["pages", op2.page]);
+      page.sections.splice(from, 1);
+      return;
+    }
+    case "section.update": {
+      const section = requireSection(doc, op2.page, op2.section);
+      checkPatch(
+        op2,
+        PROTECTED_PATHS.section,
+        [...containerPath(op2.page), "sections", op2.section],
+        "section"
+      );
+      applyPatch(section, op2);
+      return;
+    }
+    case "styles.patch": {
+      checkPatch(op2.patch, PROTECTED_PATHS.styles, ["styles"], "styles");
+      applyPatch(doc.styles, op2.patch);
+      return;
+    }
+    case "page.create": {
+      if (getPage(doc, op2.page.id))
+        throw new OpError(`Page ${op2.page.id} already exists`, ["pages", op2.page.id]);
+      doc.pages[op2.page.id] = clone(op2.page);
+      if (op2.nav) doc.site.nav = clone(op2.nav);
+      return;
+    }
+    case "page.update": {
+      const page = requirePage(doc, op2.page, "page.update");
+      checkPatch(op2, PROTECTED_PATHS.page, ["pages", op2.page], "page");
+      applyPatch(page, op2);
+      return;
+    }
+    case "page.delete": {
+      requirePage(doc, op2.page, "page.delete");
+      delete doc.pages[op2.page];
+      if (op2.nav) doc.site.nav = clone(op2.nav);
+      return;
+    }
+    case "nav.update": {
+      doc.site.nav = clone(op2.tree);
+      return;
+    }
+    case "site.update": {
+      checkPatch(op2, PROTECTED_PATHS.site, ["site"], "site");
+      applyPatch(doc.site, op2);
+      return;
+    }
+    case "media.add": {
+      doc.media[op2.path] = clone(op2.meta);
+      return;
+    }
+    case "media.remove": {
+      if (!Object.hasOwn(doc.media, op2.path))
+        throw new OpError(`Media ${op2.path} does not exist`, ["media", op2.path]);
+      delete doc.media[op2.path];
+      return;
+    }
+    case "collection.upsert": {
+      const items = Object.hasOwn(doc.collections, op2.collection) ? doc.collections[op2.collection] : void 0;
+      if (items) items[op2.item.slug] = clone(op2.item);
+      else doc.collections[op2.collection] = { [op2.item.slug]: clone(op2.item) };
+      return;
+    }
+    case "collection.delete": {
+      const items = Object.hasOwn(doc.collections, op2.collection) ? doc.collections[op2.collection] : void 0;
+      if (!items || !Object.hasOwn(items, op2.slug))
+        throw new OpError(`Item ${op2.collection}/${op2.slug} does not exist`, [
+          "collections",
+          op2.collection,
+          op2.slug
+        ]);
+      delete items[op2.slug];
+      if (!op2.keepEmpty && Object.keys(items).length === 0) delete doc.collections[op2.collection];
+      return;
+    }
+    case "collectionConfig.upsert": {
+      if (op2.config === null) {
+        const configs = doc.collectionConfigs;
+        if (!configs || !Object.hasOwn(configs, op2.collection))
+          throw new OpError(`Collection ${op2.collection} has no settings`, [
+            "collectionConfigs",
+            op2.collection
+          ]);
+        delete configs[op2.collection];
+        if (!op2.keepEmpty && Object.keys(configs).length === 0) delete doc.collectionConfigs;
+      } else {
+        if (!doc.collectionConfigs) doc.collectionConfigs = {};
+        doc.collectionConfigs[op2.collection] = clone(op2.config);
+      }
+      return;
+    }
+    default: {
+      const never = op2;
+      throw new OpError(`Unknown op ${never.op}`, ["op"]);
+    }
+  }
+}
+function apply(doc, op2) {
+  return produce(doc, (draft) => {
+    mutate(draft, op2);
+  });
+}
+function applyAll(doc, ops) {
+  return produce(doc, (draft) => {
+    ops.forEach((op2, index) => {
+      try {
+        mutate(draft, op2);
+      } catch (e) {
+        if (e instanceof OpError) throw Object.assign(e, { index });
+        throw e;
+      }
+    });
+  });
+}
+
+// src/diff.ts
+function pruneNav(nav, pageId) {
+  const out = [];
+  for (const item of nav) {
+    if (item.type === "page" && item.page === pageId) continue;
+    if (item.type === "button" && item.link.type === "page" && item.link.page === pageId) continue;
+    if (item.type === "folder") {
+      const folder = clone(item);
+      if (folder.page === pageId) delete folder.page;
+      folder.items = folder.items.filter((leaf) => !(leaf.type === "page" && leaf.page === pageId));
+      out.push(folder);
+      continue;
+    }
+    out.push(clone(item));
+  }
+  return out;
+}
+function navRefersTo(nav, pageId) {
+  return !deepEqual(pruneNav(nav, pageId), nav);
+}
+function diff(before, after, options = {}) {
+  const actor = options.actor ?? "system";
+  const ts = options.ts ?? 0;
+  const prefix = options.idPrefix ?? "diff-";
+  const ops = [];
+  let work = before;
+  const emit = (body) => {
+    const meta = { id: `${prefix}${ops.length + 1}`, actor, ts };
+    const op2 = { ...body, ...meta };
+    ops.push(op2);
+    work = apply(work, op2);
+  };
+  const afterSections = /* @__PURE__ */ new Map();
+  const afterBlocks = /* @__PURE__ */ new Set();
+  const noteSection = (container, s) => {
+    afterSections.set(s.id, container);
+    for (const b of s.blocks) afterBlocks.add(b.id);
+  };
+  noteSection(FOOTER, after.site.footer);
+  for (const page of Object.values(after.pages))
+    for (const s of page.sections) noteSection(page.id, s);
+  const styles = diffObjects(before.styles, after.styles);
+  if (!isEmptyPatch(styles)) emit({ op: "styles.patch", patch: compactPatch(styles) });
+  for (const id of Object.keys(before.pages)) {
+    if (Object.hasOwn(after.pages, id)) continue;
+    const nav = work.site.nav;
+    emit(
+      navRefersTo(nav, id) ? { op: "page.delete", page: id, nav: pruneNav(nav, id) } : { op: "page.delete", page: id }
+    );
+  }
+  for (const page of Object.values(work.pages))
+    for (const s of [...page.sections])
+      if (!afterSections.has(s.id)) emit({ op: "section.delete", page: page.id, section: s.id });
+  const removeBlock = (id) => {
+    const loc = locateBlock(work, id);
+    if (loc) emit({ op: "block.delete", page: loc.container, block: id });
+  };
+  const allBlocks = (doc) => {
+    const ids = doc.site.footer.blocks.map((b) => b.id);
+    for (const p of Object.values(doc.pages))
+      for (const s of p.sections) for (const b of s.blocks) ids.push(b.id);
+    return ids;
+  };
+  for (const id of allBlocks(work)) if (!afterBlocks.has(id)) removeBlock(id);
+  for (const page of Object.values(after.pages)) {
+    if (getPage(work, page.id)) continue;
+    const reuses = page.sections.some(
+      (s) => locateSection(work, s.id) || s.blocks.some((b) => locateBlock(work, b.id))
+    );
+    emit({ op: "page.create", page: reuses ? { ...clone(page), sections: [] } : clone(page) });
+  }
+  const insertWhole = (page, at, section) => {
+    for (const b of section.blocks) removeBlock(b.id);
+    emit({ op: "section.insert", page, at, section: clone(section) });
+  };
+  const needsReplace = (w, s) => w.layout.mode !== s.layout.mode || w.layout.mode === "stack" && s.layout.mode === "stack" && w.layout.columns.d.length !== s.layout.columns.d.length;
+  const syncBlocks = (container, target) => {
+    target.blocks.forEach((ab, i) => {
+      const cur = liveSection(work, container, target.id);
+      const grid = target.layout.mode === "grid" ? target.layout : void 0;
+      if (cur.blocks[i]?.id !== ab.id) {
+        const loc = locateBlock(work, ab.id);
+        if (loc && loc.container === container) {
+          const to = { section: target.id, at: i };
+          const item = grid?.items[ab.id];
+          if (item) to.place = clone(item);
+          if (!grid) to.column = ab.column ?? null;
+          emit({ op: "block.move", page: container, block: ab.id, to });
+        } else {
+          if (loc) removeBlock(ab.id);
+          const item = grid?.items[ab.id];
+          emit({
+            op: "block.insert",
+            page: container,
+            section: target.id,
+            at: i,
+            block: clone(ab),
+            ...item ? { place: clone(item) } : {}
+          });
+        }
+      }
+      const wb = liveSection(work, container, target.id).blocks[i];
+      const set = {};
+      const unset = [];
+      for (const k of Object.keys(wb.fields))
+        if (!Object.hasOwn(ab.fields, k) || ab.fields[k] === void 0) unset.push(k);
+      for (const [k, v] of Object.entries(ab.fields))
+        if (v !== void 0 && !deepEqual(wb.fields[k], v)) set[k] = clone(v);
+      const upd = {
+        op: "block.update",
+        page: container,
+        block: ab.id
+      };
+      if (Object.keys(set).length) upd.set = set;
+      if (unset.length) upd.unset = unset;
+      if (!deepEqual(wb.variant, ab.variant)) upd.variant = ab.variant ?? null;
+      if (!deepEqual(wb.style, ab.style)) upd.style = ab.style ? clone(ab.style) : null;
+      if (!deepEqual(wb.column, ab.column)) upd.column = ab.column ?? null;
+      if (!deepEqual(wb.label, ab.label)) upd.label = ab.label ?? null;
+      if (Boolean(wb.hidden) !== Boolean(ab.hidden)) upd.hidden = ab.hidden ? true : null;
+      if (Object.keys(upd).length > 3) emit(upd);
+      if (grid) {
+        const wl = liveSection(work, container, target.id).layout;
+        const witem = wl.mode === "grid" ? wl.items[ab.id] : void 0;
+        const sitem = grid.items[ab.id];
+        if (sitem)
+          for (const bp of ["d", "t", "m"]) {
+            if (deepEqual(witem?.[bp], sitem[bp])) continue;
+            const rect = sitem[bp];
+            emit({
+              op: "grid.place",
+              page: container,
+              section: target.id,
+              block: ab.id,
+              bp,
+              rect: rect ? clone(rect) : null
+            });
+          }
+      }
+    });
+  };
+  {
+    const target = after.site.footer;
+    const w = work.site.footer;
+    if (w.id !== target.id || needsReplace(w, target)) {
+      for (const b of target.blocks) if (!w.blocks.some((x) => x.id === b.id)) removeBlock(b.id);
+      emit({ op: "site.update", set: { footer: clone(target) } });
+    } else syncBlocks(FOOTER, target);
+  }
+  for (const page of Object.values(after.pages)) {
+    page.sections.forEach((target, j) => {
+      const cur = getPage(work, page.id).sections;
+      if (cur[j]?.id !== target.id) {
+        const loc = locateSection(work, target.id);
+        if (loc && loc.container === page.id) {
+          emit({ op: "section.move", page: page.id, section: target.id, at: j });
+        } else {
+          if (loc && loc.container !== FOOTER)
+            emit({ op: "section.delete", page: loc.container, section: target.id });
+          insertWhole(page.id, j, target);
+          return;
+        }
+      }
+      const w = getPage(work, page.id).sections[j];
+      if (needsReplace(w, target)) {
+        emit({ op: "section.delete", page: page.id, section: target.id });
+        insertWhole(page.id, j, target);
+        return;
+      }
+      syncBlocks(page.id, target);
+    });
+  }
+  const syncSection = (container, target) => {
+    const w = findSection(work, container, target.id)?.section;
+    if (!w) return;
+    const patch = diffObjects(w, target, ["id", "blocks"]);
+    if (!isEmptyPatch(patch))
+      emit({ op: "section.update", page: container, section: target.id, ...compactPatch(patch) });
+  };
+  syncSection(FOOTER, after.site.footer);
+  for (const page of Object.values(after.pages))
+    for (const s of page.sections) syncSection(page.id, s);
+  for (const page of Object.values(after.pages)) {
+    const w = getPage(work, page.id);
+    const patch = diffObjects(w, page, ["id", "sections"]);
+    if (!isEmptyPatch(patch)) emit({ op: "page.update", page: page.id, ...compactPatch(patch) });
+  }
+  const site = diffObjects(work.site, after.site, [
+    "nav",
+    "footer"
+  ]);
+  if (!isEmptyPatch(site)) emit({ op: "site.update", ...compactPatch(site) });
+  if (!deepEqual(work.site.nav, after.site.nav))
+    emit({ op: "nav.update", tree: clone(after.site.nav) });
+  for (const path of Object.keys(work.media))
+    if (!Object.hasOwn(after.media, path)) emit({ op: "media.remove", path });
+  for (const [path, meta] of Object.entries(after.media))
+    if (!deepEqual(work.media[path], meta)) emit({ op: "media.add", path, meta: clone(meta) });
+  for (const [name2, items] of Object.entries(work.collections)) {
+    const keep = after.collections[name2];
+    const gone = Object.keys(items).filter((slug) => !keep || !Object.hasOwn(keep, slug));
+    for (const slug of gone)
+      emit({
+        op: "collection.delete",
+        collection: name2,
+        slug,
+        ...keep ? { keepEmpty: true } : {}
+      });
+  }
+  for (const [name2, items] of Object.entries(after.collections))
+    for (const [slug, item] of Object.entries(items))
+      if (!deepEqual(work.collections[name2]?.[slug], item))
+        emit({ op: "collection.upsert", collection: name2, item: clone(item) });
+  const wc = work.collectionConfigs ?? {};
+  const ac = after.collectionConfigs;
+  const goneConfigs = Object.keys(wc).filter((n) => !ac || !Object.hasOwn(ac, n));
+  for (const name2 of goneConfigs)
+    emit({
+      op: "collectionConfig.upsert",
+      collection: name2,
+      config: null,
+      ...ac ? { keepEmpty: true } : {}
+    });
+  for (const [name2, config] of Object.entries(ac ?? {}))
+    if (!deepEqual(wc[name2], config))
+      emit({ op: "collectionConfig.upsert", collection: name2, config: clone(config) });
+  return ops;
+}
+function compactPatch(patch) {
+  const out = {};
+  if (Object.keys(patch.set).length) out.set = patch.set;
+  if (patch.unset.length) out.unset = patch.unset;
+  return out;
+}
+function liveSection(doc, container, id) {
+  const loc = findSection(doc, container, id);
+  if (!loc) throw new Error(`diff: section ${id} vanished from ${container}`);
+  return loc.section;
+}
+
+// src/invert.ts
+function compact(value) {
+  const out = {};
+  for (const [k, v] of Object.entries(value)) if (v !== void 0) out[k] = v;
+  return out;
+}
+function need(value, message, path) {
+  if (value === void 0) throw new OpError(message, path);
+  return value;
+}
+function blockLoc(doc, page, block) {
+  need(sectionsOf(doc, page), `Page ${page} does not exist`, containerPath(page));
+  return need(findBlock(doc, page, block), `Block ${block} does not exist`, containerPath(page));
+}
+function sectionLoc(doc, page, section) {
+  need(sectionsOf(doc, page), `Page ${page} does not exist`, containerPath(page));
+  return need(
+    findSection(doc, page, section),
+    `Section ${section} does not exist`,
+    containerPath(page)
+  );
+}
+function invert(doc, op2, meta) {
+  const m = meta ?? { id: `${op2.id}:undo`, actor: op2.actor, ts: op2.ts };
+  const body = invertBody(doc, op2);
+  return { ...body, id: m.id, actor: m.actor, ts: m.ts };
+}
+function invertBody(doc, op2) {
+  switch (op2.op) {
+    case "block.update": {
+      const { block } = blockLoc(doc, op2.page, op2.block);
+      const set = {};
+      const unset = [];
+      const keys = /* @__PURE__ */ new Set([...op2.unset ?? [], ...Object.keys(op2.set ?? {})]);
+      for (const k of keys) {
+        if (Object.hasOwn(block.fields, k) && block.fields[k] !== void 0)
+          set[k] = clone(block.fields[k]);
+        else if (op2.set && Object.hasOwn(op2.set, k)) unset.push(k);
+      }
+      return compact({
+        op: "block.update",
+        page: op2.page,
+        block: op2.block,
+        set: Object.keys(set).length ? set : void 0,
+        unset: unset.length ? unset : void 0,
+        variant: op2.variant !== void 0 ? block.variant ?? null : void 0,
+        style: op2.style !== void 0 ? block.style ? clone(block.style) : null : void 0,
+        column: op2.column !== void 0 ? block.column ?? null : void 0,
+        label: op2.label !== void 0 ? block.label ?? null : void 0,
+        hidden: op2.hidden !== void 0 ? block.hidden ?? null : void 0
+      });
+    }
+    case "block.insert": {
+      const { section } = sectionLoc(doc, op2.page, op2.section);
+      return compact({
+        op: "block.delete",
+        page: op2.page,
+        block: op2.block.id,
+        rows: section.layout.mode === "grid" ? copyRows(section.layout.rows) : void 0
+      });
+    }
+    case "block.delete": {
+      const loc = blockLoc(doc, op2.page, op2.block);
+      const layout = loc.section.layout;
+      const item = layout.mode === "grid" ? layout.items[op2.block] : void 0;
+      return compact({
+        op: "block.insert",
+        page: op2.page,
+        section: loc.section.id,
+        at: loc.index,
+        block: clone(loc.block),
+        place: item ? clone(item) : void 0,
+        rows: layout.mode === "grid" ? copyRows(layout.rows) : void 0
+      });
+    }
+    case "block.move": {
+      const from = blockLoc(doc, op2.page, op2.block);
+      const dest = sectionLoc(doc, op2.page, op2.to.section).section;
+      const src = from.section;
+      const same = src.id === dest.id;
+      const srcItem = src.layout.mode === "grid" ? src.layout.items[op2.block] : void 0;
+      return compact({
+        op: "block.move",
+        page: op2.page,
+        block: op2.block,
+        to: compact({
+          section: src.id,
+          at: from.index,
+          place: srcItem ? clone(srcItem) : void 0,
+          column: from.block.column ?? null,
+          rows: src.layout.mode === "grid" ? copyRows(src.layout.rows) : void 0
+        }),
+        fromRows: !same && dest.layout.mode === "grid" ? copyRows(dest.layout.rows) : void 0
+      });
+    }
+    case "grid.place": {
+      const { section } = sectionLoc(doc, op2.page, op2.section);
+      if (section.layout.mode !== "grid")
+        throw new OpError(`Section ${op2.section} is not a grid section`, containerPath(op2.page));
+      const item = section.layout.items[op2.block];
+      const prev = item?.[op2.bp];
+      return {
+        op: "grid.place",
+        page: op2.page,
+        section: op2.section,
+        block: op2.block,
+        bp: op2.bp,
+        rect: prev ? clone(prev) : null,
+        rows: copyRows(section.layout.rows)
+      };
+    }
+    case "section.insert":
+      return { op: "section.delete", page: op2.page, section: op2.section.id };
+    case "section.delete": {
+      const loc = sectionLoc(doc, op2.page, op2.section);
+      return { op: "section.insert", page: op2.page, at: loc.index, section: clone(loc.section) };
+    }
+    case "section.move": {
+      const loc = sectionLoc(doc, op2.page, op2.section);
+      return { op: "section.move", page: op2.page, section: op2.section, at: loc.index };
+    }
+    case "section.update": {
+      const loc = sectionLoc(doc, op2.page, op2.section);
+      return {
+        op: "section.update",
+        page: op2.page,
+        section: op2.section,
+        ...invertPatch(loc.section, op2)
+      };
+    }
+    case "styles.patch":
+      return { op: "styles.patch", patch: invertPatch(doc.styles, op2.patch) };
+    case "page.create":
+      return compact({
+        op: "page.delete",
+        page: op2.page.id,
+        nav: op2.nav ? clone(doc.site.nav) : void 0
+      });
+    case "page.delete": {
+      const page = need(getPage(doc, op2.page), `Page ${op2.page} does not exist`, [
+        "pages",
+        op2.page
+      ]);
+      return compact({
+        op: "page.create",
+        page: clone(page),
+        nav: op2.nav ? clone(doc.site.nav) : void 0
+      });
+    }
+    case "page.update": {
+      const page = need(getPage(doc, op2.page), `Page ${op2.page} does not exist`, [
+        "pages",
+        op2.page
+      ]);
+      return { op: "page.update", page: op2.page, ...invertPatch(page, op2) };
+    }
+    case "nav.update":
+      return { op: "nav.update", tree: clone(doc.site.nav) };
+    case "site.update":
+      return { op: "site.update", ...invertPatch(doc.site, op2) };
+    case "media.add": {
+      const prev = Object.hasOwn(doc.media, op2.path) ? doc.media[op2.path] : void 0;
+      return prev ? { op: "media.add", path: op2.path, meta: clone(prev) } : { op: "media.remove", path: op2.path };
+    }
+    case "media.remove": {
+      const prev = need(
+        Object.hasOwn(doc.media, op2.path) ? doc.media[op2.path] : void 0,
+        `Media ${op2.path} does not exist`,
+        ["media", op2.path]
+      );
+      return { op: "media.add", path: op2.path, meta: clone(prev) };
+    }
+    case "collection.upsert": {
+      const items = Object.hasOwn(doc.collections, op2.collection) ? doc.collections[op2.collection] : void 0;
+      const prev = items && Object.hasOwn(items, op2.item.slug) ? items[op2.item.slug] : void 0;
+      return prev ? { op: "collection.upsert", collection: op2.collection, item: clone(prev) } : compact({
+        op: "collection.delete",
+        collection: op2.collection,
+        slug: op2.item.slug,
+        keepEmpty: items ? true : void 0
+      });
+    }
+    case "collection.delete": {
+      const items = Object.hasOwn(doc.collections, op2.collection) ? doc.collections[op2.collection] : void 0;
+      const prev = need(
+        items && Object.hasOwn(items, op2.slug) ? items[op2.slug] : void 0,
+        `Item ${op2.collection}/${op2.slug} does not exist`,
+        ["collections", op2.collection, op2.slug]
+      );
+      return { op: "collection.upsert", collection: op2.collection, item: clone(prev) };
+    }
+    case "collectionConfig.upsert": {
+      const configs = doc.collectionConfigs;
+      const prev = configs && Object.hasOwn(configs, op2.collection) ? configs[op2.collection] : void 0;
+      if (op2.config === null) {
+        const p = need(prev, `Collection ${op2.collection} has no settings`, [
+          "collectionConfigs",
+          op2.collection
+        ]);
+        return { op: "collectionConfig.upsert", collection: op2.collection, config: clone(p) };
+      }
+      return prev ? { op: "collectionConfig.upsert", collection: op2.collection, config: clone(prev) } : compact({
+        op: "collectionConfig.upsert",
+        collection: op2.collection,
+        config: null,
+        keepEmpty: configs ? true : void 0
+      });
+    }
+    default: {
+      const never = op2;
+      throw new OpError(`Unknown op ${never.op}`, ["op"]);
+    }
+  }
+}
+function invertAll(doc, ops) {
+  const out = [];
+  let cur = doc;
+  for (const op2 of ops) {
+    out.push(invert(cur, op2));
+    cur = apply(cur, op2);
+  }
+  return out.reverse();
+}
+
+// src/validate.ts
+import {
+  PageSchema as PageSchema2,
+  SectionSchema as SectionSchema2,
+  SiteDocumentSchema,
+  SiteSchema,
+  StylesSchema
+} from "@omniharmonic/openspace-schema";
+import { produce as produce2 } from "immer";
+function zodIssues(error, prefix) {
+  return error.issues.map((i) => ({
+    path: [...prefix, ...i.path.map((p) => typeof p === "symbol" ? String(p) : p)],
+    message: i.message
+  }));
+}
+function siteRefIssues(doc) {
+  const issues = [];
+  const has = (id) => Object.hasOwn(doc.pages, id);
+  const checkItem = (item, path) => {
+    const it = item;
+    if (it.type === "page" && !has(it.page))
+      issues.push({
+        path: [...path, "page"],
+        message: `Navigation links to missing page ${it.page}`
+      });
+    if (it.type === "folder") {
+      if (it.page && !has(it.page))
+        issues.push({
+          path: [...path, "page"],
+          message: `Folder lands on missing page ${it.page}`
+        });
+      it.items.forEach((leaf, j) => {
+        checkItem(leaf, [...path, "items", j]);
+      });
+    }
+    if (it.type === "button" && it.link.type === "page" && !has(it.link.page))
+      issues.push({
+        path: [...path, "link", "page"],
+        message: `Button links to missing page ${it.link.page}`
+      });
+  };
+  doc.site.nav.forEach((item, i) => {
+    checkItem(item, ["site", "nav", i]);
+  });
+  const link = doc.site.announcement?.link;
+  if (link?.type === "page" && !has(link.page))
+    issues.push({
+      path: ["site", "announcement", "link", "page"],
+      message: `Announcement links to missing page ${link.page}`
+    });
+  return issues;
+}
+function walk(value, path, visit) {
+  if (Array.isArray(value)) {
+    value.forEach((v, i) => {
+      walk(v, [...path, i], visit);
+    });
+  } else if (isPlainObject(value)) {
+    visit(value, path);
+    for (const [k, v] of Object.entries(value)) walk(v, [...path, k], visit);
+  }
+}
+function contentLinksTo(doc, pageId) {
+  const out = [];
+  const visit = (o, p) => {
+    if (o.type === "page" && o.page === pageId)
+      out.push({ path: p, message: `Links to deleted page ${pageId}` });
+  };
+  walk(doc.pages, ["pages"], visit);
+  walk(doc.site.footer, ["site", "footer"], visit);
+  return out;
+}
+function mediaRefs(doc, path) {
+  const out = [];
+  const scan = (value, p) => {
+    if (typeof value === "string") {
+      if (value === path) out.push({ path: p, message: `Still references removed media ${path}` });
+    } else if (Array.isArray(value)) {
+      value.forEach((v, i) => {
+        scan(v, [...p, i]);
+      });
+    } else if (isPlainObject(value)) for (const [k, v] of Object.entries(value)) scan(v, [...p, k]);
+  };
+  scan(doc.pages, ["pages"]);
+  scan(doc.site, ["site"]);
+  scan(doc.collections, ["collections"]);
+  return out;
+}
+function slugIssues(doc, pageId) {
+  const page = doc.pages[pageId];
+  if (!page) return [];
+  for (const other of Object.values(doc.pages)) {
+    if (other.id !== pageId && other.slug === page.slug)
+      return [
+        {
+          path: ["pages", pageId, "slug"],
+          message: `Slug "${page.slug}" is also used by ${other.id}`
+        }
+      ];
+  }
+  return [];
+}
+function collectionIssues(doc, name2) {
+  const items = Object.values(doc.collections[name2] ?? {});
+  const kinds = new Set(items.map((i) => i.kind));
+  const out = [];
+  if (kinds.size > 1)
+    out.push({ path: ["collections", name2], message: `Collection ${name2} mixes item kinds` });
+  const configKind = doc.collectionConfigs?.[name2]?.kind;
+  if (configKind && configKind !== "custom") {
+    for (const item of items)
+      if (item.kind !== configKind)
+        out.push({
+          path: ["collections", name2, item.slug, "kind"],
+          message: `Collection ${name2} is a ${configKind} collection but ${item.slug} is ${item.kind}`
+        });
+  }
+  return out;
+}
+function newIdIssues(doc, sections, blocks, path) {
+  const idx = indexIds(doc);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const claim = (id, kind, taken) => {
+    if (taken || seen.has(id)) out.push({ path, message: `${kind} id ${id} is already used` });
+    seen.add(id);
+  };
+  for (const s of sections) {
+    claim(s.id, "Section", idx.sections.has(s.id));
+    for (const b of s.blocks) claim(b.id, "Block", idx.blocks.has(b.id));
+  }
+  for (const b of blocks) claim(b.id, "Block", idx.blocks.has(b.id));
+  return out;
+}
+function globalIdIssues(doc) {
+  const r = SiteDocumentSchema.safeParse(doc);
+  if (r.success) return [];
+  return zodIssues(r.error, []).filter((i) => /id .* is used in both/.test(i.message));
+}
+function containerIssues(doc, container) {
+  if (container === FOOTER) {
+    const r2 = SectionSchema2.safeParse(doc.site.footer);
+    return r2.success ? [] : zodIssues(r2.error, ["site", "footer"]);
+  }
+  const page = doc.pages[container];
+  if (!page) return [{ path: ["pages", container], message: `Page ${container} does not exist` }];
+  const r = PageSchema2.safeParse(page);
+  return r.success ? [] : zodIssues(r.error, ["pages", container]);
+}
+function blockIssues(registry, doc, container, ids) {
+  if (!registry || ids.length === 0) return [];
+  const want = new Set(ids);
+  const out = [];
+  const base = containerPath(container);
+  (sectionsOf(doc, container) ?? []).forEach((s, i) => {
+    s.blocks.forEach((b, j) => {
+      if (!want.has(b.id)) return;
+      const r = registry.validate(b);
+      if (!r.success)
+        for (const issue of r.issues)
+          out.push({
+            path: [...base, "sections", i, "blocks", j, ...issue.path],
+            message: issue.message
+          });
+    });
+  });
+  return out;
+}
+function setValueIssues(op2) {
+  const sets = [];
+  if (op2.op === "styles.patch") sets.push(op2.patch.set ?? {});
+  else if (op2.op === "block.update" || op2.op === "section.update" || op2.op === "page.update" || op2.op === "site.update")
+    sets.push(op2.set ?? {});
+  const out = [];
+  for (const set of sets)
+    for (const [k, v] of Object.entries(set))
+      if (v === void 0 || !isJson(v))
+        out.push({ path: ["set", k], message: `Value for "${k}" is not plain JSON` });
+  return out;
+}
+function validate(doc, input, options = {}) {
+  const forbidden = findForbiddenKey(input);
+  if (forbidden)
+    return { ok: false, errors: [{ path: [], message: `Forbidden key "${forbidden}"` }] };
+  let op2;
+  if (options.trusted) op2 = input;
+  else {
+    const parsed = parseOp(input);
+    if (!parsed.ok) return { ok: false, errors: parsed.errors };
+    op2 = parsed.op;
+  }
+  const valueIssues = setValueIssues(op2);
+  if (valueIssues.length) return { ok: false, errors: valueIssues };
+  const pre = [];
+  switch (op2.op) {
+    case "block.insert":
+      pre.push(...newIdIssues(doc, [], [op2.block], ["block", "id"]));
+      break;
+    case "section.insert":
+      pre.push(...newIdIssues(doc, [op2.section], [], ["section", "id"]));
+      break;
+    case "page.create":
+      pre.push(...newIdIssues(doc, op2.page.sections, [], ["page", "sections"]));
+      break;
+    case "media.add":
+      if (op2.meta.path !== op2.path)
+        pre.push({
+          path: ["meta", "path"],
+          message: `Media path ${op2.meta.path} does not match ${op2.path}`
+        });
+      for (const [p, m] of Object.entries(doc.media))
+        if (p !== op2.path && m.id === op2.meta.id)
+          pre.push({
+            path: ["meta", "id"],
+            message: `Media id ${op2.meta.id} is already used by ${p}`
+          });
+      break;
+  }
+  if (pre.length) return { ok: false, errors: pre };
+  let next;
+  try {
+    next = produce2(doc, (draft) => {
+      mutate(draft, op2);
+    });
+  } catch (e) {
+    if (e instanceof OpError) return { ok: false, errors: [{ path: e.path, message: e.message }] };
+    return {
+      ok: false,
+      errors: [{ path: [], message: e instanceof Error ? e.message : String(e) }]
+    };
+  }
+  const errors = [];
+  const warnings = [];
+  switch (op2.op) {
+    case "block.update":
+      errors.push(
+        ...containerIssues(next, op2.page),
+        ...blockIssues(options.registry, next, op2.page, [op2.block])
+      );
+      break;
+    case "block.insert":
+      errors.push(
+        ...containerIssues(next, op2.page),
+        ...blockIssues(options.registry, next, op2.page, [op2.block.id])
+      );
+      break;
+    case "block.move":
+    case "block.delete":
+    case "grid.place":
+    case "section.move":
+    case "section.delete":
+      errors.push(...containerIssues(next, op2.page));
+      break;
+    case "section.update":
+      errors.push(...containerIssues(next, op2.page));
+      break;
+    case "section.insert":
+      errors.push(
+        ...containerIssues(next, op2.page),
+        ...blockIssues(
+          options.registry,
+          next,
+          op2.page,
+          op2.section.blocks.map((b) => b.id)
+        )
+      );
+      break;
+    case "page.create":
+      errors.push(
+        ...containerIssues(next, op2.page.id),
+        ...slugIssues(next, op2.page.id),
+        ...blockIssues(
+          options.registry,
+          next,
+          op2.page.id,
+          op2.page.sections.flatMap((s) => s.blocks.map((b) => b.id))
+        )
+      );
+      if (op2.nav) errors.push(...siteSchemaIssues(next), ...siteRefIssues(next));
+      break;
+    case "page.update":
+      errors.push(...containerIssues(next, op2.page));
+      if (patchPaths(op2).some((p) => isPathPrefix("slug", p)))
+        errors.push(...slugIssues(next, op2.page));
+      break;
+    case "page.delete":
+      if (op2.nav) errors.push(...siteSchemaIssues(next));
+      errors.push(...siteRefIssues(next));
+      warnings.push(...contentLinksTo(next, op2.page));
+      break;
+    case "nav.update":
+      errors.push(...siteSchemaIssues(next), ...siteRefIssues(next));
+      break;
+    case "site.update":
+      errors.push(...siteSchemaIssues(next), ...siteRefIssues(next));
+      if (errors.length === 0 && patchPaths(op2).some((p) => isPathPrefix("footer", p)))
+        errors.push(...globalIdIssues(next));
+      break;
+    case "styles.patch": {
+      const r = StylesSchema.safeParse(next.styles);
+      if (!r.success) errors.push(...zodIssues(r.error, ["styles"]));
+      break;
+    }
+    case "media.add":
+      break;
+    case "media.remove":
+      warnings.push(...mediaRefs(next, op2.path));
+      break;
+    case "collection.upsert":
+    case "collectionConfig.upsert":
+      errors.push(...collectionIssues(next, op2.collection));
+      break;
+    case "collection.delete":
+      break;
+  }
+  if (errors.length) return { ok: false, errors };
+  return { ok: true, doc: next, warnings };
+}
+function siteSchemaIssues(doc) {
+  const r = SiteSchema.safeParse(doc.site);
+  return r.success ? [] : zodIssues(r.error, ["site"]);
+}
+function validateAll(doc, ops, options = {}) {
+  let cur = doc;
+  const warnings = [];
+  for (let index = 0; index < ops.length; index++) {
+    const r = validate(cur, ops[index], options);
+    if (!r.ok) return { ok: false, index, errors: r.errors };
+    cur = r.doc;
+    warnings.push(...r.warnings);
+  }
+  return { ok: true, doc: cur, warnings };
+}
+function validateDocument(doc, options = {}) {
+  const r = SiteDocumentSchema.safeParse(doc);
+  if (!r.success) return { ok: false, errors: zodIssues(r.error, []) };
+  const errors = siteRefIssues(r.data);
+  if (options.registry)
+    for (const issue of options.registry.validateDocument(r.data))
+      errors.push({ path: issue.path, message: issue.message });
+  if (errors.length) return { ok: false, errors };
+  return { ok: true, doc, warnings: [] };
+}
+
+// src/rebase.ts
+var edit = (...path) => ({ path, kind: "edit" });
+var order = (...path) => ({ path, kind: "order" });
+var sectionContent = (section) => [
+  order("section", section, "blocks"),
+  order("section", section, "props", "layout")
+];
+function pageReq(page) {
+  return page === FOOTER ? [] : [["page", page]];
+}
+function footprint(op2, doc) {
+  const fp = baseFootprint(op2);
+  if (doc && (op2.op === "block.update" || op2.op === "block.move" || op2.op === "block.delete" || op2.op === "grid.place")) {
+    const loc = findBlock(doc, op2.page, op2.block);
+    if (loc) {
+      fp.requires.push(["section", loc.section.id]);
+      if (op2.op !== "block.update" && op2.op !== "grid.place")
+        fp.touches.push(...sectionContent(loc.section.id));
+    }
+  }
+  if (op2.op === "section.delete") fp.touches.push(order("page", op2.page, "sections"));
+  return fp;
+}
+function baseFootprint(op2) {
+  switch (op2.op) {
+    case "block.update": {
+      const t = [];
+      for (const k of [...op2.unset ?? [], ...Object.keys(op2.set ?? {})])
+        t.push(edit("block", op2.block, "fields", k));
+      if (op2.variant !== void 0) t.push(edit("block", op2.block, "variant"));
+      if (op2.style !== void 0) t.push(edit("block", op2.block, "style"));
+      if (op2.column !== void 0) t.push(edit("block", op2.block, "column"));
+      if (op2.label !== void 0) t.push(edit("block", op2.block, "label"));
+      if (op2.hidden !== void 0) t.push(edit("block", op2.block, "hidden"));
+      return { touches: t, requires: pageReq(op2.page) };
+    }
+    case "block.insert":
+      return {
+        touches: [{ path: ["block", op2.block.id], kind: "create" }, ...sectionContent(op2.section)],
+        requires: [...pageReq(op2.page), ["section", op2.section]]
+      };
+    case "block.move": {
+      const t = [
+        edit("block", op2.block, "position"),
+        ...sectionContent(op2.to.section),
+        order("block", op2.block, "section")
+      ];
+      if (op2.to.column !== void 0) t.push(edit("block", op2.block, "column"));
+      if (op2.to.place) t.push(edit("block", op2.block, "grid"));
+      return { touches: t, requires: [...pageReq(op2.page), ["section", op2.to.section]] };
+    }
+    case "block.delete":
+      return {
+        touches: [
+          { path: ["block", op2.block], kind: "delete" },
+          order("block", op2.block, "section")
+        ],
+        requires: pageReq(op2.page)
+      };
+    case "grid.place":
+      return {
+        touches: [
+          edit("block", op2.block, "grid", op2.bp),
+          order("section", op2.section, "props", "layout", "rows"),
+          order("section", op2.section, "props", "layout", "items", op2.block, op2.bp)
+        ],
+        requires: [...pageReq(op2.page), ["section", op2.section]]
+      };
+    case "section.insert":
+      return {
+        touches: [
+          { path: ["section", op2.section.id], kind: "create" },
+          order("page", op2.page, "sections")
+        ],
+        requires: pageReq(op2.page)
+      };
+    case "section.move":
+      return {
+        touches: [edit("section", op2.section, "position"), order("page", op2.page, "sections")],
+        requires: pageReq(op2.page)
+      };
+    case "section.delete":
+      return {
+        touches: [{ path: ["section", op2.section], kind: "delete" }],
+        requires: pageReq(op2.page)
+      };
+    case "section.update":
+      return {
+        touches: patchPaths(op2).map((p) => edit("section", op2.section, "props", ...splitPath(p))),
+        requires: pageReq(op2.page)
+      };
+    case "styles.patch":
+      return {
+        touches: patchPaths(op2.patch).map((p) => edit("styles", ...splitPath(p))),
+        requires: []
+      };
+    case "page.create":
+      return {
+        touches: [{ path: ["page", op2.page.id], kind: "create" }, ...op2.nav ? [edit("nav")] : []],
+        requires: []
+      };
+    case "page.update":
+      return {
+        touches: patchPaths(op2).map((p) => edit("page", op2.page, "props", ...splitPath(p))),
+        requires: []
+      };
+    case "page.delete":
+      return {
+        touches: [{ path: ["page", op2.page], kind: "delete" }, ...op2.nav ? [edit("nav")] : []],
+        requires: []
+      };
+    case "nav.update":
+      return { touches: [edit("nav")], requires: [] };
+    case "site.update":
+      return { touches: patchPaths(op2).map((p) => edit("site", ...splitPath(p))), requires: [] };
+    case "media.add":
+      return { touches: [edit("media", op2.path)], requires: [] };
+    case "media.remove":
+      return { touches: [{ path: ["media", op2.path], kind: "delete" }], requires: [] };
+    case "collection.upsert":
+      return { touches: [edit("item", op2.collection, op2.item.slug)], requires: [] };
+    case "collection.delete":
+      return {
+        touches: [{ path: ["item", op2.collection, op2.slug], kind: "delete" }],
+        requires: []
+      };
+    case "collectionConfig.upsert":
+      return { touches: [edit("collectionConfig", op2.collection)], requires: [] };
+  }
+}
+function isPrefix(a, b) {
+  if (a.length > b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+var overlaps = (a, b) => isPrefix(a, b) || isPrefix(b, a);
+function wins(a, b) {
+  if (a.ts !== b.ts) return a.ts > b.ts;
+  return a.actor >= b.actor;
+}
+function independent(a, b, doc) {
+  const fa = footprint(a, doc);
+  const fb = footprint(b, doc);
+  for (const ta of fa.touches)
+    for (const tb of fb.touches) if (overlaps(ta.path, tb.path)) return false;
+  for (const r of fa.requires)
+    for (const tb of fb.touches) if (tb.kind === "delete" && isPrefix(tb.path, r)) return false;
+  for (const r of fb.requires)
+    for (const ta of fa.touches) if (ta.kind === "delete" && isPrefix(ta.path, r)) return false;
+  return true;
+}
+function strip(op2, paths) {
+  const hit = (p) => paths.some((q) => overlaps(p, q));
+  const stripPatch = (patch, base) => {
+    const set = {};
+    for (const [k, v] of Object.entries(patch.set ?? {}))
+      if (!hit([...base, ...splitPath(k)])) set[k] = v;
+    const unset = (patch.unset ?? []).filter((k) => !hit([...base, ...splitPath(k)]));
+    if (Object.keys(set).length === 0 && unset.length === 0) return null;
+    const out = { ...patch };
+    if (Object.keys(set).length) out.set = set;
+    else delete out.set;
+    if (unset.length) out.unset = unset;
+    else delete out.unset;
+    return out;
+  };
+  switch (op2.op) {
+    case "block.update": {
+      const base = ["block", op2.block];
+      const fields = stripPatch({ set: op2.set, unset: op2.unset }, [...base, "fields"]);
+      const next = { ...op2 };
+      delete next.set;
+      delete next.unset;
+      if (fields?.set) next.set = fields.set;
+      if (fields?.unset) next.unset = fields.unset;
+      for (const prop of ["variant", "style", "column", "label", "hidden"])
+        if (next[prop] !== void 0 && hit([...base, prop])) delete next[prop];
+      const empty = next.set === void 0 && next.unset === void 0 && next.variant === void 0 && next.style === void 0 && next.column === void 0 && next.label === void 0 && next.hidden === void 0;
+      return empty ? null : next;
+    }
+    case "styles.patch": {
+      const patch = stripPatch(op2.patch, ["styles"]);
+      return patch ? { ...op2, patch } : null;
+    }
+    case "site.update":
+      return stripPatch(op2, ["site"]);
+    case "page.update":
+      return stripPatch(op2, ["page", op2.page, "props"]);
+    case "section.update":
+      return stripPatch(op2, ["section", op2.section, "props"]);
+    case "page.create":
+    case "page.delete": {
+      const own = op2.op === "page.create" ? op2.page.id : op2.page;
+      if (hit(["page", own])) return null;
+      const { nav: _nav, ...rest } = op2;
+      return rest;
+    }
+    default:
+      return null;
+  }
+}
+var key = (p) => p.join("/");
+function rebase(localPending, remoteOps, options = {}) {
+  const conflicts = [];
+  const dropped = [];
+  const kept = [];
+  const step = (d, o) => {
+    if (!d) return void 0;
+    try {
+      return apply(d, o);
+    } catch {
+      return d;
+    }
+  };
+  let rd = options.base;
+  const remotes = remoteOps.map((r) => {
+    const fp = footprint(r, rd);
+    rd = step(rd, r);
+    return { op: r, fp };
+  });
+  let ld = options.base;
+  for (const local of localPending) {
+    let cur = local;
+    const localDoc = ld;
+    ld = step(ld, local);
+    for (const { op: remote, fp: rfp } of remotes) {
+      if (!cur) break;
+      const lfp = footprint(cur, localDoc);
+      const deletedHits = [];
+      for (const rt of rfp.touches) {
+        if (rt.kind !== "delete") continue;
+        const dependent = lfp.requires.some((r) => isPrefix(rt.path, r)) || lfp.touches.some((lt) => isPrefix(rt.path, lt.path) && lt.kind !== "create");
+        if (dependent) deletedHits.push(rt.path);
+      }
+      if (deletedHits.length) {
+        const bothDelete = lfp.touches.filter((lt) => lt.kind !== "order").every((lt) => lt.kind === "delete" && deletedHits.some((d) => isPrefix(d, lt.path)));
+        if (!bothDelete)
+          conflicts.push({
+            local,
+            remote,
+            winner: "remote",
+            reason: "deleted",
+            paths: deletedHits.map(key),
+            message: `${remote.actor} deleted this`
+          });
+        dropped.push(local);
+        cur = null;
+        break;
+      }
+      const pairs = [];
+      for (const lt of lfp.touches) {
+        if (lt.kind === "order") continue;
+        for (const rt of rfp.touches)
+          if (rt.kind !== "order" && overlaps(lt.path, rt.path)) pairs.push({ l: lt, r: rt });
+      }
+      if (pairs.length === 0) continue;
+      const paths = [
+        ...new Set(pairs.map((p) => key(p.l.path.length >= p.r.path.length ? p.l.path : p.r.path)))
+      ];
+      if (pairs.some((p) => p.l.kind === "create" && p.r.kind === "create")) {
+        conflicts.push({
+          local,
+          remote,
+          winner: "remote",
+          reason: "duplicate",
+          paths,
+          message: `${remote.actor} already added this`
+        });
+        dropped.push(local);
+        cur = null;
+        break;
+      }
+      const localDeletes = pairs.some((p) => p.l.kind === "delete");
+      if (localDeletes || wins(cur, remote)) {
+        conflicts.push({
+          local,
+          remote,
+          winner: "local",
+          reason: "concurrent-edit",
+          paths,
+          message: `${remote.actor} changed this too`
+        });
+        continue;
+      }
+      conflicts.push({
+        local,
+        remote,
+        winner: "remote",
+        reason: "concurrent-edit",
+        paths,
+        message: `${remote.actor} changed this too`
+      });
+      cur = strip(
+        cur,
+        pairs.map((p) => p.r.path)
+      );
+      if (!cur) dropped.push(local);
+    }
+    if (cur) kept.push(cur);
+  }
+  if (!options.doc) return { ops: kept, conflicts, dropped };
+  const ops = [];
+  let doc = options.doc;
+  for (const op2 of kept) {
+    const fixed = normalizePositions(doc, op2);
+    const r = validate(doc, fixed, { trusted: true });
+    if (r.ok) {
+      ops.push(fixed);
+      doc = r.doc;
+    } else {
+      dropped.push(op2);
+      conflicts.push({
+        local: op2,
+        winner: "remote",
+        reason: "invalid",
+        paths: [],
+        message: r.errors[0]?.message ?? "This change no longer applies"
+      });
+    }
+  }
+  return { ops, conflicts, dropped };
+}
+function normalizePositions(doc, op2) {
+  const fix = (ids, at) => {
+    if (!ids) return at;
+    if (typeof at === "number") return at > ids.length ? "end" : at;
+    if (typeof at === "string") return at;
+    const anchor = "before" in at ? at.before : at.after;
+    return ids.includes(anchor) ? at : "end";
+  };
+  switch (op2.op) {
+    case "block.insert": {
+      const s = findSection(doc, op2.page, op2.section)?.section;
+      return {
+        ...op2,
+        at: fix(
+          s?.blocks.map((b) => b.id),
+          op2.at
+        )
+      };
+    }
+    case "block.move": {
+      const s = findSection(doc, op2.page, op2.to.section)?.section;
+      const ids = s?.blocks.map((b) => b.id).filter((id) => id !== op2.block);
+      return { ...op2, to: { ...op2.to, at: fix(ids, op2.to.at) } };
+    }
+    case "section.insert": {
+      const p = getPage(doc, op2.page);
+      return {
+        ...op2,
+        at: fix(
+          p?.sections.map((s) => s.id),
+          op2.at
+        )
+      };
+    }
+    case "section.move": {
+      const p = getPage(doc, op2.page);
+      return {
+        ...op2,
+        at: fix(
+          p?.sections.map((s) => s.id).filter((id) => id !== op2.section),
+          op2.at
+        )
+      };
+    }
+    default:
+      return op2;
+  }
+}
+
+// src/roles.ts
+var ROLES = ["owner", "designer", "editor", "contributor"];
+function sectionLook(section) {
+  const layout = section.layout;
+  if (layout.mode !== "grid") return { layout, style: section.style };
+  const order2 = new Map(section.blocks.map((b, i) => [b.id, i]));
+  const items = Object.entries(layout.items).map(([id, item]) => [order2.get(id) ?? -1, item]).sort((a, b) => a[0] - b[0]);
+  return { layout: { ...layout, items }, style: section.style };
+}
+function isKnownSectionLook(section, context) {
+  const look = sectionLook(section);
+  if (section.preset && context.presetSection) {
+    const built = context.presetSection(section.preset, section.style?.colorTheme);
+    if (built && deepEqual(sectionLook(built), look)) return true;
+  }
+  const doc = context.doc;
+  if (!doc) return false;
+  if (deepEqual(sectionLook(doc.site.footer), look)) return true;
+  for (const page of Object.values(doc.pages))
+    for (const s of page.sections) if (deepEqual(sectionLook(s), look)) return true;
+  return false;
+}
+function lockedSectionsOf(doc) {
+  const out = /* @__PURE__ */ new Set();
+  if (doc.site.footer.locked) out.add(doc.site.footer.id);
+  for (const page of Object.values(doc.pages))
+    for (const s of page.sections) if (s.locked) out.add(s.id);
+  return out;
+}
+var CONTENT_KINDS = /* @__PURE__ */ new Set(["text", "richText", "image"]);
+function isImageValue(v) {
+  return isPlainObject(v) && typeof v.src === "string";
+}
+function contentShape(v) {
+  if (typeof v === "string") return "string";
+  if (isPlainObject(v) && v.type === "doc" && Array.isArray(v.content)) return "doc";
+  if (isImageValue(v)) return "image";
+  if (Array.isArray(v) && v.length > 0 && v.every(isImageValue)) return "images";
+  return void 0;
+}
+function sameContentShape(before, after) {
+  const a = contentShape(before);
+  return a !== void 0 && a === contentShape(after);
+}
+function isTextOrImageValue(v) {
+  if (typeof v === "string") return true;
+  if (isPlainObject(v) && v.type === "doc" && Array.isArray(v.content)) return true;
+  if (isImageValue(v)) return true;
+  return Array.isArray(v) && v.length > 0 && v.every(isImageValue);
+}
+var deny = (reason) => ({ allowed: false, reason });
+function isInverseOf(op2, priorOp, docBefore) {
+  let expected;
+  try {
+    expected = invert(docBefore, priorOp);
+  } catch {
+    return false;
+  }
+  const strip2 = ({ id: _i, actor: _a, ts: _t, ...body }) => body;
+  return deepEqual(strip2(op2), strip2(expected));
+}
+function transformForRole(op2, role, lockedSections, context = {}) {
+  const allow = { allowed: true, op: op2 };
+  if (role === "owner" || role === "designer") return allow;
+  const { doc, registry } = context;
+  if (role === "contributor") {
+    if (op2.op !== "collection.upsert")
+      return deny("Contributors can only create and edit draft collection items");
+    if (op2.item.frontmatter.status !== "draft")
+      return deny("Contributors can only save items as drafts; an editor publishes them");
+    if (!doc) return deny("Can't check this item without the current document");
+    const existing = doc.collections[op2.collection]?.[op2.item.slug];
+    if (existing && existing.frontmatter.status !== "draft")
+      return deny("This item is already published or scheduled; only editors can change it");
+    if (existing) {
+      const author = context.itemAuthor?.(op2.collection, op2.item.slug);
+      if (!context.userId || !author || author !== context.userId)
+        return deny("Someone else started this draft; only they or an editor can change it");
+    }
+    return allow;
+  }
+  if (role !== "editor") return deny(`Unknown role ${String(role)}`);
+  const locked = new Set(lockedSections);
+  const sectionOfBlock = (page, block) => {
+    if (!doc) return void 0;
+    const loc = findBlock(doc, page, block) ?? locateBlock(doc, block);
+    return loc?.section.id;
+  };
+  const isLocked = (section) => section === void 0 || locked.has(section);
+  const sectionById = (page, id) => doc ? findSection(doc, page, id)?.section : void 0;
+  const NO_GRID = "Editors can't reposition blocks on the grid";
+  switch (op2.op) {
+    case "styles.patch":
+      return deny("Editors can't change site styles");
+    case "grid.place":
+      return deny("Editors can't reposition blocks on the grid");
+    case "section.update": {
+      const paths = patchPaths(op2);
+      if (paths.some((p) => isPathPrefix("layout", p) || isPathPrefix("style", p)))
+        return deny("Editors can't change section layout or style");
+      if (paths.some((p) => isPathPrefix("locked", p)))
+        return deny("Only owners and designers can lock or unlock sections");
+      if (locked.has(op2.section)) return deny("This section is locked");
+      return allow;
+    }
+    case "section.move":
+    case "section.delete":
+      if (locked.has(op2.section)) return deny("This section is locked");
+      return allow;
+    case "section.insert":
+      if (op2.section.locked) return deny("Only owners and designers can lock sections");
+      if (!isKnownSectionLook(op2.section, context))
+        return deny(
+          "Editors add sections from the section gallery (or duplicate one); its layout and style come from the design"
+        );
+      return allow;
+    case "block.insert":
+      if (locked.has(op2.section)) return deny("This section is locked");
+      if (op2.place || op2.rows) return deny(NO_GRID);
+      return allow;
+    case "block.delete":
+      if (isLocked(sectionOfBlock(op2.page, op2.block))) return deny("This section is locked");
+      if (op2.rows) return deny(NO_GRID);
+      return allow;
+    case "block.move": {
+      const from = sectionOfBlock(op2.page, op2.block);
+      if (isLocked(from) || locked.has(op2.to.section)) return deny("This section is locked");
+      if (op2.to.place || op2.to.rows || op2.fromRows) return deny(NO_GRID);
+      if (from !== op2.to.section) {
+        const src = sectionById(op2.page, from);
+        const dest = sectionById(op2.page, op2.to.section);
+        if (!src || !dest) return deny("Can't check this move without the current document");
+        if (src.layout.mode === "grid" || dest.layout.mode === "grid") return deny(NO_GRID);
+      }
+      return allow;
+    }
+    case "block.update": {
+      const section = sectionOfBlock(op2.page, op2.block);
+      if (!isLocked(section)) return allow;
+      if (op2.variant !== void 0 || op2.style !== void 0 || op2.column !== void 0 || op2.label !== void 0 || op2.hidden !== void 0)
+        return deny("This section is locked: only its text and images can change");
+      if (op2.unset?.length) return deny("This section is locked: fields can't be removed");
+      const block = doc ? findBlock(doc, op2.page, op2.block)?.block : void 0;
+      if (!block) return deny("Can't check this edit without the current document");
+      const def = registry?.get(block.type);
+      for (const [key2, value] of Object.entries(op2.set ?? {})) {
+        const kind = def?.meta.fields[key2]?.kind;
+        const ok = def ? kind !== void 0 && CONTENT_KINDS.has(kind) : block.fields[key2] !== void 0 && sameContentShape(block.fields[key2], value);
+        if (!ok) return deny(`This section is locked: "${key2}" is not a text or image field`);
+      }
+      return allow;
+    }
+    case "site.update": {
+      const paths = patchPaths(op2);
+      if (paths.some((p) => /^(customCss|headInjection|footerInjection)(\.|$)/.test(p)))
+        return deny("Editors can't change custom code");
+      if (paths.some((p) => isPathPrefix("footer", p)))
+        return deny("Editors change the footer through its blocks");
+      if (paths.some((p) => isPathPrefix("header", p)))
+        return deny("Editors can't change the header layout; ask a designer");
+      return allow;
+    }
+    case "page.update":
+      if (patchPaths(op2).some((p) => /^(headInjection|footerInjection)(\.|$)/.test(p)))
+        return deny("Editors can't change custom code");
+      return allow;
+    case "page.create":
+      if (op2.page.headInjection !== void 0 || op2.page.footerInjection !== void 0)
+        return deny("Editors can't change custom code");
+      if (op2.page.sections.some((s) => s.locked))
+        return deny("Only owners and designers can lock sections");
+      if (!op2.page.sections.every((s) => isKnownSectionLook(s, context)))
+        return deny(
+          "Editors build pages from the section gallery; layout and style come from the design"
+        );
+      return allow;
+    case "page.delete": {
+      const page = doc?.pages[op2.page];
+      if (!page) return deny("Can't check this page without the current document");
+      if (page.sections.some((s) => s.locked || locked.has(s.id)))
+        return deny("This page has locked sections; only owners and designers can delete it");
+      return allow;
+    }
+    default:
+      return allow;
+  }
+}
+
+// src/summarize.ts
+var STYLE_LABELS = {
+  "choices.palette.brand": "brand color",
+  "choices.palette": "color palette",
+  "choices.pairing": "fonts",
+  "choices.density": "spacing",
+  "choices.shape": "corner style",
+  "choices.buttons": "button style",
+  "choices.motion": "motion",
+  "choices.imageTreatment": "image style",
+  "overrides.type": "typography",
+  "overrides.font": "typography",
+  "overrides.space": "spacing",
+  "overrides.radius": "corner style"
+};
+function styleLabel(path) {
+  const color = /^overrides\.color\.([^.]+)/.exec(path);
+  if (color) return `${color[1].replace(/-/g, " ")} color`;
+  let best = "";
+  for (const prefix of Object.keys(STYLE_LABELS))
+    if ((path === prefix || path.startsWith(`${prefix}.`)) && prefix.length > best.length)
+      best = prefix;
+  return best ? STYLE_LABELS[best] : "site styles";
+}
+function stats(ops, doc) {
+  const s = {
+    ops: ops.length,
+    pagesEdited: [],
+    pagesCreated: [],
+    pagesDeleted: [],
+    footerEdited: false,
+    sectionsAdded: 0,
+    sectionsRemoved: 0,
+    sectionsMoved: 0,
+    blocksAdded: 0,
+    blocksRemoved: 0,
+    blocksMoved: 0,
+    blocksEdited: 0,
+    imagesAdded: 0,
+    imagesRemoved: 0,
+    filesAdded: 0,
+    filesRemoved: 0,
+    stylesChanged: [],
+    navChanged: false,
+    siteSettingsChanged: false,
+    itemsSaved: 0,
+    itemsDeleted: 0,
+    collectionSettingsChanged: 0
+  };
+  const edited = /* @__PURE__ */ new Set();
+  const created = /* @__PURE__ */ new Set();
+  const deleted = /* @__PURE__ */ new Set();
+  const editedBlocks = /* @__PURE__ */ new Set();
+  const styleLabels = /* @__PURE__ */ new Set();
+  const configs = /* @__PURE__ */ new Set();
+  const touch = (page) => {
+    if (page === FOOTER) s.footerEdited = true;
+    else edited.add(page);
+  };
+  for (const op2 of ops) {
+    switch (op2.op) {
+      case "block.update":
+      case "grid.place":
+        touch(op2.page);
+        editedBlocks.add(op2.block);
+        break;
+      case "block.insert":
+        touch(op2.page);
+        s.blocksAdded++;
+        break;
+      case "block.delete":
+        touch(op2.page);
+        s.blocksRemoved++;
+        break;
+      case "block.move":
+        touch(op2.page);
+        s.blocksMoved++;
+        break;
+      case "section.insert":
+        touch(op2.page);
+        s.sectionsAdded++;
+        break;
+      case "section.delete":
+        touch(op2.page);
+        s.sectionsRemoved++;
+        break;
+      case "section.move":
+        touch(op2.page);
+        s.sectionsMoved++;
+        break;
+      case "section.update":
+      case "page.update":
+        touch(op2.page);
+        break;
+      case "styles.patch":
+        for (const p of patchPaths(op2.patch)) styleLabels.add(styleLabel(p));
+        break;
+      case "page.create":
+        if (deleted.has(op2.page.id)) deleted.delete(op2.page.id);
+        else created.add(op2.page.id);
+        if (op2.nav) s.navChanged = true;
+        break;
+      case "page.delete":
+        if (created.has(op2.page)) created.delete(op2.page);
+        else deleted.add(op2.page);
+        if (op2.nav) s.navChanged = true;
+        break;
+      case "nav.update":
+        s.navChanged = true;
+        break;
+      case "site.update":
+        if (patchPaths(op2).some((p) => p === "footer" || p.startsWith("footer.")))
+          s.footerEdited = true;
+        if (patchPaths(op2).some((p) => p !== "footer" && !p.startsWith("footer.")))
+          s.siteSettingsChanged = true;
+        break;
+      case "media.add":
+        if (!Object.hasOwn(doc.media, op2.path)) {
+          if (op2.meta.kind === "image") s.imagesAdded++;
+          else s.filesAdded++;
+        }
+        break;
+      case "media.remove": {
+        const kind = doc.media[op2.path]?.kind;
+        if (kind === "image") s.imagesRemoved++;
+        else s.filesRemoved++;
+        break;
+      }
+      case "collection.upsert":
+        s.itemsSaved++;
+        break;
+      case "collection.delete":
+        s.itemsDeleted++;
+        break;
+      case "collectionConfig.upsert":
+        configs.add(op2.collection);
+        break;
+    }
+  }
+  s.pagesCreated = [...created];
+  s.pagesDeleted = [...deleted];
+  s.pagesEdited = [...edited].filter((id) => !created.has(id) && !deleted.has(id));
+  s.blocksEdited = editedBlocks.size;
+  s.stylesChanged = [...styleLabels];
+  s.collectionSettingsChanged = configs.size;
+  return s;
+}
+function list(items, max = 3, noun = "pages") {
+  if (items.length === 0) return "";
+  if (items.length === 1) return items[0];
+  if (items.length <= max)
+    return `${items.slice(0, -1).join(", ")} and ${items[items.length - 1]}`;
+  const rest = items.length - (max - 1);
+  return `${items.slice(0, max - 1).join(", ")} and ${rest} other ${noun}`;
+}
+var count = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function summarize(ops, doc) {
+  const s = stats(ops, doc);
+  const created = /* @__PURE__ */ new Map();
+  for (const op2 of ops) if (op2.op === "page.create") created.set(op2.page.id, op2.page.title);
+  const title = (id) => doc.pages[id]?.title ?? created.get(id) ?? id;
+  const parts = [];
+  const editedNames = s.pagesEdited.map(title);
+  if (s.footerEdited) editedNames.push("the footer");
+  if (editedNames.length) parts.push(`edited ${list(editedNames)}`);
+  if (s.pagesCreated.length)
+    parts.push(
+      s.pagesCreated.length <= 2 ? `added ${s.pagesCreated.length === 1 ? "page" : "pages"} ${list(s.pagesCreated.map(title))}` : `added ${count(s.pagesCreated.length, "page")}`
+    );
+  if (s.pagesDeleted.length)
+    parts.push(
+      s.pagesDeleted.length <= 2 ? `deleted ${s.pagesDeleted.length === 1 ? "page" : "pages"} ${list(s.pagesDeleted.map(title))}` : `deleted ${count(s.pagesDeleted.length, "page")}`
+    );
+  if (s.imagesAdded) parts.push(`added ${count(s.imagesAdded, "image")}`);
+  if (s.filesAdded) parts.push(`added ${count(s.filesAdded, "file")}`);
+  if (s.imagesRemoved) parts.push(`removed ${count(s.imagesRemoved, "image")}`);
+  if (s.filesRemoved) parts.push(`removed ${count(s.filesRemoved, "file")}`);
+  if (s.stylesChanged.length) parts.push(`changed ${list(s.stylesChanged, 3, "styles")}`);
+  if (s.navChanged) parts.push("updated navigation");
+  if (s.siteSettingsChanged) parts.push("updated site settings");
+  if (s.itemsSaved) parts.push(`saved ${count(s.itemsSaved, "collection item")}`);
+  if (s.itemsDeleted) parts.push(`deleted ${count(s.itemsDeleted, "collection item")}`);
+  if (s.collectionSettingsChanged)
+    parts.push(`updated settings for ${count(s.collectionSettingsChanged, "collection")}`);
+  if (parts.length === 0) return "No changes";
+  const text = parts.join("; ");
+  return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+// src/index.ts
+var name = "@omniharmonic/openspace-ops";
+export {
+  BlockDeleteOpSchema,
+  BlockInsertOpSchema,
+  BlockMoveOpSchema,
+  BlockUpdateOpSchema,
+  BreakpointSchema,
+  CollectionConfigUpsertOpSchema,
+  CollectionDeleteOpSchema,
+  CollectionUpsertOpSchema,
+  ContainerIdSchema,
+  FOOTER,
+  GridPlaceOpSchema,
+  MediaAddOpSchema,
+  MediaRemoveOpSchema,
+  NavUpdateOpSchema,
+  OP_TYPES,
+  OpError,
+  OpMetaShape,
+  OpSchema,
+  PROTECTED_PATHS,
+  PageCreateOpSchema,
+  PageDeleteOpSchema,
+  PageUpdateOpSchema,
+  PatchShape,
+  PathSchema,
+  PositionSchema,
+  ROLES,
+  RowsSchema,
+  SectionDeleteOpSchema,
+  SectionInsertOpSchema,
+  SectionMoveOpSchema,
+  SectionUpdateOpSchema,
+  SiteUpdateOpSchema,
+  StylesPatchOpSchema,
+  apply,
+  applyAll,
+  autoPlace,
+  containerPath,
+  deepEqual,
+  diff,
+  effectiveRect,
+  findBlock,
+  findSection,
+  footprint,
+  independent,
+  indexIds,
+  invert,
+  invertAll,
+  isInverseOf,
+  isJson,
+  isKnownSectionLook,
+  isTextOrImageValue,
+  locateBlock,
+  locateSection,
+  lockedSectionsOf,
+  mutate,
+  name,
+  parseOp,
+  pruneNav,
+  raiseRows,
+  rebase,
+  resolvePosition,
+  sameContentShape,
+  sectionsOf,
+  siteRefIssues,
+  stamp,
+  stats,
+  styleLabel,
+  summarize,
+  transformForRole,
+  usedRows,
+  validate,
+  validateAll,
+  validateDocument,
+  wins
+};
+//# sourceMappingURL=index.js.map