@prenta/admin 0.92.0 → 0.94.0

package/src/lib/breakpoints.ts

@@ -0,0 +1,107 @@
+/**
+ * Breakpoint presets for the editor canvas — shared by the page editor, the
+ * post editor, and the site-preview frame.
+ *
+ * Each entry's `width` is the **real CSS width** the canvas renders at. The
+ * canvas is then scaled down with a transform to fit the available column, so
+ * the page reflows against its own width via container queries rather than
+ * being squeezed by a max-width clamp. A clamp does not reflow: it produces a
+ * narrow desktop layout, not the mobile layout.
+ *
+ * `4k` is 2560, not 3840. 2560 is the CSS width a 4K/Retina display reports
+ * once device-pixel-ratio is applied; 3840 is the physical pixel count and no
+ * stylesheet ever sees it. It is also the only preset above the canvas's
+ * `min-width: 2000px` container step, so it is the only one that exercises
+ * that branch.
+ */
+
+export type BreakpointId = '4k' | 'wide' | 'laptop' | 'tabletL' | 'tabletP' | 'mobile'
+
+export type BreakpointGroup = 'DESKTOP' | 'TABLET' | 'MOBILE'
+
+export interface Breakpoint {
+  id: BreakpointId
+  /** Full name, shown in the picker menu. */
+  name: string
+  /** Two-letter form for the collapsed trigger. */
+  abbr: string
+  /** lucide-react icon name */
+  icon: string
+  /** Real CSS width of the preview surface, in px. */
+  width: number
+  group: BreakpointGroup
+}
+
+export const BREAKPOINTS: readonly Breakpoint[] = [
+  { id: '4k', name: '4K / Retina', abbr: '4K', icon: 'monitor', width: 2560, group: 'DESKTOP' },
+  { id: 'wide', name: 'Wide Screen', abbr: 'WS', icon: 'monitor', width: 1920, group: 'DESKTOP' },
+  { id: 'laptop', name: 'Laptop', abbr: 'LT', icon: 'laptop', width: 1440, group: 'DESKTOP' },
+  {
+    id: 'tabletL',
+    name: 'Tablet Landscape',
+    abbr: 'TL',
+    icon: 'tablet',
+    width: 1024,
+    group: 'TABLET',
+  },
+  {
+    id: 'tabletP',
+    name: 'Tablet Portrait',
+    abbr: 'TP',
+    icon: 'tablet',
+    width: 768,
+    group: 'TABLET',
+  },
+  { id: 'mobile', name: 'Mobile', abbr: 'M', icon: 'smartphone', width: 390, group: 'MOBILE' },
+]
+
+/** Menu order. Groups render as labelled sections in the breakpoint picker. */
+export const BREAKPOINT_GROUPS: readonly BreakpointGroup[] = ['DESKTOP', 'TABLET', 'MOBILE']
+
+export const DEFAULT_BREAKPOINT: BreakpointId = 'wide'
+
+const BY_ID = new Map(BREAKPOINTS.map((b) => [b.id, b]))
+
+export function getBreakpoint(id: BreakpointId): Breakpoint {
+  return BY_ID.get(id) ?? BY_ID.get(DEFAULT_BREAKPOINT)!
+}
+
+export function breakpointsInGroup(group: BreakpointGroup): Breakpoint[] {
+  return BREAKPOINTS.filter((b) => b.group === group)
+}
+
+/**
+ * Narrows arbitrary input (persisted state, a URL param, a stale prop) to a
+ * known id. The v0.92 preset ids — `1080p` and `tablet` — map onto their
+ * closest current equivalents so an editor open across the upgrade doesn't
+ * land on the default.
+ */
+const LEGACY_IDS: Record<string, BreakpointId> = {
+  '1080p': 'laptop', // was 1440 — same width, renamed
+  tablet: 'tabletP', // was 768 — same width, split into landscape/portrait
+}
+
+export function coerceBreakpointId(value: unknown): BreakpointId {
+  if (typeof value !== 'string') return DEFAULT_BREAKPOINT
+  if (BY_ID.has(value as BreakpointId)) return value as BreakpointId
+  return LEGACY_IDS[value] ?? DEFAULT_BREAKPOINT
+}
+
+export type Zoom = 'fit' | 1
+
+/**
+ * Scale factor for the canvas transform.
+ *
+ * `available` must come from a zero-height sentinel measured inside the canvas
+ * panel — NOT from `panel.clientWidth - padding`. The two disagree whenever the
+ * host scales the preview or a scrollbar appears, and the padding arithmetic is
+ * the kind that silently rots when the gutter changes.
+ *
+ * Never scales above 1: a 390px mobile canvas blown up to fill a 1200px column
+ * would show text at 3× the size the visitor sees.
+ */
+export function fitScale(available: number, width: number, zoom: Zoom = 'fit'): number {
+  if (zoom !== 'fit') return 1
+  if (!Number.isFinite(available) || available <= 0 || width <= 0) return 1
+  return Math.min(1, available / width)
+}

package/src/lib/canvas-edit-chrome.ts

@@ -0,0 +1,82 @@
+/**
+ * Shared edit affordances for the page/post canvas and Site preview iframe.
+ *
+ * Structure canvas: section hover is styled in `theme.css` under `.prenta-canvas`.
+ * Site preview: the same field chrome is injected into the iframe document when
+ * same-origin (CMS-host preview) so consumers get hover borders without shipping CSS.
+ */
+
+/** localStorage key for the dismissible canvas tip. */
+export const CANVAS_EDIT_TIP_STORAGE_KEY = 'prenta.canvasEditTip.dismissed'
+
+/**
+ * CSS injected into the Site preview iframe while editing is enabled.
+ * Uses system colors so it works without admin theme tokens in the iframe.
+ */
+export const PREVIEW_EDITABLE_FIELD_CHROME_CSS = `
+/* Prenta Site preview — editable field hover chrome (injected by @prenta/admin) */
+[data-cms-field] {
+  outline: 1px solid transparent;
+  outline-offset: 2px;
+  border-radius: 2px;
+  transition: outline-color 120ms ease;
+  cursor: text;
+}
+[data-cms-field]:hover,
+[data-cms-field]:focus,
+[data-cms-field]:focus-within {
+  outline-color: color-mix(in oklab, CanvasText 24%, transparent);
+}
+[data-cms-field][data-cms-field-kind="media"] {
+  cursor: pointer;
+}
+[data-cms-field][data-cms-field-kind="media"]:hover,
+[data-cms-field][data-cms-field-kind="media"]:focus {
+  outline-color: color-mix(in oklab, CanvasText 32%, transparent);
+}
+@media (prefers-reduced-motion: reduce) {
+  [data-cms-field] {
+    transition: none;
+  }
+}
+`.trim()
+
+const STYLE_ATTR = 'data-prenta-edit-chrome'
+
+/**
+ * Inject (or refresh) editable-field hover chrome into a same-origin preview
+ * iframe. No-ops on cross-origin frames (browser blocks contentDocument).
+ */
+export function injectPreviewEditChrome(iframe: HTMLIFrameElement | null): boolean {
+  try {
+    const doc = iframe?.contentDocument
+    if (!doc?.head) return false
+    let style = doc.head.querySelector<HTMLStyleElement>(`style[${STYLE_ATTR}]`)
+    if (!style) {
+      style = doc.createElement('style')
+      style.setAttribute(STYLE_ATTR, '1')
+      doc.head.appendChild(style)
+    }
+    style.textContent = PREVIEW_EDITABLE_FIELD_CHROME_CSS
+    doc.documentElement.setAttribute('data-prenta-preview-editing', 'true')
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function isCanvasEditTipDismissed(): boolean {
+  try {
+    return localStorage.getItem(CANVAS_EDIT_TIP_STORAGE_KEY) === '1'
+  } catch {
+    return false
+  }
+}
+
+export function dismissCanvasEditTip(): void {
+  try {
+    localStorage.setItem(CANVAS_EDIT_TIP_STORAGE_KEY, '1')
+  } catch {
+    /* private mode — tip will reappear next session */
+  }
+}

package/src/lib/media-format.ts

@@ -0,0 +1,99 @@
+/**
+ * Presentation helpers for the media block.
+ *
+ * Pure, because these are the parts with real logic — the rest of the block is
+ * layout. Ported from the design prototype so the labels an editor reads match
+ * the ones the design specifies.
+ */
+
+/** The crop the template renders an image at. Drives the frame's aspect ratio. */
+export type MediaCrop = 'section' | 'social'
+
+/**
+ * Aspect ratio per crop, as a CSS `aspect-ratio` value.
+ *
+ * The frame shows the crop the TEMPLATE renders, not the asset's own ratio.
+ * Showing the asset's ratio would tell an editor their portrait photo is fine
+ * and then crop its subject out on the page.
+ */
+export const CROP_RATIO: Record<MediaCrop, string> = {
+  section: '16 / 10',
+  social: '1.91 / 1',
+}
+
+/** Named ratios an editor recognises, nearest-match within a tolerance. */
+const KNOWN_RATIOS: Array<[number, string]> = [
+  [1.91, '1.91:1'],
+  [16 / 9, '16:9'],
+  [1.5, '3:2'],
+  [4 / 3, '4:3'],
+  [1, '1:1'],
+  [0.8, '4:5'],
+  [9 / 16, '9:16'],
+]
+
+/**
+ * Human ratio for an asset's intrinsic dimensions.
+ *
+ * Snaps to a named ratio when within 0.05, else reports the number. The
+ * tolerance matters: a 2400×1600 photo is 1.5 exactly, but a 2401×1600 scan is
+ * 1.5006 and an editor should still read "3:2" rather than "1.50:1".
+ *
+ * Returns null when dimensions are unknown — the library does not always have
+ * them, and inventing "1.00:1" would be worse than saying nothing.
+ */
+export function ratioLabel(width?: number, height?: number): string | null {
+  if (!width || !height || width <= 0 || height <= 0) return null
+  const r = width / height
+  const best = KNOWN_RATIOS.reduce((a, b) => (Math.abs(b[0] - r) < Math.abs(a[0] - r) ? b : a))
+  return Math.abs(best[0] - r) < 0.05 ? best[1] : `${r.toFixed(2)}:1`
+}
+
+/**
+ * Short format badge — the file extension, uppercased.
+ *
+ * Falls back to the MIME subtype so a URL with no extension (a signed CDN link,
+ * an upload route) still shows something meaningful rather than a blank chip.
+ */
+export function formatBadge(filenameOrUrl: string, mimeType?: string): string {
+  const path = filenameOrUrl.split(/[?#]/)[0] ?? ''
+  const segment = path.split('/').pop() ?? ''
+  // Only a segment that actually contains a dot has an extension. Comparing
+  // against the whole path instead of the segment let a dotless filename —
+  // which is what signed CDN links look like — read as its own extension.
+  const ext = segment.includes('.') ? (segment.split('.').pop() ?? '') : ''
+  if (ext && ext.length <= 5 && /^[a-z0-9]+$/i.test(ext)) {
+    return ext.toUpperCase()
+  }
+  const sub = mimeType?.split('/')[1]
+  return sub ? sub.split('+')[0]!.toUpperCase() : 'FILE'
+}
+
+/**
+ * Filename for display, from a filename or a URL.
+ *
+ * Query strings are dropped — a signed URL's token is noise in a 200px-wide
+ * toolbar, and it is never what an editor is trying to read.
+ */
+export function displayName(filenameOrUrl: string): string {
+  const path = filenameOrUrl.split(/[?#]/)[0] ?? ''
+  return decodeURIComponent(path.split('/').pop() ?? '') || filenameOrUrl
+}
+
+/**
+ * A stable background tint for an asset.
+ *
+ * The design fills the frame with a wash derived from the asset's dominant
+ * colour. The media library stores no such value, so it is derived from the
+ * name instead: the same asset is always the same colour, which is the property
+ * that actually matters for recognising a thumbnail, and it costs no storage
+ * and no extra request.
+ *
+ * Returned as a 135° gradient to the design's `color-mix(tint 45%, #fff)`.
+ */
+export function assetWash(seed: string): string {
+  let hash = 0
+  for (let i = 0; i < seed.length; i++) hash = (hash * 31 + seed.charCodeAt(i)) % 360
+  const tint = `oklch(0.88 0.06 ${hash})`
+  return `linear-gradient(135deg, ${tint}, color-mix(in srgb, ${tint} 45%, #fff))`
+}

package/src/lib/page-audit-input.ts

@@ -0,0 +1,104 @@
+import { resolveRenderedMetaTitle } from '@prenta/core/client'
+import type { PageSection } from '@prenta/core/page-sections'
+import type { PageAuditInput } from '@prenta/core/seo/page-audit'
+import type { SeoContentRecord } from './seo-service.js'
+
+/**
+ * One place that turns editor state into `PageAuditInput`.
+ *
+ * Two callers build the audit and their numbers must agree:
+ *
+ *   - the page editor, from the SAVED record, so the header chip and rail dot
+ *     have a score from first paint rather than after someone opens a tab;
+ *   - the SEO pane, from LIVE form state, so the score moves as you type.
+ *
+ * They differ only in where the metadata comes from — saved versus unsaved —
+ * which is exactly the difference an editor expects to see. Everything else
+ * (which fields feed which check, how the title is rendered, what counts as
+ * unknown) is decided here once. Two hand-written copies of this mapping is how
+ * the editor ended up showing three different scores in the first place.
+ */
+export interface AuditMetaSource {
+  /** Page-level meta title, before the site title template is applied. */
+  metaTitle: string
+  metaDescription: string
+  focusKeyword: string
+  structuredDataType: string
+  noindex: boolean
+  /** `nosnippet` — blocks AI Overview and chat citations outright. */
+  nosnippet: boolean
+  /** `NEVER` excludes the page from llms.txt. */
+  llmsInclude: string
+  /** True when an OG image is set — dimensions are not stored, see below. */
+  hasOgImage: boolean
+}
+
+export interface BuildAuditInputArgs {
+  sections: PageSection[]
+  meta: AuditMetaSource
+  slug: string
+  /** Document title and site template, for the rendered `<title>`. */
+  record: Pick<SeoContentRecord, 'title' | 'siteName' | 'titleTemplate' | 'url'> | null
+  /** Fallback title when there is no saved record yet. */
+  fallbackTitle?: string
+}
+
+export function buildPageAuditInput({
+  sections,
+  meta,
+  slug,
+  record,
+  fallbackTitle,
+}: BuildAuditInputArgs): PageAuditInput {
+  // Measure the title a searcher actually sees — the page meta title with the
+  // site's template applied — not the raw field. Checking the raw field would
+  // give length advice that contradicts the rendered result.
+  const renderedTitle = record
+    ? resolveRenderedMetaTitle({
+        metaTitlePage: meta.metaTitle,
+        documentTitle: record.title,
+        site: {
+          siteName: record.siteName ?? undefined,
+          titleTemplate: record.titleTemplate ?? undefined,
+        },
+      })
+    : meta.metaTitle.trim() || fallbackTitle || ''
+
+  return {
+    sections,
+    seo: {
+      title: renderedTitle,
+      description: meta.metaDescription,
+      slug: slug || record?.url?.split('/').filter(Boolean).pop() || '',
+      keyword: meta.focusKeyword,
+      schema: meta.structuredDataType,
+      // `undefined` (unknown) when an image is set: the record stores a URL
+      // with no dimensions, and the check needs width and ratio. `null` when
+      // none is set, which is a genuine absence and correctly fails.
+      ogImage: meta.hasOgImage ? undefined : null,
+      robots: {
+        index: !meta.noindex,
+        snippet: !meta.nosnippet,
+      },
+    },
+    llmsTxt: meta.llmsInclude !== 'NEVER',
+    // Not resolved in the editor yet; both report not-applicable rather than
+    // failing an editor for a gap in the plumbing.
+    brand: '',
+    author: undefined,
+  }
+}
+
+/** Meta source from a saved SEO record. */
+export function metaFromRecord(record: SeoContentRecord): AuditMetaSource {
+  return {
+    metaTitle: record.metaTitlePage ?? '',
+    metaDescription: record.metaDescription ?? '',
+    focusKeyword: record.focusKeyword ?? '',
+    structuredDataType: record.structuredDataType ?? 'WebPage',
+    noindex: record.noindex,
+    nosnippet: record.nosnippet ?? false,
+    llmsInclude: record.llmsInclude ?? 'AUTO',
+    hasOgImage: Boolean(record.ogImage),
+  }
+}

package/src/lib/page-editor-service.ts

@@ -79,6 +79,18 @@ export interface EditorPage {
   updatedAt: string | null
   scheduledAt: string | null
   scheduledUnpublishAt: string | null
+  /**
+   * Displayed byline. Read by `composePageMeta` into the page's structured
+   * data, so this is a real output and not decoration.
+   *
+   * Deliberately separate from the document's `createdById`, which the API
+   * never reassigns. That field records who created the record — provenance —
+   * and overwriting it to change a displayed name would trade an audit trail
+   * for a label.
+   */
+  authorName: string
+  /** CMS user behind the byline, when it is one. Empty for generic/guest. */
+  authorId: string
   /**
    * True when the document was authored in the visual Page Builder (it carries
    * a `_layout` tree). Such a page's `sections` are *compiled* from the layout
@@ -215,6 +227,8 @@ function rowToEditorPage(doc: DocumentApiRow): EditorPage {
     updatedAt: doc.updatedAt ?? null,
     scheduledAt: doc.scheduledAt ?? null,
     scheduledUnpublishAt: doc.scheduledUnpublishAt ?? null,
+    authorName: typeof data.authorName === 'string' ? data.authorName : '',
+    authorId: typeof data.authorId === 'string' ? data.authorId : '',
     builderOwned,
   }
 }
@@ -254,6 +268,8 @@ function toWriteBody(page: EditorPage, extra?: Record<string, unknown>): string
     sections: page.sections.map(({ unmanaged: _unmanaged, ...rest }) => rest),
     metaTitle: page.seoTitle,
     metaDescription: page.seoDescription,
+    authorName: page.authorName,
+    authorId: page.authorId,
     ...extra,
   }
   return JSON.stringify(payload)
@@ -312,6 +328,8 @@ export function emptyPage(parentPageId: string | null = null): EditorPage {
     updatedAt: null,
     scheduledAt: null,
     scheduledUnpublishAt: null,
+    authorName: '',
+    authorId: '',
     builderOwned: false,
   }
 }

package/src/lib/page-redirect.ts

@@ -0,0 +1,60 @@
+import { cmsApi } from './api.js'
+
+/**
+ * The 301 an editor owes the web when a published page moves.
+ *
+ * ── Why this is offered rather than assumed ───────────────────────────────
+ *
+ * Changing the slug of a page that is already live breaks every inbound link
+ * to it — search results, other sites, someone's bookmarks — and the CMS is the
+ * only party that knows the old address. Leaving the editor to remember it
+ * afterwards means the 404s are discovered by visitors.
+ *
+ * It is offered rather than created silently because a redirect is a public,
+ * durable artifact: it outlives the page, and a wrong one is harder to notice
+ * than a missing one. The editor sees `old → new` and decides.
+ */
+export interface SlugChange {
+  from: string
+  to: string
+}
+
+/**
+ * The move worth redirecting, or `null`.
+ *
+ * `null` when the page has never been live (nothing out there points at the old
+ * path), when the path is unchanged, or when either side is empty — a redirect
+ * from or to nothing is not a redirect, and posting one would put a broken rule
+ * in a table that runs on every request.
+ */
+export function pendingSlugChange(
+  publishedPath: string | null,
+  currentPath: string,
+): SlugChange | null {
+  const from = (publishedPath ?? '').trim()
+  const to = currentPath.trim()
+  if (!from || !to || from === to) return null
+  return { from, to }
+}
+
+/**
+ * Create the 301.
+ *
+ * Failure is reported, never swallowed. The page has already moved by the time
+ * this runs, so a silently-failed redirect leaves exactly the broken links the
+ * switch promised to prevent — and the editor would have no reason to suspect
+ * it.
+ */
+export async function createPublishRedirect(change: SlugChange): Promise<{ error?: string }> {
+  const res = await cmsApi('/redirects', {
+    method: 'POST',
+    body: JSON.stringify({
+      source: change.from,
+      destination: change.to,
+      statusCode: 301,
+      source_kind: 'manual',
+      notes: 'Created automatically when the page slug changed on publish.',
+    }),
+  })
+  return res.error ? { error: res.error } : {}
+}

package/src/lib/rail-width.ts

@@ -0,0 +1,58 @@
+/**
+ * Editor rail sizing — pure logic, no DOM, so the clamping and persistence
+ * rules are testable without mounting a resizable panel.
+ */
+
+export const RAIL_MIN_WIDTH = 300
+export const RAIL_MAX_WIDTH = 620
+export const RAIL_DEFAULT_WIDTH = 360
+
+/** Width of the strip that replaces the rail when it is collapsed. */
+export const RAIL_COLLAPSED_WIDTH = 38
+
+export const RAIL_WIDTH_STORAGE_KEY = 'pb.panelW'
+
+/** Constrain a candidate width to the rail's range, rejecting junk. */
+export function clampRailWidth(width: number): number {
+  if (!Number.isFinite(width)) return RAIL_DEFAULT_WIDTH
+  return Math.min(RAIL_MAX_WIDTH, Math.max(RAIL_MIN_WIDTH, Math.round(width)))
+}
+
+/**
+ * Read the persisted width. Anything unreadable — no storage, a value written
+ * by an older build, a user editing localStorage — falls back to the default
+ * rather than throwing or producing a broken layout.
+ *
+ * Storage access is wrapped: Safari in private mode throws on `getItem`, and a
+ * rail that cannot size itself must not take down the editor.
+ */
+export function readRailWidth(storage?: Pick<Storage, 'getItem'>): number {
+  const store = storage ?? safeStorage()
+  if (!store) return RAIL_DEFAULT_WIDTH
+  try {
+    const raw = store.getItem(RAIL_WIDTH_STORAGE_KEY)
+    if (raw === null) return RAIL_DEFAULT_WIDTH
+    const parsed = Number.parseInt(raw, 10)
+    return Number.isNaN(parsed) ? RAIL_DEFAULT_WIDTH : clampRailWidth(parsed)
+  } catch {
+    return RAIL_DEFAULT_WIDTH
+  }
+}
+
+export function writeRailWidth(width: number, storage?: Pick<Storage, 'setItem'>): void {
+  const store = storage ?? safeStorage()
+  if (!store) return
+  try {
+    store.setItem(RAIL_WIDTH_STORAGE_KEY, String(clampRailWidth(width)))
+  } catch {
+    // Quota or private-mode failure. The width still applies for this session.
+  }
+}
+
+function safeStorage(): Storage | null {
+  try {
+    return typeof localStorage === 'undefined' ? null : localStorage
+  } catch {
+    return null
+  }
+}

package/src/lib/reflow-baseline.ts

@@ -0,0 +1,70 @@
+import type { PageSection } from '@prenta/core/page-sections'
+
+/**
+ * The content a page's sections had when they were last live.
+ *
+ * ── What "baseline" means here, and why ───────────────────────────────────
+ *
+ * The guard answers "will this edit change how the live page wraps?" — so the
+ * baseline has to be what is actually on the site, not what was last saved.
+ *
+ * This CMS has no draft/published split: a document carries one `status` and
+ * saving a PUBLISHED page updates the live content in place. So for a published
+ * page the live content is whatever the editor loaded, refreshed on every save
+ * and publish. For a page that has never been published there is no baseline at
+ * all, and the guard reports line counts without deltas — correctly, because
+ * there is no live layout to break.
+ *
+ * Deliberately NOT sourced from the versions API. Versions do hold full
+ * snapshots, but they record every update, so finding "the published one" means
+ * scanning history and guessing which entry was live — an extra request and a
+ * heuristic, to reconstruct something the editor already has in hand.
+ */
+export interface ReflowBaseline {
+  byId: Map<string, Record<string, unknown>>
+}
+
+/**
+ * Snapshot section content, or `null` when the page is not live.
+ *
+ * `null` rather than an empty snapshot: an empty baseline would read as "every
+ * field was previously blank" and flag every line of existing copy as newly
+ * added.
+ */
+export function snapshotBaseline(
+  sections: readonly PageSection[],
+  status: string,
+): ReflowBaseline | null {
+  if (status !== 'PUBLISHED') return null
+  return {
+    byId: new Map(sections.map((s) => [s.id, { ...(s.content ?? {}) }])),
+  }
+}
+
+/**
+ * Resolve a `data-cms-field` path against a baseline.
+ *
+ * Paths are dotted and may index arrays (`stats.0.label`), matching the markers
+ * the renderers emit.
+ *
+ * Returns `undefined` for anything that is not baseline text — no snapshot, a
+ * section added since publish, a field that did not exist, or a non-string
+ * value. The guard reads `undefined` as "nothing to compare against" and
+ * reports no delta, which is the truthful answer in every one of those cases.
+ */
+export function baselineFieldText(
+  baseline: ReflowBaseline | null,
+  sectionId: string,
+  fieldPath: string,
+): string | undefined {
+  const content = baseline?.byId.get(sectionId)
+  if (!content) return undefined
+
+  let cursor: unknown = content
+  for (const key of fieldPath.split('.')) {
+    if (cursor === null || typeof cursor !== 'object') return undefined
+    cursor = (cursor as Record<string, unknown>)[key]
+  }
+
+  return typeof cursor === 'string' ? cursor : undefined
+}