@acms-subir/core 0.3.0 → 0.3.1

package/src/lib/live/signals.ts

@@ -0,0 +1,89 @@
+import { subscribeLive } from './client';
+import type { PublicLiveSnapshot } from './types';
+
+// Site-wide live signals (Site.astro renders them hidden when the owner
+// enables them): the live bar, the header marker and the floating dock. All
+// three appear only while a broadcast is actually live, and dismissals last
+// for that broadcast in this browser session.
+
+const dismissKey = (what: string, s: PublicLiveSnapshot) => `acms-live-${what}-${s.provider}-${s.id || s.watchUrl}`;
+const dismissed = (what: string, s: PublicLiveSnapshot) => {
+  try { return sessionStorage.getItem(dismissKey(what, s)) === '1'; } catch { return false; }
+};
+const dismiss = (what: string, s: PublicLiveSnapshot) => {
+  try { sessionStorage.setItem(dismissKey(what, s), '1'); } catch { /* private mode: dismiss for this page only */ }
+};
+
+// a live card already on the page makes the dock redundant and gives the
+// header marker a local target
+function pageCard(): HTMLElement | null {
+  const card = Array.from(document.querySelectorAll<HTMLElement>('[data-live-card]')).find((c) => !c.hidden && c.dataset.status === 'live');
+  if (card && !card.id) card.id = 'live-video';
+  return card ?? null;
+}
+
+function openExternally(a: HTMLAnchorElement, url: string) {
+  a.href = url;
+  a.target = '_blank';
+  a.rel = 'noopener noreferrer';
+}
+
+export function mountLiveSignals() {
+  const bar = document.querySelector<HTMLElement>('[data-live-bar]:not([data-ready])');
+  const marker = document.querySelector<HTMLAnchorElement>('[data-live-header]:not([data-ready])');
+  const dock = document.querySelector<HTMLElement>('[data-live-dock]:not([data-ready])');
+  let current: PublicLiveSnapshot | null = null;
+
+  if (bar) {
+    bar.dataset.ready = '';
+    bar.querySelector('.pc-live-x')?.addEventListener('click', () => {
+      if (current) dismiss('bar', current);
+      bar.hidden = true;
+      delete document.documentElement.dataset.liveBar;
+    });
+    subscribeLive(bar, (s) => {
+      current = s;
+      const show = s?.status === 'live' && !dismissed('bar', s);
+      bar.hidden = !show;
+      if (show) document.documentElement.dataset.liveBar = '';
+      else delete document.documentElement.dataset.liveBar;
+      if (!s || !show) return;
+      bar.querySelector('[data-live-bar-title]')!.textContent = s.title;
+      const card = pageCard();
+      const a = bar.querySelector<HTMLAnchorElement>('[data-live-bar-watch]')!;
+      if (card) { a.href = `#${card.id}`; a.removeAttribute('target'); } else openExternally(a, s.watchUrl);
+    });
+  }
+
+  if (marker) {
+    marker.dataset.ready = '';
+    subscribeLive(marker, (s) => {
+      marker.hidden = s?.status !== 'live';
+      if (!s || marker.hidden) return;
+      const card = pageCard();
+      marker.title = s.title;
+      if (card) { marker.href = `#${card.id}`; marker.removeAttribute('target'); } else openExternally(marker, s.watchUrl);
+    });
+  }
+
+  if (dock) {
+    dock.dataset.ready = '';
+    const link = dock.querySelector<HTMLAnchorElement>('a')!;
+    const img = dock.querySelector<HTMLImageElement>('img')!;
+    img.addEventListener('load', () => { img.hidden = false; });
+    img.addEventListener('error', () => { img.hidden = true; });
+    dock.querySelector('.pc-live-x')?.addEventListener('click', () => {
+      if (current) dismiss('dock', current);
+      dock.hidden = true;
+    });
+    subscribeLive(dock, (s) => {
+      current = s;
+      dock.hidden = s?.status !== 'live' || dismissed('dock', s) || !!pageCard();
+      if (!s || dock.hidden) return;
+      openExternally(link, s.watchUrl);
+      dock.querySelector('[data-live-dock-title]')!.textContent = s.title;
+      if (!s.thumbUrl) { img.hidden = true; img.removeAttribute('src'); }
+      else if (img.getAttribute('src') !== s.thumbUrl) img.src = s.thumbUrl;
+    });
+  }
+}

package/src/lib/live/store.ts

@@ -0,0 +1,49 @@
+import { randomInt } from 'node:crypto';
+import type { SqlDriver } from '../repo/sql';
+import type { Connection, Provider, LiveSnapshot, Channel } from './types';
+const parse = <T>(raw: unknown, fallback: T): T => { try { return raw ? JSON.parse(String(raw)) : fallback; } catch { return fallback; } };
+function connection(r: Record<string, unknown>): Connection {
+  return { provider: r.provider as Provider, clientId: String(r.client_id), channelInput: String(r.channel_input), channelId: String(r.channel_id), channelName: String(r.channel_name), encrypted: String(r.encrypted), enabled: !!r.enabled, revision: Number(r.revision), channels: parse<Channel[]>(r.channels, []), googleStatus: r.google_status as Connection['googleStatus'], testedAt: Number(r.tested_at), checkedAt: Number(r.checked_at), lastAttemptAt: Number(r.last_attempt_at), nextAt: Number(r.next_at), failures: Number(r.failures), error: String(r.error), lease: String(r.lease), leaseUntil: Number(r.lease_until), snapshot: parse<LiveSnapshot | null>(r.snapshot, null), upcoming: parse<LiveSnapshot | null>(r.upcoming, null), upcomingCheckedAt: Number(r.upcoming_checked_at) };
+}
+const columns: Record<string, string> = { clientId:'client_id', channelInput:'channel_input', channelId:'channel_id', channelName:'channel_name', encrypted:'encrypted', enabled:'enabled', channels:'channels', googleStatus:'google_status', testedAt:'tested_at', checkedAt:'checked_at', lastAttemptAt:'last_attempt_at', nextAt:'next_at', failures:'failures', error:'error', snapshot:'snapshot', upcoming:'upcoming', upcomingCheckedAt:'upcoming_checked_at' };
+const serialized = new Set(['channels','snapshot','upcoming']);
+export class LiveStore {
+  constructor(private driver: () => Promise<SqlDriver>) {}
+  async list() { return (await (await this.driver()).all('SELECT * FROM live_connections ORDER BY provider')).map(connection); }
+  async get(provider: Provider) { return (await this.list()).find(c => c.provider === provider) ?? null; }
+  // Revisions invalidate in-flight provider requests and OAuth callbacks when a setting changes.
+  async save(provider: Provider, data: { clientId: string; channelInput: string; encrypted: string; googleStatus: string }) {
+    // A recreated connection must not reuse the revision of an in-flight OAuth callback.
+    const revision = randomInt(1, 2 ** 48 - 1);
+    await (await this.driver()).run(`INSERT INTO live_connections (provider,client_id,channel_input,encrypted,google_status,revision) VALUES (?,?,?,?,?,?)
+      ON CONFLICT(provider) DO UPDATE SET client_id=excluded.client_id,channel_input=excluded.channel_input,encrypted=excluded.encrypted,google_status=excluded.google_status,
+      enabled=0,tested_at=0,revision=revision+1,lease='',lease_until=0,snapshot=NULL,upcoming=NULL,upcoming_checked_at=0,error='',failures=0,next_at=0`, [provider,data.clientId,data.channelInput,data.encrypted,data.googleStatus,revision]);
+  }
+  async patch(provider: Provider, data: Partial<Connection>, revision: number, lease?: string): Promise<boolean> {
+    const entries = Object.entries(data).filter(([k]) => columns[k]);
+    if (!entries.length) return false;
+    const args = entries.map(([k,v]) => serialized.has(k) ? v == null ? null : JSON.stringify(v) : typeof v === 'boolean' ? Number(v) : v);
+    const rows = await (await this.driver()).all(`UPDATE live_connections SET ${entries.map(([k]) => `${columns[k]}=?`).join(',')},
+      ${lease ? "lease='',lease_until=0" : "revision=revision+1,lease='',lease_until=0"}
+      WHERE provider=? AND revision=?${lease ? ' AND lease=?' : ''} RETURNING provider`, [...args,provider,revision,...(lease ? [lease] : [])]);
+    return rows.length > 0;
+  }
+  async claim(provider: Provider, now: number, force = false) {
+    const lease = crypto.randomUUID();
+    const rows = await (await this.driver()).all(`UPDATE live_connections SET lease=?,lease_until=?,last_attempt_at=?
+      WHERE provider=? AND lease_until<=? AND ${force ? '(last_attempt_at=0 OR last_attempt_at<=?)' : 'enabled=1 AND next_at<=?'} RETURNING *`, [lease,now+90_000,now,provider,now,force ? now-10_000 : now]);
+    return rows[0] ? connection(rows[0]) : null;
+  }
+  async remove(provider: Provider) {
+    await (await this.driver()).batch([{sql:'DELETE FROM live_connections WHERE provider=?',args:[provider]}, ...(provider === 'youtube' ? [{sql:'DELETE FROM live_oauth_states'}] : [])]);
+  }
+  async state(hash: string, sessionHash: string, revision: number, encrypted: string, expiresAt: number) {
+    await (await this.driver()).batch([{sql:'DELETE FROM live_oauth_states WHERE expires_at<? OR session_hash=?',args:[Date.now(),sessionHash]}, {sql:'INSERT INTO live_oauth_states (hash,session_hash,revision,encrypted,expires_at) VALUES (?,?,?,?,?)',args:[hash,sessionHash,revision,encrypted,expiresAt]}]);
+  }
+  async consumeState(hash: string, sessionHash: string, now: number) {
+    const rows = await (await this.driver()).all('DELETE FROM live_oauth_states WHERE hash=? AND session_hash=? AND expires_at>? RETURNING revision,encrypted', [hash,sessionHash,now]);
+    return rows[0] ? {revision:Number(rows[0].revision),encrypted:String(rows[0].encrypted)} : null;
+  }
+  async heartbeat(now: number) { await (await this.driver()).run('UPDATE live_health SET last_at=? WHERE id=1',[now]); }
+  async lastHeartbeat() { return Number((await (await this.driver()).all('SELECT last_at FROM live_health WHERE id=1'))[0]?.last_at ?? 0); }
+}

package/src/lib/live/types.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export const Provider = z.enum(['youtube', 'twitch']);
+export type Provider = z.infer<typeof Provider>;
+const httpsUrl = z.string().trim().max(2048).refine(v => { if (!v) return true; try { const u = new URL(v); return u.protocol === 'https:' && !u.username && !u.password; } catch { return false; } }, 'Use an HTTPS URL without credentials.');
+export const LiveConfig = z.object({
+  mode: z.enum(['off', 'automatic', 'manual']).default('off'),
+  priority: z.array(Provider).max(2).default(['youtube', 'twitch']).refine(v => new Set(v).size === v.length, 'Choose each provider only once.'),
+  fallbackUrl: httpsUrl.default(''),
+  showUpcoming: z.boolean().default(false),
+  manual: z.object({ watchUrl: httpsUrl.default(''), title: z.string().trim().max(200).default('We’re live'), until: z.number().int().nonnegative().default(0) }).strict().default({}),
+  // How the public site presents the snapshot. Site-wide signals start off so
+  // an upgrade never changes an existing site without the owner opting in.
+  display: z.object({
+    style: z.enum(['poster', 'split', 'row']).default('poster'),
+    thumbnail: z.boolean().default(true),
+    viewers: z.boolean().default(false),
+    bar: z.boolean().default(false),
+    header: z.boolean().default(false),
+    dock: z.boolean().default(false),
+  }).strict().default({}),
+}).strict();
+export type LiveConfig = z.infer<typeof LiveConfig>;
+export interface LiveSnapshot {
+  status: 'live' | 'offline' | 'upcoming' | 'unknown';
+  source: 'automatic' | 'manual';
+  provider: Provider | 'facebook' | 'other';
+  id: string; title: string; watchUrl: string; embedId: string;
+  startedAt: number; checkedAt: number; expiresAt: number;
+  // optional: snapshots stored before these existed parse unchanged
+  channel?: string; viewers?: number;
+}
+// What visitors receive: viewers only when the owner opts in, and a same-site
+// thumbnail URL (empty when disabled or the provider has no image).
+export interface PublicLiveSnapshot extends Omit<LiveSnapshot, 'viewers'> { viewers?: number; thumbUrl: string }
+export interface Channel { id: string; name: string }
+export interface Credentials { clientSecret: string; accessToken?: string; refreshToken?: string; tokenExpiresAt?: number; tokenValidatedAt?: number; callbackUrl?: string }
+export interface Connection {
+  provider: Provider; clientId: string; channelInput: string; channelId: string; channelName: string;
+  encrypted: string; enabled: boolean; revision: number; channels: Channel[];
+  googleStatus: 'testing' | 'production'; testedAt: number; checkedAt: number; lastAttemptAt: number;
+  nextAt: number; failures: number; error: string; lease: string; leaseUntil: number;
+  snapshot: LiveSnapshot | null; upcoming: LiveSnapshot | null; upcomingCheckedAt: number;
+}
+export interface PublicConnection extends Omit<Connection, 'encrypted' | 'lease' | 'leaseUntil' | 'snapshot' | 'upcoming'> {
+  hasSecret: boolean; authorized: boolean; broadcastStatus: LiveSnapshot['status'];
+}
+export interface LiveAdminState {
+  config: LiveConfig; connections: PublicConnection[]; callbackUrl: string;
+  encryptionReady: boolean; scheduler: { lastAt: number; healthy: boolean };
+  snapshot: LiveSnapshot | null;
+}
+export const emptySnapshot = (provider: Provider, now: number): LiveSnapshot => ({ status: 'offline', source: 'automatic', provider, id: '', title: '', watchUrl: '', embedId: '', startedAt: 0, checkedAt: now, expiresAt: now + 120_000 });

package/src/lib/live/view.ts

@@ -0,0 +1,78 @@
+import type { PublicLiveSnapshot } from './types';
+
+// Display text for a live snapshot. Pure and DOM-free: LiveCard renders it on
+// the server and the browser re-applies it on every status change, so both
+// always agree.
+
+export const PROVIDER_NAMES: Record<string, string> = { youtube: 'YouTube', twitch: 'Twitch', facebook: 'Facebook', other: '' };
+
+export interface LiveView {
+  status: 'live' | 'upcoming' | 'offline';
+  provider: string;
+  // poster tag: "LIVE" or "Sat 7:00 PM · in 2 h"
+  tag: string;
+  // marker line above the title: "LIVE ON TWITCH"
+  kicker: string;
+  title: string;
+  // "heymunmusic · started 42 min ago"
+  meta: string;
+  viewers: string;
+  watchLabel: string;
+  watchUrl: string;
+  thumbUrl: string;
+}
+
+const MIN = 60_000, HOUR = 60 * MIN, DAY = 24 * HOUR;
+
+export function compactCount(n: number): string {
+  if (n < 1000) return String(n);
+  const [v, unit] = n < 1e6 ? [n / 1e3, 'K'] : [n / 1e6, 'M'];
+  return `${v < 10 ? Math.floor(v * 10) / 10 : Math.floor(v)}${unit}`;
+}
+
+export function ago(ms: number): string {
+  if (ms < MIN) return 'just now';
+  if (ms < HOUR) return `${Math.floor(ms / MIN)} min ago`;
+  const h = Math.floor(ms / HOUR), m = Math.floor((ms % HOUR) / MIN);
+  return m ? `${h} h ${m} min ago` : `${h} h ago`;
+}
+
+export function until(ms: number): string {
+  if (ms < MIN) return 'starting now';
+  if (ms < HOUR) return `in ${Math.ceil(ms / MIN)} min`;
+  if (ms < DAY) return `in ${Math.round(ms / HOUR)} h`;
+  const d = Math.round(ms / DAY);
+  return `in ${d} day${d === 1 ? '' : 's'}`;
+}
+
+export function when(ts: number, now: number): string {
+  const d = new Date(ts);
+  const time = d.toLocaleTimeString(undefined, { hour: 'numeric', minute: '2-digit' });
+  if (ts - now < 6 * DAY) return `${d.toLocaleDateString(undefined, { weekday: 'short' })} ${time}`;
+  return `${d.toLocaleDateString(undefined, { month: 'short', day: 'numeric' })} ${time}`;
+}
+
+export function liveView(s: PublicLiveSnapshot | null, now: number): LiveView | null {
+  if (!s || (s.status !== 'live' && s.status !== 'upcoming' && s.status !== 'offline')) return null;
+  const name = PROVIDER_NAMES[s.provider] ?? '';
+  const channel = s.channel?.trim() ?? '';
+  const base = { status: s.status, provider: s.provider, title: s.title, watchUrl: s.watchUrl, thumbUrl: s.thumbUrl };
+  if (s.status === 'offline') {
+    return { ...base, tag: '', kicker: '', meta: channel, viewers: '', thumbUrl: '', watchLabel: 'Watch our channel ↗' };
+  }
+  const watchLabel = name ? `Watch on ${name} ↗` : 'Watch now ↗';
+  if (s.status === 'upcoming') {
+    const start = s.startedAt > 0 ? `${when(s.startedAt, now)} · ${until(s.startedAt - now)}` : '';
+    return {
+      ...base, tag: start || 'UPCOMING', kicker: name ? `UPCOMING ON ${name.toUpperCase()}` : 'UPCOMING',
+      meta: [channel, name && 'scheduled'].filter(Boolean).join(' · '), viewers: '', watchLabel: name ? `Open on ${name} ↗` : 'Open ↗',
+    };
+  }
+  const started = s.startedAt > 0 && s.startedAt <= now ? `started ${ago(now - s.startedAt)}` : '';
+  return {
+    ...base, tag: 'LIVE', kicker: name ? `LIVE ON ${name.toUpperCase()}` : 'LIVE NOW',
+    meta: [channel, started].filter(Boolean).join(' · '),
+    viewers: typeof s.viewers === 'number' ? `${compactCount(s.viewers)} watching` : '',
+    watchLabel,
+  };
+}

package/src/lib/repo/migrations.ts

@@ -1,4 +1,6 @@
+import { LIVE_MIGRATION } from '../live/migration';
 import { EMAIL_MIGRATION } from '../email/migration';
+import { WEBHOOK_MIGRATION } from '../webhook-sql';
 // Versioned schema migrations shared by the two SQLite-dialect adapters
 // (D1 and libSQL). Applied versions are recorded in the `migrations` table;
 // each adapter's runner applies whatever is newer, in order, at startup.
@@ -495,6 +497,8 @@ export const MIGRATIONS: Migration[] = [
       actual_revision INTEGER NOT NULL CHECK (expected_revision = actual_revision)
     )`,
   ] },
+  WEBHOOK_MIGRATION,
+  LIVE_MIGRATION,
 ];
 
 export const LATEST_VERSION = MIGRATIONS[MIGRATIONS.length - 1].version;

package/src/lib/repo/sql.ts

@@ -1,3 +1,5 @@
+import { LiveStore } from '../live/store';
+import { LiveConfig } from '../live/types';
 import { ApiError } from '../api';
 import { EmailStore, bookingJobs } from '../email/store';
 import type { ContentRepository, DesignVersion, EventUpdate, SearchResults, Stats } from './types';
@@ -9,6 +11,7 @@ import { MIGRATIONS, MIGRATIONS_TABLE } from './migrations';
 import { htmlToPlaintext } from '../plaintext';
 import { SEED } from '../brand';
 import { CONTENT, postsIndexUrl } from '../content';
+import { webhookStatement } from '../webhook-sql';
 
 // Shared SQL implementation of ContentRepository. Cloudflare D1 and libSQL
 // are both SQLite, so every statement, mapper and behavior lives here once;
@@ -215,9 +218,11 @@ export class SqlRepository implements ContentRepository {
   private driver!: SqlDriver;
   private ready: Promise<void>;
   readonly email: EmailStore;
+  readonly live: LiveStore;
 
   constructor(driver: SqlDriver | (() => Promise<SqlDriver>)) {
     this.ready = this.init(driver);
+    this.live = new LiveStore(async () => { await this.ready; return this.driver; });
     this.email = new EmailStore(async () => { await this.ready; return this.driver; });
   }
 
@@ -435,6 +440,8 @@ export class SqlRepository implements ContentRepository {
   }
   async updatePage(id: string, data: Parameters<ContentRepository['updatePage']>[1]) {
     await this.ready;
+    if (!(await this.getPage(id))) return;
+    const writes: SqlStatement[] = [];
     // a direct live write supersedes any staged edits (applyPageDraft routes
     // through here too, so applying clears the snapshot in the same UPDATE)
     const sets: string[] = ['updated_at = ?', 'draft = NULL'];
@@ -457,12 +464,13 @@ export class SqlRepository implements ContentRepository {
           data.locale !== undefined
             ? data.locale
             : String((await this.first('SELECT locale FROM pages WHERE id = ?', [id]))?.locale ?? '');
-        await this.driver.run('UPDATE pages SET is_home = 0 WHERE locale = ?', [locale]);
+        writes.push({ sql: 'UPDATE pages SET is_home = 0 WHERE locale = ? AND id != ? AND is_home = 1', args: [locale, id] });
       }
       sets.push('is_home = ?'); args.push(data.isHome ? 1 : 0);
     }
     args.push(id);
-    await this.driver.run(`UPDATE pages SET ${sets.join(', ')} WHERE id = ?`, args);
+    writes.push({ sql: `UPDATE pages SET ${sets.join(', ')} WHERE id = ?`, args });
+    await this.driver.batch(writes);
     await this.syncPageIndex(id);
   }
   // stage edits on a live page: only the `draft` JSON changes — live columns,
@@ -577,8 +585,7 @@ export class SqlRepository implements ContentRepository {
     if (data.featured !== undefined) { sets.push('featured = ?'); args.push(data.featured ? 1 : 0); }
     if (data.template !== undefined) { sets.push('template = ?'); args.push(data.template); }
     // authorIds is the source of truth; author_id mirrors the first entry.
-    // The join rows are written AFTER the main UPDATE succeeds, so a failed
-    // update (e.g. duplicate slug) can't leave the two out of sync.
+    // Main row, join rows and webhook notifications share one transaction.
     let authorJoin: string[] | null = null;
     if (data.authorIds !== undefined) {
       authorJoin = data.authorIds;
@@ -596,16 +603,28 @@ export class SqlRepository implements ContentRepository {
       }
     }
     args.push(id);
-    await this.driver.run(`UPDATE posts SET ${sets.join(', ')} WHERE id = ?`, args);
+    const writes: SqlStatement[] = [{ sql: `UPDATE posts SET ${sets.join(', ')} WHERE id = ?`, args }];
     if (authorJoin !== null) {
-      await this.driver.batch([
+      writes.push(
         { sql: 'DELETE FROM post_authors WHERE post_id = ?', args: [id] },
         ...authorJoin.map((aid, i) => ({
           sql: 'INSERT INTO post_authors (post_id, author_id, ord) VALUES (?, ?, ?)',
           args: [id, aid, i],
         })),
-      ]);
+      );
+      // The main-row trigger detects primary-author changes. Additional
+      // authors live in a join table, so emit once for an authors-only edit.
+      const authorsOnly = current.status === 'published'
+        && (authorJoin[0] ?? null) === current.authorId
+        && JSON.stringify(authorJoin) !== JSON.stringify(current.authorIds)
+        && Object.entries(data).every(([key, value]) => key === 'authorIds' || value === undefined
+          || JSON.stringify(value) === JSON.stringify(current[key as keyof Post]));
+      if (authorsOnly) {
+        const post = { id, slug: current.slug, title: current.title, status: current.status, collection: current.collection };
+        writes.push(webhookStatement('post.updated', { post, previous: post }));
+      }
     }
+    await this.driver.batch(writes);
     await this.syncPostIndex(id);
   }
   // stage edits on a live post: only the `draft` JSON changes — live columns,
@@ -1192,6 +1211,15 @@ export class SqlRepository implements ContentRepository {
     );
     return rows.map(rowToDelivery);
   }
+  async claimDelivery(id: string, now: number) {
+    await this.ready;
+    // A lease outlasts the HTTP timeout. Competing request/cron flushes must
+    // not send the same pending delivery at the same time.
+    const r = await this.first(`UPDATE webhook_deliveries SET next_at = ?
+      WHERE id = ? AND status = 'pending' AND (next_at IS NULL OR next_at <= ?)
+      RETURNING *`, [now + 30_000, id, now]);
+    return r ? rowToDelivery(r) : null;
+  }
   async recordDelivery(id: string, data: Parameters<ContentRepository['recordDelivery']>[1]) {
     await this.ready;
     const r = await this.first('SELECT webhook_id FROM webhook_deliveries WHERE id = ?', [id]);
@@ -1546,6 +1574,9 @@ export class SqlRepository implements ContentRepository {
   async restoreAll(content: Parameters<ContentRepository['restoreAll']>[0]) {
     await this.ready;
     const stmts: SqlStatement[] = [
+      // Suppression and re-enabling share the restore transaction. A failed
+      // restore cannot leave notifications disabled or emit phantom deletes.
+      { sql: 'UPDATE webhook_control SET suppressed=1 WHERE id=1' },
       ...['email_jobs', 'email_attempts', 'email_delivery_events', 'email_tokens', 'posts', 'pages', 'media', 'links', 'tags', 'nav_items', 'users', 'post_authors', 'redirects', 'calendars', 'events', 'resources', 'booking_links', 'bookings', 'mobile_booking_requests'].map((t) => ({
         sql: `DELETE FROM ${t}`,
       })),
@@ -1614,8 +1645,14 @@ export class SqlRepository implements ContentRepository {
         args: [r.id, r.fromPath, r.toPath, r.code, r.createdAt],
       })),
     ];
+    const settingsWrite = this.settingsStatement({ ...content.settings, live: { ...LiveConfig.parse(content.settings.live ?? {}), mode: 'off', manual: { watchUrl: '', title: 'We’re live', until: 0 } } });
+    stmts.push({ sql: "UPDATE live_connections SET enabled=0,tested_at=0,revision=revision+1,lease='',lease_until=0,snapshot=NULL,upcoming=NULL,error='Restored content. Test this connection before enabling automatic checks.'" }, { sql: 'DELETE FROM live_oauth_states' });
+    if (settingsWrite) stmts.push(settingsWrite);
+    stmts.push(
+      { sql: 'UPDATE webhook_control SET suppressed=0 WHERE id=1' },
+      webhookStatement('site.restored', { counts: { posts: content.posts.length, pages: content.pages.length, media: content.media.length } }),
+    );
     await this.driver.batch(stmts);
-    await this.updateSettings(content.settings);
     await this.reindexSearch();
   }
 
@@ -1666,6 +1703,7 @@ export class SqlRepository implements ContentRepository {
       headCode: r?.head_code ?? '', footerCode: r?.footer_code ?? '',
       timezone: r?.timezone ?? '', locale: r?.locale ?? '',
       ai: JSON.parse(String(r?.ai ?? '{}')),
+      live: JSON.parse(String(r?.live ?? '{}')),
       agent: JSON.parse(String(r?.agent ?? '{}')),
       draftsApiKey: r?.drafts_api_key ?? '',
       draftsAllowedOrigins: JSON.parse(String(r?.drafts_allowed_origins ?? '[]')),
@@ -1674,18 +1712,22 @@ export class SqlRepository implements ContentRepository {
   }
   async updateSettings(data: Partial<Settings>) {
     await this.ready;
+    const statement = this.settingsStatement(data);
+    if (statement) await this.driver.run(statement.sql, statement.args);
+  }
+  private settingsStatement(data: Partial<Settings>): SqlStatement | undefined {
     const columns: Record<string, string> = {
       siteTitle:'site_title', tagline:'tagline', footerText:'footer_text', linksName:'links_name', linksBio:'links_bio', linksAvatar:'links_avatar',
       activeTheme:'active_theme', designOverrides:'design_overrides', sectionPages:'section_pages', siteLogo:'site_logo', siteUrl:'site_url', siteFavicon:'site_favicon', siteCover:'site_cover',
       announcement:'announcement', analytics:'analytics', headCode:'head_code', footerCode:'footer_code', timezone:'timezone', locale:'locale',
-      draftsApiKey:'drafts_api_key', draftsAllowedOrigins:'drafts_allowed_origins', draftDesign:'draft_design', ai:'ai', agent:'agent',
+      draftsApiKey:'drafts_api_key', draftsAllowedOrigins:'drafts_allowed_origins', draftDesign:'draft_design', ai:'ai', agent:'agent', live:'live',
     };
-    const jsonKeys = new Set(['designOverrides','sectionPages','announcement','analytics','draftsAllowedOrigins','draftDesign','ai','agent']);
+    const jsonKeys = new Set(['designOverrides','sectionPages','announcement','analytics','draftsAllowedOrigins','draftDesign','ai','agent','live']);
     const entries = Object.entries(data).filter(([k,v]) => columns[k] && v !== undefined);
     if (!entries.length) return;
     const design = entries.some(([k]) => ['activeTheme','designOverrides','sectionPages','siteLogo','siteFavicon','siteCover','draftDesign'].includes(k));
-    await this.driver.run(`UPDATE settings SET ${entries.map(([k]) => `${columns[k]} = ?`).join(', ')}${design ? ', design_revision = design_revision + 1' : ''} WHERE id = 1`,
-      entries.map(([k,v]) => jsonKeys.has(k) && v !== null ? JSON.stringify(v) : v));
+    return { sql: `UPDATE settings SET ${entries.map(([k]) => `${columns[k]} = ?`).join(', ')}${design ? ', design_revision = design_revision + 1' : ''} WHERE id = 1`,
+      args: entries.map(([k,v]) => jsonKeys.has(k) && v !== null ? JSON.stringify(v) : v) };
   }
   private async designWrite(expected: number, actor: string, action: string, statements: SqlStatement[]) {
     try {
@@ -1739,6 +1781,10 @@ export class SqlRepository implements ContentRepository {
     if (nav) statements.push({ sql: 'DELETE FROM nav_items' }, ...nav.map((n,i) => ({
       sql: 'INSERT INTO nav_items (id,label,url,area,ord) VALUES (?,?,?,?,?)', args: [n.id.startsWith('tmp-') ? crypto.randomUUID() : n.id,n.label,n.url,n.area,i],
     })));
+    statements.push(webhookStatement('design.published', { design: {
+      revision: current.designRevision + 1, activeTheme: design.activeTheme,
+      navigationChanged: nav !== null, sectionPageIds: Object.keys(design.sectionPages),
+    } }));
     await this.designWrite(opts.expectedRevision ?? current.designRevision, opts.author ?? 'admin', 'publish', statements);
   }
   async discardDesignDraft() { await this.setDesignDraft(null); }

package/src/lib/repo/types.ts

@@ -1,3 +1,4 @@
+import type { LiveStore } from '../live/store';
 import type { BookingRequest } from '../backup/content';
 import type { EmailStore } from '../email/store';
 export interface DesignVersion { id: string; createdAt: number; author: string; summary: string; snapshot: Record<string, unknown> }
@@ -42,6 +43,7 @@ export type EventUpdate = Partial<
 // this — never a concrete adapter.
 export interface ContentRepository {
   readonly email: EmailStore;
+  readonly live: LiveStore;
   // Bounded public catalog; fetch limit + 1 IDs without loading every body.
   listPublicContent(options: { page: number; limit: number; kind?: 'post' | 'page'; collection?: string; locale?: string; collections: string[]; defaultLocale: string }): Promise<{ id: string; kind: 'post' | 'page' }[]>;
   exportBookingState(): Promise<{ bookings: Booking[]; bookingRequests: BookingRequest[] }>;
@@ -172,6 +174,7 @@ export interface ContentRepository {
   createDeliveries(rows: Omit<WebhookDelivery, 'attempts' | 'responseCode' | 'deliveredAt'>[]): Promise<void>;
   listDueDeliveries(now: number, limit: number): Promise<WebhookDelivery[]>;
   listDeliveries(webhookId: string, limit: number): Promise<WebhookDelivery[]>;
+  claimDelivery(id: string, now: number): Promise<WebhookDelivery | null>;
   recordDelivery(id: string, data: Pick<WebhookDelivery, 'status' | 'attempts' | 'nextAt' | 'responseCode' | 'deliveredAt'>): Promise<void>;
 
   // media

package/src/lib/scheduler.ts

@@ -1,3 +1,4 @@
+import { syncDueLive } from './live/service';
 import type { ContentRepository } from './repo/types';
 import { processDueDeliveries } from './webhooks';
 import { dispatchEmail } from './email/service';
@@ -13,6 +14,7 @@ export async function runScheduledTasks(repo: ContentRepository, locals?: unknow
     webhooks: () => processDueDeliveries(repo),
     reminders: () => sendDueReminders(repo, { origin: settings.siteUrl, locals, now: startedAt }),
     email: () => dispatchEmail(repo, locals, 10),
+    live: () => syncDueLive(repo, locals),
   };
   const results: Record<string, { ok: boolean; count?: number }> = {};
   for (const [name, run] of Object.entries(jobs)) {

package/src/lib/schema.ts

@@ -1,3 +1,4 @@
+import { LiveConfig } from './live/types';
 import { SectionPages } from '../theme-sdk/contract.mjs';
 import { AiConfig, AgentConfig } from './ai-schema';
 import { z } from 'zod';
@@ -8,6 +9,7 @@ import { z } from 'zod';
 // component in src/components/widgets/ + an editor section in the admin.
 
 export const widgetConfigs = {
+  live: z.object({ display: z.enum(['card','player']).default('card') }),
   hero: z.object({
     heading: z.string().default(''),
     sub: z.string().default(''),
@@ -195,7 +197,7 @@ export const authorSlug = (u: Pick<User, 'name' | 'slug'>) => u.slug || slugify(
 // `<svg…>` markup (brand icons), or the keyword 'favicon'. `meta` is per-kind
 // extras: { color, textColor } button colors, { size } spacer height, vcard
 // fields, etc.
-export const LinkKind = z.enum(['link', 'email', 'phone', 'heading', 'text', 'spacer', 'vcard', 'html']);
+export const LinkKind = z.enum(['link', 'email', 'phone', 'heading', 'text', 'spacer', 'vcard', 'html', 'live']);
 export type LinkKind = z.infer<typeof LinkKind>;
 
 export const Link = z.object({
@@ -509,6 +511,9 @@ export const ApiKey = z.object({
 export type ApiKey = z.infer<typeof ApiKey>;
 
 export const WEBHOOK_EVENTS = [
+  'post.published', 'post.updated', 'post.unpublished', 'post.deleted',
+  'page.published', 'page.updated', 'page.unpublished', 'page.deleted',
+  'design.published', 'media.created', 'media.updated', 'media.deleted', 'site.restored',
   'event.published', 'event.updated', 'event.unpublished', 'event.deleted',
   'booking.created', 'booking.confirmed', 'booking.declined', 'booking.cancelled', 'booking.rescheduled',
 ] as const;
@@ -554,6 +559,7 @@ export function normalizeRedirectPath(input: string): string {
 }
 
 export const Settings = z.object({
+  live: LiveConfig.default({}),
   siteTitle: z.string().default('My Site'),
   tagline: z.string().default(''),
   // site-wide footer, markdown allowed; empty falls back to "title — tagline"

package/src/lib/themeTokens.ts

@@ -138,11 +138,20 @@ export function paletteVars(p: Palette, t: ThemeTokens, dark: boolean): string[]
     `--btn:${t.button === 'accent' ? 'var(--accent)' : 'var(--ink)'}`, `--btn-ink:${btnInk}`,
     `--code-bg:${dark ? '#0d0e11' : '#1b1c21'}`,
     `--success:${dark ? '#5cc98e' : '#127442'}`, `--danger:${dark ? '#f07b7b' : '#b42f2f'}`, `--warning:${dark ? '#e3b456' : '#8a5f0a'}`,
+    ...liveVars(dark ? t.dark?.live || (t.live ? ensureContrast(t.live, p.bg, 3, '#ffffff') : '#ff5a4e') : t.live || '#d42f25', p.bg),
     `--sh-1:${s1}`, `--sh-2:${s2}`, `--sh-3:${s3}`,
     `color-scheme:${dark ? 'dark' : 'light'}`,
   ];
 }
 
+// The live signal color stays visible on the canvas (3:1, it's a marker, not
+// body text) and gets whichever text color reads on it.
+function liveVars(live: string, bg: string): string[] {
+  const c = ensureContrast(live, bg, 3);
+  const on = contrast('#ffffff', c) >= 4.5 || contrast('#ffffff', c) >= contrast('#111214', c) ? '#ffffff' : '#111214';
+  return [`--live:${c}`, `--live-on:${on}`];
+}
+
 // Scheme-independent variables: type, shape, rhythm, layout widths.
 export function staticVars(t: ThemeTokens): string[] {
   const [r1, r2, r3] = RADII[t.radius];

package/src/lib/webhook-sql.ts

@@ -0,0 +1,68 @@
+import type { SqlStatement } from './repo/sql';
+import type { WebhookEventType } from './schema';
+
+// Shared by triggers and transactional design/restore writes. SQL expressions
+// passed here are authored in this module, never supplied by a request.
+const now = "CAST((julianday('now') - 2440587.5) * 86400000 AS INTEGER)";
+function enqueue(event: string, data: string) {
+  return `INSERT INTO webhook_deliveries (id,webhook_id,event,payload,status,attempts,next_at,created_at)
+    SELECT lower(hex(randomblob(16))),h.id,${event},
+      json_object('type',${event},'createdAt',strftime('%Y-%m-%dT%H:%M:%fZ','now'),'data',json(${data})),
+      'pending',0,${now},${now}
+    FROM webhooks h WHERE h.active=1 AND EXISTS (
+      SELECT 1 FROM json_each(h.events) WHERE value=${event} OR value='*'
+    ) AND (SELECT suppressed FROM webhook_control WHERE id=1)=0;`;
+}
+
+export function webhookStatement(event: WebhookEventType, data: Record<string, unknown>): SqlStatement {
+  return {
+    sql: enqueue(`'${event}'`, '?'),
+    args: [JSON.stringify(data)],
+  };
+}
+
+function trigger(name: string, action: string, table: string, when: string, event: string, data: string) {
+  return `CREATE TRIGGER ${name} AFTER ${action} ON ${table} WHEN ${when}
+    BEGIN ${enqueue(event, data)} END`;
+}
+
+function content(kind: 'post' | 'page') {
+  const table = `${kind}s`;
+  const fields = kind === 'post'
+    ? ['collection','slug','title','status','body','body_json','body_html','excerpt','tags','cover','cover_alt','seo_title','seo_desc','featured','author_id','template','published_at']
+    : ['slug','title','status','is_home','locale','blocks','body_json','body_html','seo_title','seo_desc','template'];
+  // Metadata only: draft bodies, unpublished edits, credentials and user
+  // details never enter a publication webhook. Receivers fetch public content.
+  const snapshot = (row: string) => `json_object('id',${row}.id,'slug',${row}.slug,'title',${row}.title,'status',${row}.status,
+    ${kind === 'post' ? `'collection',${row}.collection` : `'locale',${row}.locale,'isHome',json(CASE WHEN ${row}.is_home THEN 'true' ELSE 'false' END)`})`;
+  const changed = fields.map(f => `OLD.${f} IS NOT NEW.${f}`).join(' OR ');
+  const event = `CASE WHEN OLD.status!='published' THEN '${kind}.published'
+    WHEN NEW.status!='published' THEN '${kind}.unpublished' ELSE '${kind}.updated' END`;
+  return [
+    trigger(`webhook_${kind}_insert`, 'INSERT', table, "NEW.status='published'", `'${kind}.published'`, `json_object('${kind}',${snapshot('NEW')})`),
+    trigger(`webhook_${kind}_update`, 'UPDATE', table,
+      `(OLD.status='published' OR NEW.status='published') AND (${changed})`, event,
+      `json_object('${kind}',json(CASE WHEN NEW.status='published' THEN ${snapshot('NEW')}
+        ELSE json_set(${snapshot('OLD')},'$.status',NEW.status) END),
+        'previous',json(CASE WHEN OLD.status='published' THEN ${snapshot('OLD')} ELSE 'null' END))`),
+    trigger(`webhook_${kind}_delete`, 'DELETE', table, "OLD.status='published'", `'${kind}.deleted'`, `json_object('${kind}',${snapshot('OLD')})`),
+  ];
+}
+
+const media = (row: string) => `json_object('media',json_object('id',${row}.id,'key',${row}.key,'filename',${row}.filename,
+  'mime',${row}.mime,'width',${row}.width,'height',${row}.height,'size',${row}.size,'alt',${row}.alt))`;
+
+export const WEBHOOK_MIGRATION = { version: 33, statements: [
+  `CREATE TABLE webhook_control (id INTEGER PRIMARY KEY CHECK(id=1), suppressed INTEGER NOT NULL DEFAULT 0)`,
+  `INSERT INTO webhook_control (id,suppressed) VALUES (1,0)`,
+  // Populate the envelope from the inserted delivery's stable ID. Retries
+  // send these exact stored bytes, including for SQL-generated notifications.
+  `CREATE TRIGGER webhook_delivery_envelope AFTER INSERT ON webhook_deliveries
+    WHEN json_extract(NEW.payload,'$.id') IS NULL BEGIN
+      UPDATE webhook_deliveries SET payload=json_set(payload,'$.id',NEW.id) WHERE id=NEW.id;
+    END`,
+  ...content('post'), ...content('page'),
+  trigger('webhook_media_create','INSERT','media','1',"'media.created'",media('NEW')),
+  trigger('webhook_media_update','UPDATE','media','OLD.alt IS NOT NEW.alt',"'media.updated'",media('NEW')),
+  trigger('webhook_media_delete','DELETE','media','1',"'media.deleted'",media('OLD')),
+] };