@commonpub/layer 0.23.3 → 0.25.0

package/sections/builtin/embed.ts

@@ -0,0 +1,31 @@
+/**
+ * Built-in section definition: embed.
+ *
+ * Stage E.2 — reuses BlockEmbedView (generic-iframe renderer). Host
+ * allowlist + sandbox policy live in BlockEmbedView.
+ *
+ * Schema (incl. URL_HTTPS_OR_EMPTY guard — strict http(s) only, no
+ * relative-path branch unlike image/video/gallery) lives in
+ * `@commonpub/schema/sectionConfigs` (session 161 move).
+ */
+import type { SectionDefinition } from '@commonpub/ui';
+import { embedConfigSchema, type EmbedConfig } from '@commonpub/schema';
+import BlockEmbedView from '../../components/blocks/BlockEmbedView.vue';
+
+export const embedSection: SectionDefinition<EmbedConfig> = {
+  type: 'embed',
+  name: 'Embed',
+  description: 'Tweets, gists, CodePen, Loom, etc (uses BlockEmbedView)',
+  icon: 'fa-square-arrow-up-right',
+  category: 'content',
+  status: 'stable',
+  configSchema: embedConfigSchema,
+  defaultConfig: { url: '' },
+  schemaVersion: 1,
+  component: BlockEmbedView,
+  propMap: ({ config }) => ({ content: config }),
+  minColSpan: 6,
+  maxColSpan: 12,
+  defaultColSpan: 12,
+  resizable: true,
+};

package/sections/builtin/gallery.ts

@@ -0,0 +1,29 @@
+/**
+ * Built-in section definition: gallery.
+ *
+ * Stage E.2 — reuses BlockGalleryView (image grid + lightbox).
+ *
+ * Schema (incl. per-image URL_MEDIA_OR_EMPTY guard + max-20 array bound)
+ * lives in `@commonpub/schema/sectionConfigs` (session 161 move).
+ */
+import type { SectionDefinition } from '@commonpub/ui';
+import { galleryConfigSchema, type GalleryConfig } from '@commonpub/schema';
+import BlockGalleryView from '../../components/blocks/BlockGalleryView.vue';
+
+export const gallerySection: SectionDefinition<GalleryConfig> = {
+  type: 'gallery',
+  name: 'Gallery',
+  description: 'Image grid (uses BlockGalleryView)',
+  icon: 'fa-images',
+  category: 'content',
+  status: 'stable',
+  configSchema: galleryConfigSchema,
+  defaultConfig: { images: [] },
+  schemaVersion: 1,
+  component: BlockGalleryView,
+  propMap: ({ config }) => ({ content: config }),
+  minColSpan: 6,
+  maxColSpan: 12,
+  defaultColSpan: 12,
+  resizable: true,
+};

package/sections/builtin/heading.ts

@@ -1,34 +1,29 @@
 /**
  * Built-in section definition: heading.
  *
- * Phase 1c starter — single heading with optional eyebrow + subline.
- * Drives the auto-form via the configSchema (Phase 3e maps Zod kinds to
- * controls; level is a small enum → segmented control).
+ * Stage E.1 (session 159) — reuses the existing `BlockHeadingView`
+ * renderer (`layers/base/components/blocks/BlockHeadingView.vue`)
+ * instead of a parallel `SectionHeading.vue`.
+ *
+ * Schema lives in `@commonpub/schema/sectionConfigs` (session 161 move).
+ * See `feedback-reuse-existing-components` memory + Stage E plan.
  */
-import { z } from 'zod';
 import type { SectionDefinition } from '@commonpub/ui';
-import SectionHeading from '../../components/sections/SectionHeading.vue';
-
-const configSchema = z.object({
-  text: z.string().min(1).max(240).default('Section heading'),
-  level: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4)]).default(2),
-  align: z.enum(['left', 'center']).default('left'),
-  eyebrow: z.string().max(120).default(''),
-  subline: z.string().max(480).default(''),
-});
+import { headingConfigSchema, type HeadingConfig } from '@commonpub/schema';
+import BlockHeadingView from '../../components/blocks/BlockHeadingView.vue';
 
-export const headingSection: SectionDefinition<z.infer<typeof configSchema>> = {
+export const headingSection: SectionDefinition<HeadingConfig> = {
   type: 'heading',
   name: 'Heading',
-  description: 'Single h1–h4 heading with optional eyebrow + subline',
+  description: 'Single h1–h6 heading (uses BlockHeadingView)',
   icon: 'fa-heading',
   category: 'content',
   status: 'stable',
-  configSchema,
-  defaultConfig: { text: 'Section heading', level: 2, align: 'left', eyebrow: '', subline: '' },
+  configSchema: headingConfigSchema,
+  defaultConfig: { level: 2, text: 'Section heading' },
   schemaVersion: 1,
-  component: SectionHeading,
-  // Heading reads fine narrow; allow as small as quarter-width
+  component: BlockHeadingView,
+  propMap: ({ config }) => ({ content: config }),
   minColSpan: 3,
   maxColSpan: 12,
   defaultColSpan: 12,

package/sections/builtin/hero.ts

@@ -1,67 +1,32 @@
 /**
  * Built-in section definition: hero.
  *
- * Phase 1c starter. Three variants — `default` (left-aligned with grid
- * backdrop), `compact` (narrow with no backdrop), `centered` (centered
- * content). Up to two CTAs each with their own variant.
+ * Stage E.4 — reuses the existing HeroSection which handles
+ * contest-aware swap + dismiss button + hardcoded fallback copy
+ * ("Build. Document. Share.").
  *
- * NOT contest-aware (the existing HomepageHeroSection has dispatch
- * logic for the live-contest hero — that responsibility moves to a
- * future `contest-feature` data section in Phase 6b).
+ * Schema (incl. URL_LINK_STRICT guard on CTA hrefs) lives in
+ * `@commonpub/schema/sectionConfigs` (session 161 move).
  */
-import { z } from 'zod';
 import type { SectionDefinition } from '@commonpub/ui';
-import SectionHero from '../../components/sections/SectionHero.vue';
+import { heroConfigSchema, type HeroConfig } from '@commonpub/schema';
+import HeroSection from '../../components/homepage/HeroSection.vue';
 
-/**
- * URL guard — accepts http(s), site-relative paths, hash links, mailto/tel.
- * Rejects javascript:, data:, vbscript:, file:, etc. — admin-set fields
- * render to ALL visitors, so a malicious admin (or DB corruption) could
- * inject a clickable XSS via `<a href="javascript:...">` without this.
- *
- * Defense at the write boundary; the renderer doesn't re-validate
- * (Vue's :href binding doesn't sanitize, so this IS the guard).
- */
-const SAFE_LINK_URL = /^(https?:\/\/|\/|#|mailto:|tel:)/i;
-
-const ctaSchema = z.object({
-  label: z.string().min(1).max(80),
-  href: z.string().min(1).max(2048).regex(SAFE_LINK_URL, {
-    message: 'href must be http(s), relative (/), hash (#), mailto:, or tel:',
-  }),
-  variant: z.enum(['primary', 'secondary']).default('primary'),
-});
-
-const configSchema = z.object({
-  variant: z.enum(['default', 'compact', 'centered']).default('default'),
-  eyebrow: z.string().max(120).default(''),
-  title: z.string().min(1).max(240).default('Welcome'),
-  subtitle: z.string().max(800).default(''),
-  // Capped at 2 — visual + a11y guidance: more than two competing CTAs
-  // dilute the call-to-action and read as a button bar instead.
-  ctas: z.array(ctaSchema).max(2).default([]),
-});
-
-export const heroSection: SectionDefinition<z.infer<typeof configSchema>> = {
+export const heroSection: SectionDefinition<HeroConfig> = {
   type: 'hero',
   name: 'Hero',
-  description: 'Banner with title, subtitle, and up to two CTAs',
+  description: 'Top-of-page banner (uses HeroSection — contest-aware)',
   icon: 'fa-bullhorn',
   category: 'layout',
   status: 'stable',
-  configSchema,
-  defaultConfig: {
-    variant: 'default',
-    eyebrow: '',
-    title: 'Welcome',
-    subtitle: '',
-    ctas: [],
-  },
+  configSchema: heroConfigSchema,
+  defaultConfig: { variant: 'default', customTitle: '', customSubtitle: '', ctas: [] },
   schemaVersion: 1,
-  component: SectionHero,
-  // Hero breaks at <6 cols (CTA wrap looks awful); 12 is the canonical use
-  minColSpan: 6,
+  component: HeroSection,
+  // HeroSection takes { config: HomepageSectionConfig }
+  propMap: ({ config }) => ({ config }),
+  minColSpan: 12,
   maxColSpan: 12,
   defaultColSpan: 12,
-  resizable: true,
+  resizable: false,
 };

package/sections/builtin/hubs.ts

@@ -0,0 +1,30 @@
+/**
+ * Built-in section definition: hubs.
+ *
+ * Stage E.4 — reuses the existing HubsSection (Trending Hubs sidebar
+ * card with join CTAs).
+ *
+ * Schema lives in `@commonpub/schema/sectionConfigs` (session 161 move).
+ */
+import type { SectionDefinition } from '@commonpub/ui';
+import { hubsConfigSchema, type HubsConfig } from '@commonpub/schema';
+import HubsSection from '../../components/homepage/HubsSection.vue';
+
+export const hubsSection: SectionDefinition<HubsConfig> = {
+  type: 'hubs',
+  name: 'Hubs',
+  description: 'Trending hubs with join action (uses HubsSection)',
+  icon: 'fa-users',
+  category: 'data',
+  status: 'stable',
+  featureGate: 'hubs',
+  configSchema: hubsConfigSchema,
+  defaultConfig: { limit: 4 },
+  schemaVersion: 1,
+  component: HubsSection,
+  propMap: ({ config }) => ({ config }),
+  minColSpan: 3,
+  maxColSpan: 12,
+  defaultColSpan: 4,
+  resizable: true,
+};

package/sections/builtin/image.ts

@@ -1,65 +1,28 @@
 /**
  * Built-in section definition: image.
  *
- * Phase 1c starter. Stores raw URL + alt + optional caption + optional
- * href. The Phase 3e auto-form will swap `src` for an ImageUpload picker
- * via `.describe('image')` — current Zod is a plain URL string so the
- * form generator still produces a usable text input today.
+ * Stage E.1 — reuses BlockImageView (`<figure>` with size preset +
+ * caption + lazy loading).
  *
- * Security note: `src` is rendered as-is via `<img>` — sanitisation is
- * caller responsibility (the URL is never reflected into a script
- * context). Custom-HTML / iframe sections are the XSS surface and gate
- * differently (admin-only addRoles in Phase 6b).
+ * Schema (incl. URL_MEDIA_OR_EMPTY guard on `src`) lives in
+ * `@commonpub/schema/sectionConfigs` (session 161 move).
  */
-import { z } from 'zod';
 import type { SectionDefinition } from '@commonpub/ui';
-import SectionImage from '../../components/sections/SectionImage.vue';
+import { imageConfigSchema, type ImageConfig } from '@commonpub/schema';
+import BlockImageView from '../../components/blocks/BlockImageView.vue';
 
-/**
- * URL guards — separate for `src` (image fetch) vs `href` (click target).
- *
- * - `src`: http(s) or site-relative. data: rejected (large + tracking
- *   surface; ImageUpload should be the path for inline data). javascript:
- *   in <img src> doesn't execute in modern browsers, but disallow anyway
- *   for consistency.
- * - `href`: http(s), site-relative, hash, mailto:, tel:. javascript:
- *   would execute on click — admin-set fields render to ALL visitors so
- *   this is a stored XSS surface without the regex.
- *
- * Both allow EMPTY string (the section's "no image yet" / "no link"
- * state). The `^(?:$|…)` shape matches empty-string only when the
- * `$` end-of-string anchor immediately follows `^` — pinned by tests
- * because the obvious `^(?:|…)` would have an empty alternation
- * branch that matches ANY input (the empty match always succeeds at
- * position 0).
- */
-const SAFE_IMAGE_URL = /^(?:$|https?:\/\/|\/)/i;
-const SAFE_LINK_URL = /^(?:$|https?:\/\/|\/|#|mailto:|tel:)/i;
-
-const configSchema = z.object({
-  src: z.string().max(2048).regex(SAFE_IMAGE_URL, {
-    message: 'src must be http(s) or relative (/)',
-  }).default(''),
-  alt: z.string().max(240).default(''),
-  caption: z.string().max(480).default(''),
-  href: z.string().max(2048).regex(SAFE_LINK_URL, {
-    message: 'href must be http(s), relative (/), hash (#), mailto:, or tel:',
-  }).default(''),
-  fit: z.enum(['contain', 'cover']).default('contain'),
-  aspectRatio: z.enum(['16/9', '4/3', '1/1', 'auto']).default('auto'),
-});
-
-export const imageSection: SectionDefinition<z.infer<typeof configSchema>> = {
+export const imageSection: SectionDefinition<ImageConfig> = {
   type: 'image',
   name: 'Image',
-  description: 'Single image with optional caption + link',
+  description: 'Single image with caption (uses BlockImageView)',
   icon: 'fa-image',
   category: 'content',
   status: 'stable',
-  configSchema,
-  defaultConfig: { src: '', alt: '', caption: '', href: '', fit: 'contain', aspectRatio: 'auto' },
+  configSchema: imageConfigSchema,
+  defaultConfig: { src: '', alt: '', caption: '', size: 'l' },
   schemaVersion: 1,
-  component: SectionImage,
+  component: BlockImageView,
+  propMap: ({ config }) => ({ content: config }),
   minColSpan: 3,
   maxColSpan: 12,
   defaultColSpan: 12,

package/sections/builtin/learning.ts

@@ -0,0 +1,30 @@
+/**
+ * Built-in section definition: learning.
+ *
+ * Phase 1c addition (session 159) — learning paths grid. Server-fetches
+ * `/api/learn?limit=N` and renders a responsive grid of cards.
+ *
+ * Schema lives in `@commonpub/schema/sectionConfigs` (session 161 move).
+ */
+import type { SectionDefinition } from '@commonpub/ui';
+import { learningConfigSchema, type LearningConfig } from '@commonpub/schema';
+import SectionLearning from '../../components/sections/SectionLearning.vue';
+
+export const learningSection: SectionDefinition<LearningConfig> = {
+  type: 'learning',
+  name: 'Learning paths',
+  description: 'Grid of learning paths with enrollment + difficulty (feature-gated)',
+  icon: 'fa-graduation-cap',
+  category: 'data',
+  status: 'stable',
+  // Palette gate — see hubs.ts for the rationale.
+  featureGate: 'learning',
+  configSchema: learningConfigSchema,
+  defaultConfig: { heading: 'Learning Paths', limit: 6, columns: 3 },
+  schemaVersion: 1,
+  component: SectionLearning,
+  minColSpan: 6,
+  maxColSpan: 12,
+  defaultColSpan: 12,
+  resizable: true,
+};

package/sections/builtin/markdown.ts

@@ -0,0 +1,29 @@
+/**
+ * Built-in section definition: markdown.
+ *
+ * Stage E.2 — reuses BlockMarkdownView. Pipes source markdown through
+ * markdownToBlockTuples + sanitizeBlockHtml — safer than custom-html.
+ *
+ * Schema lives in `@commonpub/schema/sectionConfigs` (session 161 move).
+ */
+import type { SectionDefinition } from '@commonpub/ui';
+import { markdownConfigSchema, type MarkdownConfig } from '@commonpub/schema';
+import BlockMarkdownView from '../../components/blocks/BlockMarkdownView.vue';
+
+export const markdownSection: SectionDefinition<MarkdownConfig> = {
+  type: 'markdown',
+  name: 'Markdown',
+  description: 'Markdown body — safer than custom-html (uses BlockMarkdownView)',
+  icon: 'fa-markdown',
+  category: 'content',
+  status: 'stable',
+  configSchema: markdownConfigSchema,
+  defaultConfig: { source: '' },
+  schemaVersion: 1,
+  component: BlockMarkdownView,
+  propMap: ({ config }) => ({ content: config }),
+  minColSpan: 3,
+  maxColSpan: 12,
+  defaultColSpan: 12,
+  resizable: true,
+};

package/sections/builtin/paragraph.ts

@@ -1,32 +1,29 @@
 /**
  * Built-in section definition: paragraph.
  *
- * Phase 1c starter — plain prose, blank-line split into `<p>` tags.
- * Upgrade to TipTap-driven rich text in Phase 3e via `.describe('rich')`
- * + a v2 migration; this v1 keeps the storage simple so the editor work
- * doesn't block on TipTap integration.
+ * Stage E.1 — reuses BlockTextView (sanitised HTML body via
+ * `sanitizeBlockHtml`). Admin-set HTML works because BlockTextView pipes
+ * through sanitizeBlockHtml — same XSS posture as the rest of the Block
+ * system.
+ *
+ * Schema lives in `@commonpub/schema/sectionConfigs` (session 161 move).
  */
-import { z } from 'zod';
 import type { SectionDefinition } from '@commonpub/ui';
-import SectionParagraph from '../../components/sections/SectionParagraph.vue';
-
-const configSchema = z.object({
-  text: z.string().max(8000).default(''),
-  align: z.enum(['left', 'center']).default('left'),
-});
+import { paragraphConfigSchema, type ParagraphConfig } from '@commonpub/schema';
+import BlockTextView from '../../components/blocks/BlockTextView.vue';
 
-export const paragraphSection: SectionDefinition<z.infer<typeof configSchema>> = {
+export const paragraphSection: SectionDefinition<ParagraphConfig> = {
   type: 'paragraph',
   name: 'Paragraph',
-  description: 'Plain prose body with blank-line paragraph breaks',
+  description: 'Sanitised HTML body (uses BlockTextView)',
   icon: 'fa-align-left',
   category: 'content',
   status: 'stable',
-  configSchema,
-  defaultConfig: { text: '', align: 'left' },
+  configSchema: paragraphConfigSchema,
+  defaultConfig: { html: '<p>Paragraph body.</p>' },
   schemaVersion: 1,
-  component: SectionParagraph,
-  // Prose reads best at ~6/12; allow narrower for sidebars + full-width on landing pages
+  component: BlockTextView,
+  propMap: ({ config }) => ({ content: config }),
   minColSpan: 3,
   maxColSpan: 12,
   defaultColSpan: 6,

package/sections/builtin/stats.ts

@@ -0,0 +1,35 @@
+/**
+ * Built-in section definition: stats.
+ *
+ * Stage E.4 — reuses the existing StatsSection (`layers/base/
+ * components/homepage/StatsSection.vue`) which fetches `/api/stats`
+ * + renders the Projects/Posts/Members/Hubs sidebar card. StatsSection
+ * takes no props (reads useFeatures internally for the hubs gate).
+ *
+ * Schema lives in `@commonpub/schema/sectionConfigs` (session 161 move).
+ * Schema is intentionally `z.object({})` so admin tooling / migrations
+ * can pass extra fields (e.g., legacy `heading: 'Platform Stats'`)
+ * without rejection; StatsSection ignores them since it takes no props.
+ */
+import type { SectionDefinition } from '@commonpub/ui';
+import { statsConfigSchema, type StatsConfig } from '@commonpub/schema';
+import StatsSection from '../../components/homepage/StatsSection.vue';
+
+export const statsSection: SectionDefinition<StatsConfig> = {
+  type: 'stats',
+  name: 'Platform stats',
+  description: 'Projects/Posts/Members/Hubs sidebar card (uses StatsSection)',
+  icon: 'fa-chart-simple',
+  category: 'data',
+  status: 'stable',
+  configSchema: statsConfigSchema,
+  defaultConfig: {},
+  schemaVersion: 1,
+  component: StatsSection,
+  // StatsSection takes no props — pass empty object
+  propMap: () => ({}),
+  minColSpan: 3,
+  maxColSpan: 12,
+  defaultColSpan: 4,
+  resizable: true,
+};

package/sections/builtin/video.ts

@@ -0,0 +1,30 @@
+/**
+ * Built-in section definition: video.
+ *
+ * Stage E.2 — reuses BlockVideoView (YouTube/Vimeo embed routing +
+ * local file fallback).
+ *
+ * Schema (incl. URL_MEDIA_OR_EMPTY guard) lives in
+ * `@commonpub/schema/sectionConfigs` (session 161 move).
+ */
+import type { SectionDefinition } from '@commonpub/ui';
+import { videoConfigSchema, type VideoConfig } from '@commonpub/schema';
+import BlockVideoView from '../../components/blocks/BlockVideoView.vue';
+
+export const videoSection: SectionDefinition<VideoConfig> = {
+  type: 'video',
+  name: 'Video',
+  description: 'YouTube / Vimeo / local file (uses BlockVideoView)',
+  icon: 'fa-film',
+  category: 'content',
+  status: 'stable',
+  configSchema: videoConfigSchema,
+  defaultConfig: { url: '' },
+  schemaVersion: 1,
+  component: BlockVideoView,
+  propMap: ({ config }) => ({ content: config }),
+  minColSpan: 6,
+  maxColSpan: 12,
+  defaultColSpan: 12,
+  resizable: true,
+};

package/sections/registry.ts

@@ -29,26 +29,57 @@ import { paragraphSection } from './builtin/paragraph';
 import { imageSection } from './builtin/image';
 import { heroSection } from './builtin/hero';
 import { contentFeedSection } from './builtin/content-feed';
+import { editorialSection } from './builtin/editorial';
+import { statsSection } from './builtin/stats';
+import { hubsSection } from './builtin/hubs';
+import { contestsSection } from './builtin/contests';
+import { learningSection } from './builtin/learning';
+import { customHtmlSection } from './builtin/custom-html';
+import { ctaSection } from './builtin/cta';
+import { markdownSection } from './builtin/markdown';
+import { gallerySection } from './builtin/gallery';
+import { videoSection } from './builtin/video';
+import { embedSection } from './builtin/embed';
 
 // Singleton — registered once at module load. Vue/Nuxt's setup() runs
 // per-component, but module load is once per app process. Safe.
 const registry = new SectionRegistry();
 
 // --- Built-in registrations -----------------------------------------------
-// Phase 1c starter catalog: divider (proof-of-life) + 5 sections covering
-// the four leading categories — layout (hero, divider), content (heading,
-// paragraph, image), and data (content-feed).
+// Phase 1c full catalog (session 159): divider (proof-of-life) + 11
+// sections covering the four leading categories — layout (hero,
+// divider), content (heading, paragraph, image, custom-html), and data
+// (content-feed, editorial, stats, hubs, contests, learning).
 //
-// Phase 6b adds the remaining 20 types (gallery, video, embed, spacer,
-// cta, featured-content, content-card, contest-list, hub-list, event-list,
-// member-list, stats-grid, contact-form, newsletter, announcement,
-// markdown, custom-html, iframe, editorial). See docs/plans/layout-and-pages.md §3.4.
+// With the addition of editorial / stats / hubs / contests / learning /
+// custom-html this session, every section type the legacy
+// `homepage.sections` JSON dispatches to (HomepageSectionRenderer.vue)
+// is now representable as a registered section — unblocking the real
+// legacy-homepage migration (Phase 1c step 3 in the session-158 handoff).
+//
+// Phase 6b will add the remaining 18 types (gallery, video, embed,
+// spacer, cta, featured-content, content-card, contest-list, hub-list,
+// event-list, member-list, stats-grid, contact-form, newsletter,
+// announcement, markdown, iframe, content-grid alias). See
+// docs/plans/layout-and-pages.md §3.4.
 registry.register(dividerSection);
 registry.register(heroSection);
 registry.register(headingSection);
 registry.register(paragraphSection);
 registry.register(imageSection);
 registry.register(contentFeedSection);
+registry.register(editorialSection);
+registry.register(statsSection);
+registry.register(hubsSection);
+registry.register(contestsSection);
+registry.register(learningSection);
+registry.register(customHtmlSection);
+// Phase 6b additions (session 159)
+registry.register(ctaSection);
+registry.register(markdownSection);
+registry.register(gallerySection);
+registry.register(videoSection);
+registry.register(embedSection);
 
 /**
  * Read-only accessor — the layer's standard pattern for shared state.

package/server/api/admin/homepage/sections.put.ts

@@ -1,5 +1,6 @@
-import { setHomepageSections } from '@commonpub/server';
+import { setHomepageSections, migrateHomepageSectionsToLayout } from '@commonpub/server';
 import { z } from 'zod';
+import { invalidateLayoutsByRouteCache } from '../../../utils/layoutCache';
 
 const sectionConfigSchema = z.object({
   contentType: z.string().max(64).optional(),
@@ -48,5 +49,55 @@ export default defineEventHandler(async (event) => {
 
   await setHomepageSections(db, body.sections, user.id, getRequestIP(event) ?? undefined);
 
+  // When the layout engine is on, the legacy `homepage.sections` JSON
+  // is no longer what /pages/index.vue renders — the page reads from
+  // the `layouts` table. Without this sync, admin edits made via the
+  // existing homepage editor (which still writes homepage.sections,
+  // because the Phase 3 layout editor isn't built yet) would have
+  // ZERO visible effect on the live page.
+  //
+  // Fix: after the legacy save succeeds, if layoutEngine is on,
+  // **R4 audit P0 data-loss fix (session 160)**: previously this called
+  // migrateHomepageSectionsToLayout with force:true on every legacy save,
+  // which DELETES the existing layout (cascade → rows, sections,
+  // VERSIONS). If an admin had bespoke-edited the homepage via /admin/
+  // layouts, those edits + the entire publish history were silently
+  // destroyed the next time anyone touched /admin/homepage. Same data-
+  // loss path also hit the audit log if two admins were editing in
+  // parallel.
+  //
+  // New semantics: NON-DESTRUCTIVE auto-sync. If a layout doesn't yet
+  // exist for ('route','/'), create it from the legacy data so the
+  // first-time operator's legacy edits keep working. If a layout DOES
+  // exist, leave it alone — the new editor is the source of truth from
+  // that point forward. /admin/homepage now shows a deprecation banner
+  // (see the page itself) directing operators to /admin/layouts.
+  //
+  // History: original auto-sync added session 159 (per the comment
+  // above) to handle "I removed a section in /admin/homepage but it
+  // still renders" — that scenario still works on first-time admins
+  // since the layout gets created on first save. After the operator
+  // adopts the layout editor, /admin/homepage becomes effectively
+  // read-only with respect to the live homepage; the legacy data still
+  // saves into instance_settings for backward-compat but is no longer
+  // promoted.
+  const config = useConfig();
+  if (config.features.layoutEngine) {
+    try {
+      const result = await migrateHomepageSectionsToLayout(db, {
+        adminId: user.id,
+        force: false, // changed from true — see comment above
+      });
+      if (result.migrated) {
+        invalidateLayoutsByRouteCache();
+      }
+    } catch (err) {
+      // Don't fail the user's save just because the layout sync hit a
+      // hiccup. Log + return — they can re-trigger the migration via
+      // the dedicated /api/admin/layouts/migrate-homepage endpoint.
+      console.error('[admin:homepage.sections] post-save layout sync failed:', err);
+    }
+  }
+
   return { sections: body.sections, message: 'Homepage updated' };
 });

package/server/api/admin/layouts/[id]/publish.post.ts

@@ -28,6 +28,18 @@ export default defineEventHandler(async (event) => {
   }
 
   const version = await publishLayout(db, id, { publishedBy: admin.id });
+
+  // Audit log (round 3): publish changes what the public sees — highest-
+  // leverage action. layout_versions also stores publishedBy (durable trail);
+  // stdout adds incident-response greppability.
+  console.info('cpub.audit.layout.publish', JSON.stringify({
+    at: new Date().toISOString(),
+    adminId: admin.id,
+    layoutId: id,
+    scope: existing.scope,
+    versionId: (version as { id?: string } | null | undefined)?.id ?? null,
+  }));
+
   invalidateLayoutsByRouteCache();
   return version;
 });

package/server/api/admin/layouts/[id]/versions/[versionId]/revert.post.ts

@@ -31,6 +31,17 @@ export default defineEventHandler(async (event) => {
 
   try {
     const reverted = await revertToVersion(db, id, versionId, { userId: admin.id });
+
+    // Audit log (round 3): revert overwrites current state with a prior
+    // snapshot — destructive transformation, deserves forensic trail.
+    console.info('cpub.audit.layout.revert', JSON.stringify({
+      at: new Date().toISOString(),
+      adminId: admin.id,
+      layoutId: id,
+      scope: existing.scope,
+      versionId,
+    }));
+
     invalidateLayoutsByRouteCache();
     return reverted;
   } catch (e) {