@acms-subir/core 0.3.3-next.20260929113209 → 0.3.4

package/src/lib/calendar/render.ts

@@ -105,9 +105,9 @@ const dotStyle = (e: DisplayEvent) => (e.k ? ` style="--cal-dot:${e.k}"` : '');
 const chipHtml = (e: DisplayEvent, i: number) =>
   `<button type="button" class="pc-cal-event${e.x ? ' is-cancelled' : ''}" data-ev="${i}" data-cal="${e.c}"${dotStyle(e)}><span class="t">${esc(e.tm)}</span><b>${esc(e.t)}</b></button>`;
 
-function monthGridHtml(y: number, m: number, todayN: number, byDay: Map<number, number[]>, events: DisplayEvent[], dows: string[], monthsShort: string[]): string {
+function monthGridHtml(y: number, m: number, todayN: number, byDay: Map<number, number[]>, events: DisplayEvent[], dows: string[], monthsShort: string[], ws: number): string {
   const first = dayNum(y, m, 1);
-  const start = first - dowOfDay(first);
+  const start = first - ((dowOfDay(first) - ws + 7) % 7);
   let h = dows.map((d) => `<div class="pc-cal-dow">${esc(d)}</div>`).join('');
   for (let i = 0; i < 42; i++) {
     const n = start + i;
@@ -149,7 +149,7 @@ var body=root.querySelector('.pc-cal-body'),titleEl=root.querySelector('.pc-cal-
 var D=864e5;
 function dnum(a){return Math.round(Date.UTC(a[0],a[1]-1,a[2])/D)}
 function fday(n){var d=new Date(n*D);return[d.getUTCFullYear(),d.getUTCMonth()+1,d.getUTCDate()]}
-function dow(n){return((n+4)%7+7)%7}
+function dow(n){return((n+4-(P.ws||0))%7+7)%7}
 var byDay={};P.events.forEach(function(e,i){var n0=dnum(e.d);for(var k=0;k<Math.min(e.n,60);k++){(byDay[n0+k]=byDay[n0+k]||[]).push(i)}});
 function esc(s){return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;')}
 function chip(i){var e=P.events[i];return '<button type="button" class="pc-cal-event'+(e.x?' is-cancelled':'')+'" data-ev="'+i+'" data-cal="'+e.c+'"'+(e.k?' style="--cal-dot:'+e.k+'"':'')+'><span class="t">'+esc(e.tm)+'</span><b>'+esc(e.t)+'</b></button>'}
@@ -246,7 +246,9 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     new Intl.DateTimeFormat(locale, { ...o, timeZone: 'UTC' }).format(ms);
   const months = Array.from({ length: 12 }, (_, i) => utcLabel({ month: 'long' }, Date.UTC(2026, i, 1)));
   const monthsShort = Array.from({ length: 12 }, (_, i) => utcLabel({ month: 'short' }, Date.UTC(2026, i, 1)));
-  const dows = Array.from({ length: 7 }, (_, i) => utcLabel({ weekday: 'short' }, Date.UTC(2026, 7, 2 + i))); // Aug 2 2026 = Sunday
+  // Calendar settings → Defaults → "Weeks start on" (0 Sunday, 1 Monday)
+  const ws = settings.calendar?.weekStart ?? 0;
+  const dows = Array.from({ length: 7 }, (_, i) => utcLabel({ weekday: 'short' }, Date.UTC(2026, 7, 2 + ws + i))); // Aug 2 2026 = Sunday
 
   const focusOk = opts.focus && (opts.focus.y * 12 + opts.focus.m) >= minY * 12 + minM && (opts.focus.y * 12 + opts.focus.m) <= maxY * 12 + maxM;
   const [fy, fm] = focusOk ? [opts.focus!.y, opts.focus!.m] : [today.y, today.m];
@@ -254,7 +256,7 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
   let bodyHtml: string;
   let titleText: string;
   if (opts.view === 'week') {
-    const weekStart = todayN - dowOfDay(todayN);
+    const weekStart = todayN - ((dowOfDay(todayN) - ws + 7) % 7);
     const wa = fromDayNum(weekStart);
     const wb = fromDayNum(weekStart + 6);
     titleText = `${monthsShort[wa.m - 1]} ${wa.d} – ${wa.m === wb.m ? '' : `${monthsShort[wb.m - 1]} `}${wb.d}, ${wb.y}`;
@@ -267,7 +269,7 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     if (!order.length && opts.emptyText) bodyHtml = `<p class="pc-cal-empty">${esc(opts.emptyText)}</p>`;
   } else {
     titleText = `${months[fm - 1]} ${fy}`;
-    bodyHtml = monthGridHtml(fy, fm, todayN, byDay, events, dows, monthsShort);
+    bodyHtml = monthGridHtml(fy, fm, todayN, byDay, events, dows, monthsShort, ws);
   }
 
   const navButtons =
@@ -287,7 +289,7 @@ export function renderCalendarView(raw: ViewEvent[], settings: Settings, now: nu
     month: [fy, fm],
     min: [minY, minM],
     max: [maxY, maxM],
-    months, monthsShort, dows, events,
+    months, monthsShort, dows, events, ws,
     details: 'Details', cancelled: 'Cancelled',
   };
   const json = JSON.stringify(payload).replace(/</g, '\\u003c');

package/src/lib/calendar/schedule.ts

@@ -0,0 +1,166 @@
+// Writes behind the admin Schedule: quick add, drag to move (a whole series
+// or one occurrence), undo, duplicate. Everything goes through the same
+// save/apply path as the event editor, so hooks, feeds, search and webhooks
+// see the same changes. A move applies at once, even on a published event —
+// the editor's "stage until Update" flow is for content edits, not dates.
+import type { ContentRepository } from '../repo/types';
+import type { CalEvent } from '../schema';
+import { slugify } from '../schema';
+import { ApiError } from '../api';
+import { applyEventUpdate, saveEvent, type SaveHooks } from '../content-service';
+import { addWallDays, formatWall, parseWall } from './events';
+import { rruleMap, WEEKDAY_CODES, weekdayOf } from './rrule';
+import { eventDeleted } from './hooks';
+import { waitUntilFrom } from '../webhooks';
+
+async function uniqueSlug(repo: ContentRepository, title: string) {
+  const base = slugify(title) || 'event';
+  let slug = base;
+  for (let n = 2; await repo.getEventBySlug(slug); n++) slug = `${base}-${n}`;
+  return slug;
+}
+
+const live = (s: CalEvent['status']) => s === 'published' || s === 'scheduled';
+
+// Save on a live event without staging: stage, then apply just this change.
+// Refuses when the event already has unrelated unpublished edits, so a drag
+// never publishes someone's half-finished copy.
+async function saveNow(repo: ContentRepository, e: CalEvent, data: Parameters<typeof saveEvent>[2], hooks: SaveHooks) {
+  if (live(e.status) && e.draft) {
+    throw new ApiError(409, 'This event has unpublished changes. Open it and update or discard them first.');
+  }
+  const saved = await saveEvent(repo, e.id, data, hooks);
+  return live(e.status) ? applyEventUpdate(repo, e.id, hooks) : saved;
+}
+
+export interface QuickEvent {
+  title: string;
+  start: string; // YYYY-MM-DD or YYYY-MM-DDTHH:mm
+  end: string;
+  allDay: boolean;
+  calendarId: string;
+  rrule: string;
+  location: string;
+  publish: boolean;
+  // bookable rooms/people this event uses (held while it happens)
+  roomIds?: string[];
+}
+
+export async function quickCreate(repo: ContentRepository, q: QuickEvent, hooks: SaveHooks): Promise<CalEvent> {
+  const title = q.title.trim().slice(0, 300) || 'Untitled event';
+  const cal = q.calendarId ? await repo.getCalendar(q.calendarId) : null;
+  const created = await repo.createEvent({
+    title, slug: await uniqueSlug(repo, title), start: q.start, allDay: q.allDay, status: 'draft',
+    calendarIds: cal?.kind === 'native' ? [cal.id] : [],
+    location: { name: q.location.trim().slice(0, 300), address: '', url: '' },
+  });
+  if (q.roomIds?.length) await saveEvent(repo, created.id, { roomHold: { resourceIds: q.roomIds, span: 'event', before: 0, after: 0, whileDraft: false, keep: [] } }, hooks);
+  // times + repeat go through the editor's validation (end defaults, pairs)
+  await saveEvent(repo, created.id, { start: q.start, end: q.end || undefined, allDay: q.allDay, rrule: q.rrule }, hooks);
+  return q.publish ? saveEvent(repo, created.id, { status: 'published' }, hooks) : (await repo.getEvent(created.id))!;
+}
+
+// Shift a recurrence rule by whole days so "weekly on Wednesday" moved two
+// days later becomes "weekly on Friday" (and nth-weekday / day-of-month
+// rules follow the new first date). UNTIL moves with the series.
+export function shiftRrule(rrule: string, days: number, newStart: string): string {
+  if (!rrule || !days) return rrule;
+  const p = rruleMap(rrule);
+  if (p.FREQ === 'WEEKLY' && p.BYDAY) {
+    p.BYDAY = p.BYDAY.split(',').map((c) => {
+      const i = (WEEKDAY_CODES as readonly string[]).indexOf(c);
+      return i < 0 ? c : WEEKDAY_CODES[(((i + days) % 7) + 7) % 7];
+    }).join(',');
+  }
+  if (p.FREQ === 'MONTHLY') {
+    const wd = weekdayOf(newStart);
+    if (p.BYDAY && /^-?\d(SU|MO|TU|WE|TH|FR|SA)$/.test(p.BYDAY)) p.BYDAY = `${wd.nth >= 5 || p.BYDAY.startsWith('-') ? -1 : wd.nth}${WEEKDAY_CODES[wd.dow]}`;
+    else if (p.BYMONTHDAY && !p.BYMONTHDAY.includes(',')) p.BYMONTHDAY = String(wd.day);
+  }
+  if (p.UNTIL && /^\d{8}$/.test(p.UNTIL)) {
+    const u = parseWall(`${p.UNTIL.slice(0, 4)}-${p.UNTIL.slice(4, 6)}-${p.UNTIL.slice(6, 8)}`);
+    if (u) p.UNTIL = formatWall(addWallDays(u, days)).replace(/-/g, '');
+  }
+  const order = ['FREQ', 'INTERVAL', 'BYDAY', 'BYMONTHDAY', 'BYMONTH', 'COUNT', 'UNTIL', 'WKST'];
+  return Object.entries(p).sort(([a], [b]) => order.indexOf(a) - order.indexOf(b)).map(([k, v]) => `${k}=${v}`).join(';');
+}
+
+const shift = (wall: string, days: number) => {
+  const w = parseWall(wall);
+  return w ? formatWall(addWallDays(w, days)) : wall;
+};
+
+export type MoveUndo =
+  | { kind: 'series'; id: string; days: number }
+  | { kind: 'split'; id: string; seriesId: string; occurrence: string };
+
+// Move a whole event (and every repeat) by `days`
+export async function moveSeries(repo: ContentRepository, id: string, days: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo }> {
+  const e = await repo.getEvent(id);
+  if (!e) throw new ApiError(404, 'Event not found.');
+  if (!Number.isInteger(days) || Math.abs(days) > 3660) throw new ApiError(400, 'Pick a day to move it to.');
+  const start = shift(e.start, days);
+  const event = await saveNow(repo, e, {
+    start, end: shift(e.end, days), allDay: e.allDay,
+    ...(e.rrule ? { rrule: shiftRrule(e.rrule, days, start), exdates: e.exdates.map((x) => shift(x, days)) } : {}),
+  }, hooks);
+  return { event, undo: { kind: 'series', id, days: -days } };
+}
+
+// Move one occurrence of a repeating event: skip that date in the series and
+// add a one-off copy on the new date. No schema change, and the copy is a
+// normal event the editor can open.
+export async function moveOccurrence(repo: ContentRepository, id: string, occurrence: string, days: number, hooks: SaveHooks): Promise<{ event: CalEvent; undo: MoveUndo }> {
+  const e = await repo.getEvent(id);
+  if (!e) throw new ApiError(404, 'Event not found.');
+  if (!e.rrule) return moveSeries(repo, id, days, hooks);
+  const occ = parseWall(occurrence);
+  const first = parseWall(e.start);
+  if (!occ || !first) throw new ApiError(400, 'That date isn’t part of this event.');
+  if (e.exdates.includes(occurrence)) throw new ApiError(409, 'That date was already removed from the series.');
+  // keep the occurrence's own length (first occurrence's start → end)
+  const toMs = (w: { y: number; m: number; d: number; hh: number; mm: number }) => Date.UTC(w.y, w.m - 1, w.d, w.hh, w.mm);
+  const lenMs = toMs(parseWall(e.end) ?? first) - toMs(first);
+  const newStart = addWallDays(occ, days);
+  const t = new Date(toMs(newStart) + lenMs);
+  const pad = (n: number) => String(n).padStart(2, '0');
+  const endDay = `${t.getUTCFullYear()}-${pad(t.getUTCMonth() + 1)}-${pad(t.getUTCDate())}`;
+  const endStr = e.allDay ? endDay : `${endDay}T${pad(t.getUTCHours())}:${pad(t.getUTCMinutes())}`;
+
+  await saveNow(repo, e, { exdates: [...e.exdates, occurrence] }, hooks);
+  const copy = await repo.createEvent({
+    title: e.title, slug: await uniqueSlug(repo, e.title), start: formatWall(newStart), end: endStr, allDay: e.allDay,
+    timezone: e.timezone, status: 'draft', excerpt: e.excerpt, bodyJson: e.bodyJson, bodyHtml: e.bodyHtml, cover: e.cover, coverAlt: e.coverAlt,
+    location: e.location, cta: e.cta, calendarIds: e.calendarIds, fields: e.fields, tags: e.tags, cancelled: e.cancelled, rsvp: e.rsvp,
+    template: e.template, featured: false,
+  });
+  const event = live(e.status) ? await saveEvent(repo, copy.id, { status: 'published' }, hooks) : copy;
+  return { event, undo: { kind: 'split', id: copy.id, seriesId: e.id, occurrence } };
+}
+
+export async function undoMove(repo: ContentRepository, undo: MoveUndo, hooks: SaveHooks): Promise<void> {
+  if (undo.kind === 'series') {
+    await moveSeries(repo, undo.id, undo.days, hooks);
+    return;
+  }
+  const series = await repo.getEvent(undo.seriesId);
+  const copy = await repo.getEvent(undo.id);
+  if (copy) {
+    await repo.deleteEvent(copy.id);
+    await eventDeleted(repo, copy, { waitUntil: waitUntilFrom(hooks.locals) });
+  }
+  if (series) await saveNow(repo, series, { exdates: series.exdates.filter((x) => x !== undo.occurrence) }, hooks);
+}
+
+export async function duplicateEvent(repo: ContentRepository, id: string): Promise<CalEvent> {
+  const e = await repo.getEvent(id);
+  if (!e) throw new ApiError(404, 'Event not found.');
+  const src = e.draft ? { ...e, ...(e.draft as Partial<CalEvent>) } : e;
+  const title = `${src.title} (copy)`;
+  return repo.createEvent({
+    title, slug: await uniqueSlug(repo, title), start: src.start, end: src.end, allDay: src.allDay, timezone: src.timezone,
+    rrule: src.rrule, exdates: src.exdates, status: 'draft', excerpt: src.excerpt, bodyJson: src.bodyJson, bodyHtml: src.bodyHtml,
+    cover: src.cover, coverAlt: src.coverAlt, location: src.location, cta: src.cta, calendarIds: src.calendarIds, fields: src.fields,
+    tags: src.tags, rsvp: src.rsvp, template: src.template,
+  });
+}

package/src/lib/content-service.ts

@@ -0,0 +1,203 @@
+import type { ContentRepository } from './repo/types';
+import type { CalEvent, Page, Post, WidgetInstance } from './schema';
+import { slugify } from './schema';
+import { ApiError } from './api';
+import { CONTENT, collectionUrl } from './content';
+import { CALENDAR } from './calendar/config';
+import { isValidTimeZone, normalizeEventTimes } from './calendar/events';
+import { eventChanged } from './calendar/hooks';
+import { normalizePageLocale } from './i18n';
+import { siteOrigin } from './seo';
+import { waitUntilFrom } from './webhooks';
+
+// Saving posts, pages and events: the one implementation behind the admin
+// editor (astro:actions) and the editor-app API (/api/v1/admin/documents).
+// A live (published/scheduled) document never takes content edits directly:
+// they stage into its pending draft until Update. Status transitions stay
+// deliberate, immediate writes. Errors are ApiErrors; the actions translate
+// them to ActionErrors with the same messages.
+
+export interface SaveHooks {
+  /** the request URL (origin fallback for event side effects) */
+  url: URL;
+  locals?: unknown;
+  /** new redirects must fire at once in this isolate */
+  onRedirect?: () => void;
+}
+
+export type PostSave = Parameters<ContentRepository['updatePost']>[1];
+export type PageSave = Omit<Parameters<ContentRepository['updatePage']>[1], 'blocks'>;
+export type EventSave = Partial<Omit<CalEvent, 'id' | 'draft' | 'startAt' | 'endAt' | 'createdAt' | 'updatedAt' | 'sourceUid' | 'publishedAt'>>;
+
+const live = (status: string) => status === 'published' || status === 'scheduled';
+
+export async function savePost(repo: ContentRepository, id: string, input: PostSave, hooks: SaveHooks): Promise<Post> {
+  const data = { ...input };
+  if (data.slug !== undefined) data.slug = slugify(data.slug);
+  if (data.collection !== undefined && !CONTENT.collections[data.collection]) throw new ApiError(400, `Unknown collection "${data.collection}".`);
+  const before = await repo.getPost(id);
+  if (!before) throw new ApiError(404, 'Post not found.');
+  const transitions = data.status !== undefined && data.status !== before.status;
+  if (live(before.status) && !transitions) {
+    const { status: _status, scheduledAt: _scheduledAt, authorId: _authorId, ...staged } = data;
+    await repo.savePostDraft(id, staged);
+    return (await repo.getPost(id))!;
+  }
+  await repo.updatePost(id, data);
+  // any new tag names become registry entries with slugs for archives
+  if (data.tags !== undefined) await repo.ensureTags(data.tags);
+  const post = await repo.getPost(id);
+  if (!post) throw new ApiError(404, 'Post not found.');
+  // a published post whose slug or collection changed leaves a 301 behind
+  if (before.status === 'published' && (before.slug !== post.slug || before.collection !== post.collection)) {
+    await repo.createRedirect({ fromPath: collectionUrl(before.collection, before.slug), toPath: collectionUrl(post.collection, post.slug) }).catch(() => {});
+    hooks.onRedirect?.();
+  }
+  return post;
+}
+
+/** Update: the pending draft goes live (tag registry, slug-change 301 happen now) */
+export async function applyPostUpdate(repo: ContentRepository, id: string, hooks: SaveHooks): Promise<Post> {
+  const before = await repo.getPost(id);
+  if (!before) throw new ApiError(404, 'Post not found.');
+  await repo.applyPostDraft(id);
+  const post = (await repo.getPost(id))!;
+  if (post.tags.length) await repo.ensureTags(post.tags);
+  if (before.status === 'published' && (before.slug !== post.slug || before.collection !== post.collection)) {
+    await repo.createRedirect({ fromPath: collectionUrl(before.collection, before.slug), toPath: collectionUrl(post.collection, post.slug) }).catch(() => {});
+    hooks.onRedirect?.();
+  }
+  return post;
+}
+
+export async function savePage(repo: ContentRepository, id: string, input: PageSave, blocks: WidgetInstance[] | undefined, hooks: SaveHooks): Promise<Page> {
+  const data = { ...input };
+  if (data.slug !== undefined) data.slug = slugify(data.slug);
+  // default locale stores as '', unknown codes fall back to it
+  if (data.locale !== undefined) data.locale = normalizePageLocale(data.locale);
+  const before = await repo.getPage(id);
+  if (!before) throw new ApiError(404, 'Page not found.');
+  const transitions = data.status !== undefined && data.status !== before.status;
+  if (live(before.status) && !transitions) {
+    const { status: _status, ...staged } = data;
+    await repo.savePageDraft(id, { ...staged, blocks });
+    return (await repo.getPage(id))!;
+  }
+  await repo.updatePage(id, { ...data, blocks });
+  const page = await repo.getPage(id);
+  if (!page) throw new ApiError(404, 'Page not found.');
+  if (before.status === 'published' && before.slug !== page.slug && !page.isHome) {
+    await repo.createRedirect({ fromPath: `/${before.slug}`, toPath: `/${page.slug}` }).catch(() => {});
+    hooks.onRedirect?.();
+  }
+  return page;
+}
+
+export async function applyPageUpdate(repo: ContentRepository, id: string, hooks: SaveHooks): Promise<Page> {
+  const before = await repo.getPage(id);
+  if (!before) throw new ApiError(404, 'Page not found.');
+  await repo.applyPageDraft(id);
+  const page = (await repo.getPage(id))!;
+  if (before.status === 'published' && before.slug !== page.slug && !page.isHome) {
+    await repo.createRedirect({ fromPath: `/${before.slug}`, toPath: `/${page.slug}` }).catch(() => {});
+    hooks.onRedirect?.();
+  }
+  return page;
+}
+
+// Validate + normalize an event save. Times are checked as a PAIR against the
+// merged (staged) state so a half-edited range can't slip through.
+export async function cleanEventInput(repo: ContentRepository, data: EventSave, before: CalEvent): Promise<EventSave> {
+  const out: EventSave = { ...data };
+  if (out.slug !== undefined) {
+    const base = slugify(out.slug || out.title || before.title);
+    let slug = base;
+    for (let n = 2; ; n++) {
+      const clash = await repo.getEventBySlug(slug);
+      if (!clash || clash.id === before.id) break;
+      slug = `${base}-${n}`;
+    }
+    out.slug = slug;
+  }
+  if (out.timezone !== undefined && out.timezone !== '' && !isValidTimeZone(out.timezone)) {
+    throw new ApiError(400, `“${out.timezone}” isn’t a timezone we recognize.`);
+  }
+  if (out.start !== undefined || out.end !== undefined || out.allDay !== undefined) {
+    const merged = before.draft ? { ...before, ...(before.draft as Partial<CalEvent>) } : before;
+    try {
+      const t = normalizeEventTimes({ start: out.start ?? merged.start, end: out.end ?? merged.end, allDay: out.allDay ?? merged.allDay });
+      out.start = t.start;
+      out.end = t.end;
+    } catch (err) {
+      throw new ApiError(400, err instanceof Error ? err.message : 'Invalid time.');
+    }
+  }
+  if (out.roomHold !== undefined) {
+    // only rooms/people that exist; order kept, duplicates dropped
+    const known = new Set((await repo.listResources()).map((r) => r.id));
+    out.roomHold = { ...out.roomHold, resourceIds: [...new Set(out.roomHold.resourceIds.filter((id) => known.has(id)))] };
+  }
+  if (out.calendarIds !== undefined) {
+    const known = new Set((await repo.listCalendars()).filter((c) => c.kind === 'native').map((c) => c.id));
+    out.calendarIds = [...new Set(out.calendarIds.filter((c) => known.has(c)))];
+  }
+  if (out.fields !== undefined) {
+    const allowed = new Map(CALENDAR.eventFields.map((f) => [f.key, f]));
+    out.fields = Object.fromEntries(
+      Object.entries(out.fields)
+        .filter(([k, v]) => allowed.has(k) && v !== '')
+        .filter(([k, v]) => allowed.get(k)!.type !== 'select' || allowed.get(k)!.options.includes(v))
+    );
+  }
+  if (out.cta !== undefined) {
+    const href = out.cta.href.trim();
+    if (href && !/^(https?:\/\/|\/(?!\/)|mailto:|tel:|#)/i.test(href)) {
+      throw new ApiError(400, 'The button link must start with https://, /, mailto:, or tel:.');
+    }
+    out.cta = { ...out.cta, href };
+  }
+  if (out.location?.url) {
+    if (!/^https?:\/\//i.test(out.location.url.trim())) throw new ApiError(400, 'The map or meeting link must start with https://.');
+  }
+  if (out.tags !== undefined) out.tags = [...new Set(out.tags.map((t) => t.trim()).filter(Boolean))];
+  if (out.status === 'scheduled' && !(out.scheduledAt && out.scheduledAt > Date.now())) {
+    throw new ApiError(400, 'Pick a future publish time to schedule.');
+  }
+  if (out.status === 'published') out.scheduledAt = null;
+  return out;
+}
+
+async function eventSideEffects(repo: ContentRepository, hooks: SaveHooks, before: CalEvent, after: CalEvent, applied = false) {
+  const settings = await repo.getSettings();
+  await eventChanged(repo, before, after, {
+    origin: siteOrigin(settings, hooks.url), waitUntil: waitUntilFrom(hooks.locals), applied, onRedirect: hooks.onRedirect,
+  });
+}
+
+export async function saveEvent(repo: ContentRepository, id: string, data: EventSave, hooks: SaveHooks): Promise<CalEvent> {
+  const before = await repo.getEvent(id);
+  if (!before) throw new ApiError(404, 'Event not found.');
+  const clean = await cleanEventInput(repo, data, before);
+  // live events stage edits until Update, exactly like posts
+  const transitions = clean.status !== undefined && clean.status !== before.status;
+  if (live(before.status) && !transitions) {
+    const { status: _s, scheduledAt: _sa, ...staged } = clean;
+    await repo.saveEventDraft(id, staged);
+    return (await repo.getEvent(id))!;
+  }
+  await repo.updateEvent(id, clean);
+  if (clean.tags !== undefined) await repo.ensureTags(clean.tags);
+  const event = (await repo.getEvent(id))!;
+  await eventSideEffects(repo, hooks, before, event);
+  return event;
+}
+
+export async function applyEventUpdate(repo: ContentRepository, id: string, hooks: SaveHooks): Promise<CalEvent> {
+  const before = await repo.getEvent(id);
+  if (!before) throw new ApiError(404, 'Event not found.');
+  await repo.applyEventDraft(id);
+  const event = (await repo.getEvent(id))!;
+  if (event.tags.length) await repo.ensureTags(event.tags);
+  await eventSideEffects(repo, hooks, before, event, true);
+  return event;
+}

package/src/lib/design-service.ts

@@ -1,10 +1,16 @@
 import { z } from 'zod';
 import { SectionPages, sectionIssues } from '../theme-sdk/contract.mjs';
-import { ApiError, requireSession } from './api';
+import { migrateSection } from './sections';
+import type { Theme } from './theme';
+import { ApiError, sessionRole } from './api';
 import { hashAgentKey } from './ai-config';
 import { pickDesignDraft } from './drafts';
 import type { ContentRepository } from './repo/types';
 import type { Settings, ApiScope } from './schema';
+import { diffDesign, summarizeChanges } from './designDiff';
+import { shareEpoch } from './drafts';
+import { createDesignToken } from './preview';
+import { ThemeTokens } from '../theme-sdk/contract.mjs';
 
 export const DESIGN_SCOPES = ['design:read', 'design:write-draft', 'design:publish', 'media:read', 'media:write'] as const;
 export const DesignPatch = z.object({
@@ -20,6 +26,8 @@ export const DesignRequest = z.discriminatedUnion('operation', [
   z.object({ operation:z.literal('restore'),revision:z.number().int().nonnegative(),id:z.string().max(100) }).strict(),
   z.object({ operation:z.literal('share'),revision:z.number().int().nonnegative(),days:z.number().int().min(1).max(30).default(7) }).strict(),
   z.object({ operation:z.literal('revoke'),revision:z.number().int().nonnegative() }).strict(),
+  z.object({ operation:z.literal('migrate'),revision:z.number().int().nonnegative() }).strict(),
+  z.object({ operation:z.literal('publishSection'),revision:z.number().int().nonnegative(),pageId:z.string().min(1).max(100),sectionId:z.string().min(1).max(100) }).strict(),
 ]);
 export async function designIdentity(request: Request, cookies: {get(name:string):{value:string}|undefined}, repo:ContentRepository, scope:ApiScope | readonly ApiScope[]) {
   if (request.headers.has('authorization')) {
@@ -33,16 +41,49 @@ export async function designIdentity(request: Request, cookies: {get(name:string
     if (!required.some(s=>key.scopes.includes(s))) throw new ApiError(403,`Required scope: ${required.join(' or ')}`);
     return { actor:`key:${key.id}`,scopes:key.scopes };
   }
-  await requireSession(request,cookies,repo,true);
-  return {actor:'owner',scopes:[...DESIGN_SCOPES]};
+  // editors may edit section content (never layout, theme or locked fields)
+  const who=await sessionRole(request,cookies,repo);
+  if(who.role!=='owner')return {actor:`editor:${who.id}`,role:'editor' as const,scopes:['design:read','design:write-draft','design:publish']};
+  return {actor:'owner',role:'owner' as const,scopes:[...DESIGN_SCOPES]};
 }
 export function publicDesign(settings:Settings) { return {...pickDesignDraft(settings), sectionPages:settings.sectionPages}; }
-export function validateSectionDesign(settings:Settings, theme:{sections:Parameters<typeof sectionIssues>[1]}) {
+export function validateSectionDesign(settings:Settings, theme:Pick<Theme,'sections'|'migrations'>) {
+  // a section with a theme migration renders upgraded, so validate it upgraded
   const issues=Object.entries(settings.sectionPages).flatMap(([pageId,layout]) => layout.mode === 'sections'
-    ? sectionIssues({...layout,sections:layout.sections.filter(s=>!s.hidden)},theme.sections).map(issue=>({pageId,...issue})) : []);
+    ? sectionIssues({...layout,sections:layout.sections.filter(s=>!s.hidden).map(s=>migrateSection(theme,s))},theme.sections).map(issue=>({pageId,...issue})) : []);
   if (issues.length) throw new ApiError(409,`Resolve section compatibility before publishing: ${issues.slice(0,5).map(i=>i.message).join('; ')}`);
 }
 
+type Pages = z.infer<typeof SectionPages>;
+/** persist theme migrations: every instance older than its definition is upgraded */
+export function migrateLayouts(pages: Pages, theme: Pick<Theme,'sections'|'migrations'>): { pages: Pages; upgraded: number } {
+  let upgraded = 0;
+  const out = Object.fromEntries(Object.entries(pages).map(([id, layout]) => [id, { ...layout, sections: layout.sections.map((s) => {
+    const next = migrateSection(theme, s);
+    if (next !== s) upgraded++;
+    return next;
+  }) }]));
+  return { pages: out, upgraded };
+}
+
+/**
+ * "Publish just this section": the live layout takes the staged copy of one
+ * section; everything else stays staged. Returns the next live + draft maps.
+ */
+export function publishOneSection(live: Pages, staged: Pages, pageId: string, sectionId: string): { live: Pages; staged: Pages | null } {
+  const draftLayout = staged[pageId];
+  const section = draftLayout?.sections.find((s) => s.id === sectionId);
+  if (!section) throw new ApiError(404, 'That section is not in the draft. Save it first.');
+  const liveLayout = live[pageId];
+  if (!liveLayout || liveLayout.mode !== 'sections' || !liveLayout.sections.some((s) => s.id === sectionId)) {
+    throw new ApiError(409, 'This section is new on the page. Publish the whole design to add it.');
+  }
+  const nextLive: Pages = { ...live, [pageId]: { ...liveLayout, sections: liveLayout.sections.map((s) => (s.id === sectionId ? structuredClone(section) : s)) } };
+  // nothing left to stage for sections once draft and live agree
+  const same = JSON.stringify(nextLive) === JSON.stringify(staged);
+  return { live: nextLive, staged: same ? null : staged };
+}
+
 export function validateDesignValues(patch: z.infer<typeof DesignPatch>) {
   const allowed = new Set(['bg','ink','muted','line','accent','panel','soft','width','wideWidth','button','scheme','radius','elevation','density','header','footer','blogLayout','fontPairing','homeMode','darkBg','darkInk','darkMuted','darkLine','darkAccent','darkPanel','darkSoft','postCover','postDate','postReadingTime','postByline','postAuthorCard','postShare','postRelated','postProgress','postToc']);
   for (const [key,value] of Object.entries(patch.designOverrides ?? {})) {
@@ -56,3 +97,110 @@ export function validateDesignValues(patch: z.infer<typeof DesignPatch>) {
     if(value && !/^(https?:\/\/|mailto:|tel:|\/(?!\/)|#)/i.test(value.trim())) throw new ApiError(400,'Use an HTTP(S) or site-relative URL.');
   }
 }
+
+type Layout = Pages[string];
+type Inst = Layout['sections'][number];
+const same = (a: unknown, b: unknown) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+/**
+ * Editors change content only: every page keeps its sections, order, type,
+ * style, visibility, schedule and lock, and nothing locked (a locked section,
+ * or a field marked `locked` in the theme) changes. Throws 403 otherwise.
+ */
+export function assertContentOnly(before: Pages, after: Pages, defs: Pick<Theme, 'sections'>['sections']) {
+  const deny = (why: string) => { throw new ApiError(403, `Only an owner can ${why}.`); };
+  const ids = (p: Pages) => Object.keys(p).filter((k) => p[k]).sort();
+  if (!same(ids(before), ids(after))) deny('add or remove page layouts');
+  for (const pageId of Object.keys(after)) {
+    const a: Layout = before[pageId], b: Layout = after[pageId];
+    if (a.mode !== b.mode) deny('switch a page between sections and page content');
+    if (!same(a.sections.map((s) => s.id), b.sections.map((s) => s.id))) deny('add, remove or reorder sections');
+    b.sections.forEach((s: Inst, i: number) => {
+      const o: Inst = a.sections[i];
+      for (const k of ['type', 'version', 'variant', 'hidden', 'showFrom', 'showUntil', 'locked'] as const) {
+        if (!same(o[k], s[k])) deny(k === 'variant' ? 'change a section’s style' : k === 'hidden' ? 'hide or show sections' : k.startsWith('show') ? 'schedule sections' : k === 'locked' ? 'lock or unlock sections' : 'change a section’s type');
+      }
+      if (o.locked && (!same(o.data, s.data) || !same(o.translations, s.translations))) deny(`edit the locked “${defs[s.type]?.name ?? s.type}” section`);
+      const def = defs[s.type];
+      const keys = new Set([...Object.keys(o.data), ...Object.keys(s.data)]);
+      for (const key of keys) {
+        // a focal point belongs to its image field (same lock)
+        const owner = key.endsWith('__focus') && def?.fields[key.slice(0, -7)] ? key.slice(0, -7) : key;
+        const f = def?.fields[owner] as { locked?: boolean; type?: string; fields?: Record<string, { locked?: boolean }> } | undefined;
+        if (!f) { if (!same(o.data[key], s.data[key])) deny('change saved values the theme no longer uses'); continue; }
+        if (f.locked && !same(o.data[key], s.data[key])) deny(`change the locked “${(f as { label?: string }).label ?? key}” field`);
+        if (f.type === 'list' && f.fields) {
+          const lockedSubs = Object.entries(f.fields).filter(([, sf]) => sf.locked).map(([k]) => k);
+          if (lockedSubs.length) {
+            const rowsA = (o.data[key] ?? []) as Record<string, unknown>[], rowsB = (s.data[key] ?? []) as Record<string, unknown>[];
+            if (rowsA.length !== rowsB.length || rowsB.some((r, j) => lockedSubs.some((k) => !same(r?.[k], rowsA[j]?.[k])))) deny('change locked list fields');
+          }
+        }
+      }
+    });
+  }
+}
+
+/**
+ * One design operation (stage, publish, publishSection, …) with the role
+ * rules shared by the Design screen, scoped keys and editor apps: editors
+ * only stage section content (assertContentOnly) and publish single
+ * sections; everything else is owner/key work. Revision mismatches are 409.
+ */
+export async function runDesignOperation(repo: ContentRepository, identity: { actor: string; role?: 'owner' | 'editor' }, input: z.infer<typeof DesignRequest>, origin: string): Promise<{ ok: true; revision: number } | { url: string; expiresAt: number; revision: number }> {
+    // lazy: the theme registry pulls in Astro templates, which callers that only need the schemas shouldn't load
+    const { getTheme, listThemes } = await import('./theme');
+    const current=await repo.getSettings();
+    if(current.designRevision!==input.revision)throw new ApiError(409,'Design changed. Pull the latest revision before saving.');
+    if(identity.role==='editor'){
+      if(input.operation!=='stage'&&input.operation!=='publishSection')throw new ApiError(403,'Only an owner can do that. Editors change section content and publish single sections.');
+      if(input.operation==='stage'){
+        if(Object.keys(input.patch).some(k=>k!=='sectionPages')||!input.patch.sectionPages)throw new ApiError(403,'Editors can only change section content.');
+        const theme=getTheme(String(current.draftDesign?.activeTheme??current.activeTheme));
+        assertContentOnly((current.draftDesign?.sectionPages??current.sectionPages) as typeof current.sectionPages,input.patch.sectionPages as typeof current.sectionPages,theme.sections);
+      }
+    }
+    if(input.operation==='stage') {
+      validateDesignValues(input.patch);
+      const draft={...current.draftDesign,...input.patch};
+      if(input.patch.activeTheme && !listThemes().some(t=>t.slug===input.patch.activeTheme))throw new ApiError(400,'Theme is not installed. Install locally, build and deploy its code first.');
+      const theme=getTheme(String(draft.activeTheme??current.activeTheme));
+      ThemeTokens.parse({...theme.tokens,...draft.designOverrides as object});
+      const pageIds=new Set((await repo.listPages()).map(p=>p.id));
+      if(input.patch.sectionPages && Object.keys(input.patch.sectionPages).some(id=>!pageIds.has(id)))throw new ApiError(400,'A section layout refers to a missing page.');
+      await repo.setDesignDraft(draft,input.revision,identity.actor);
+    } else if(input.operation==='publish') {
+      const settings={...current,...pickDesignDraft(current.draftDesign??{})};
+      validateSectionDesign(settings,getTheme(settings.activeTheme));
+      await repo.applyDesignDraft({expectedRevision:input.revision,author:identity.actor,summary:summarizeChanges(diffDesign(current,await repo.listNavItems(),current.draftDesign))});
+    } else if(input.operation==='publishSection') {
+      const staged=(current.draftDesign?.sectionPages ?? current.sectionPages) as typeof current.sectionPages;
+      if(identity.role==='editor'){
+        const a=current.sectionPages[input.pageId]?.sections.find(s=>s.id===input.sectionId),b=staged[input.pageId]?.sections.find(s=>s.id===input.sectionId);
+        if(a&&b&&(['type','variant','hidden','showFrom','showUntil','locked'] as const).some(k=>JSON.stringify(a[k]??null)!==JSON.stringify(b[k]??null)))
+          throw new ApiError(403,'This section has style or visibility changes from an owner. Ask an owner to publish it.');
+      }
+      const next=publishOneSection(current.sectionPages,staged,input.pageId,input.sectionId);
+      validateSectionDesign({...current,sectionPages:next.live},getTheme(current.activeTheme));
+      const name=next.live[input.pageId].sections.find(s=>s.id===input.sectionId)?.type ?? 'section';
+      await repo.publishSectionPages(next.live,next.staged,{expectedRevision:input.revision,author:identity.actor,summary:`Section: ${name}`});
+    } else if(input.operation==='migrate') {
+      const theme=getTheme(String(current.draftDesign?.activeTheme ?? current.activeTheme));
+      const {pages,upgraded}=migrateLayouts((current.draftDesign?.sectionPages ?? current.sectionPages) as typeof current.sectionPages,theme);
+      if(!upgraded)throw new ApiError(409,'No sections need upgrading.');
+      await repo.setDesignDraft({...current.draftDesign,sectionPages:pages},input.revision,identity.actor);
+    } else if(input.operation==='discard') await repo.setDesignDraft(null,input.revision,identity.actor);
+    else if(input.operation==='restore') {
+      const version=await repo.getDesignVersion(input.id);if(!version)throw new ApiError(404,'Version not found.');
+      await repo.setDesignDraft({...version.snapshot,shareEpoch:crypto.randomUUID()},input.revision,identity.actor);
+    } else {
+      if(!current.draftDesign)throw new ApiError(409,'There is no draft to share.');
+      if(input.operation==='revoke')await repo.setDesignDraft({...current.draftDesign,shareEpoch:crypto.randomUUID()},input.revision,identity.actor);
+      else {
+        if(shareEpoch(current.draftDesign)==='legacy-disabled')throw new ApiError(409,'Save the draft before sharing.');
+        const {token,expiresAt}=createDesignToken(shareEpoch(current.draftDesign),input.days*86400000);
+        return {url:`${origin}/?preview=${token}`,expiresAt,revision:input.revision};
+      }
+    }
+    // Write-only credentials receive no private content inventory.
+    return {ok:true as const,revision:(await repo.getSettings()).designRevision};
+}

package/src/lib/drafts.ts

@@ -12,12 +12,12 @@ import type { CalEvent, NavItem, Page, Post, Settings } from './schema';
 export const POST_DRAFT_KEYS = [
   'title', 'slug', 'collection', 'body', 'bodyJson', 'bodyHtml', 'excerpt',
   'tags', 'cover', 'coverAlt', 'seoTitle', 'seoDesc', 'featured',
-  'authorIds', 'template', 'publishedAt',
+  'authorIds', 'template', 'publishedAt', 'translations',
 ] as const;
 
 export const PAGE_DRAFT_KEYS = [
   'title', 'slug', 'locale', 'isHome', 'seoTitle', 'seoDesc', 'template',
-  'bodyJson', 'bodyHtml', 'blocks',
+  'bodyJson', 'bodyHtml', 'blocks', 'translations',
 ] as const;
 
 // events stage everything the editor can change, times and recurrence
@@ -25,7 +25,7 @@ export const PAGE_DRAFT_KEYS = [
 export const EVENT_DRAFT_KEYS = [
   'title', 'slug', 'bodyJson', 'bodyHtml', 'excerpt', 'tags', 'cover', 'coverAlt',
   'seoTitle', 'seoDesc', 'featured', 'template', 'start', 'end', 'allDay',
-  'timezone', 'rrule', 'exdates', 'cancelled', 'location', 'cta', 'calendarIds', 'fields', 'rsvp',
+  'timezone', 'rrule', 'exdates', 'cancelled', 'location', 'cta', 'calendarIds', 'fields', 'rsvp', 'translations', 'roomHold',
 ] as const;
 
 type PostDraftKey = (typeof POST_DRAFT_KEYS)[number];