@acms-subir/core 0.3.0 → 0.3.2

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')),
+] };

package/src/lib/webhooks.ts

@@ -50,6 +50,7 @@ export interface EmitOptions {
   fetcher?: Fetcher;
   // Workers: ctx.waitUntil, so the response isn't held for delivery
   waitUntil?: (p: Promise<unknown>) => void;
+  limit?: number;
 }
 
 export async function emitWebhook(
@@ -76,8 +77,11 @@ export async function emitWebhook(
   return rows;
 }
 
-export async function attemptDelivery(repo: ContentRepository, d: WebhookDelivery, hook: Webhook, opts: EmitOptions = {}): Promise<void> {
+export async function attemptDelivery(repo: ContentRepository, d: WebhookDelivery, hook: Webhook, opts: EmitOptions = {}): Promise<boolean> {
   const now = opts.now ?? Date.now();
+  const claimed = await repo.claimDelivery(d.id, now);
+  if (!claimed) return false;
+  d = claimed;
   const fetcher: Fetcher = opts.fetcher ?? ((url, init) => fetch(url, init));
   const ts = Math.floor(now / 1000);
   let code: number | null = null;
@@ -111,24 +115,28 @@ export async function attemptDelivery(repo: ContentRepository, d: WebhookDeliver
     responseCode: code,
     deliveredAt: ok ? now : null,
   });
+  return true;
 }
 
 // retry sweep: due pending deliveries, oldest first, bounded per run
 export async function processDueDeliveries(repo: ContentRepository, opts: EmitOptions = {}): Promise<number> {
   const now = opts.now ?? Date.now();
-  const due = await repo.listDueDeliveries(now, 25);
+  const due = await repo.listDueDeliveries(now, opts.limit ?? 25);
   if (!due.length) return 0;
   const hooks = new Map((await repo.listWebhooks()).map((h) => [h.id, h]));
   let n = 0;
-  for (const d of due) {
+  const deliver = async (d: WebhookDelivery) => {
     const hook = hooks.get(d.webhookId);
     if (!hook || !hook.active) {
       await repo.recordDelivery(d.id, { status: 'failed', attempts: d.attempts, nextAt: null, responseCode: null, deliveredAt: null });
-      continue;
+      return;
     }
-    await attemptDelivery(repo, d, hook, { ...opts, now });
-    n++;
-  }
+    // Each claim gets a fresh clock, even after earlier batches time out.
+    if (await attemptDelivery(repo, d, hook, opts)) n++;
+  };
+  // Bound network concurrency, while avoiding a string of eight-second
+  // endpoint timeouts holding up a request or exhausting waitUntil time.
+  for (let i = 0; i < due.length; i += 5) await Promise.all(due.slice(i, i + 5).map(deliver));
   return n;
 }
 

package/src/lib/widgets.ts

@@ -13,6 +13,7 @@ export interface WidgetMeta {
 }
 
 export const widgetMeta: Record<WidgetType, WidgetMeta> = {
+  live: { label: 'Live video', description: 'Your shared live broadcast (set up in Integrations)', group: 'Content', icon: 'M3 5h12v14H3zM15 10l6-4v12l-6-4' },
   hero: {
     label: 'Hero',
     description: 'Headline, subtitle + CTA',

package/src/middleware.ts

@@ -85,7 +85,7 @@ export const onRequest = defineMiddleware(async (context, next) => {
       const emails = dispatchEmail(repo, context.locals, 2).catch(() => 0);
       const wait = waitUntilFrom(context.locals);
       if (wait) wait(emails); else await emails;
-      const retries = processDueDeliveries(repo, { now }).catch(() => {});
+      const retries = processDueDeliveries(repo).catch(() => {});
       if (wait) wait(retries); else await retries;
       // booking reminders (Node has no cron): site URL, else this request's origin
       const reminders = repo.getSettings()
@@ -99,6 +99,15 @@ export const onRequest = defineMiddleware(async (context, next) => {
 
   const response = await next();
 
+  // Database writes enqueue publication/media notifications atomically.
+  // Flush after mutations (including Astro actions), once their transaction
+  // has committed. The scheduler remains the durable fallback on failure.
+  if (!['GET', 'HEAD', 'OPTIONS'].includes(context.request.method)) {
+    const deliveries = getRepo(context.locals).then(repo => processDueDeliveries(repo, { limit: 5 })).catch(() => 0);
+    const wait = waitUntilFrom(context.locals);
+    if (wait) wait(deliveries); else await deliveries;
+  }
+
   // a preview render must never be cached where a visitor could get it
   if (hasPreviewCookie(context.cookies)) {
     try {

package/src/pages/[...slug].astro

@@ -21,6 +21,12 @@ if (!page || (page.status !== 'published' && !isAdmin)) {
 const bodyHtml = page.bodyHtml ? highlightCodeHtml(await expandDynamicBlocks(page.bodyHtml, repo)) : '';
 // ?designPreview=1 (admin-only) renders the staged Design-screen changes
 const settings = await effectiveSettings(await repo.getSettings(), Astro.url, Astro.cookies, Astro.locals);
+// Live state must not survive in a cached page after its snapshot expires.
+if (settings.live.mode !== 'off' || page?.blocks.some(block => block.type === 'live') ||
+    (page && settings.sectionPages?.[page.id]?.sections.some(section => section.type === 'live'))) {
+  Astro.response.headers.set('Cache-Control', 'no-store');
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const PageTemplate = (page.template && settings.sectionPages?.[page.id]?.mode !== 'content' ? resolveDesign(settings).theme.pageTemplates[page.template] : null) as any;
 ---