@open-mercato/core 0.8.1-develop.7296.1.2111d779db → 0.8.1-develop.7441.1.b42958b98c

package/src/modules/forms/schema/layout-catalog.ts

@@ -0,0 +1,68 @@
+/**
+ * Layout palette catalog.
+ *
+ * Layout palette entries are studio-only — they don't register as field
+ * types and never appear in `properties`. The catalog is a sibling to
+ * `FieldTypeRegistry` so the compiler can keep rejecting unknown
+ * `x-om-type` values on real fields while the studio enumerates the
+ * `Page` and `Section/Group` palette cards from a single source.
+ *
+ * Decision 1 (`.ai/specs/2026-05-10-forms-visual-builder.md`): "Grid" is
+ * not a separate primitive. Multi-column layouts are a section with
+ * `columns >= 2`.
+ *
+ * Pack-registered layout entries (Decisions 16a/16b) take a different
+ * shape: they go through `FieldTypeRegistry.register({ category: 'layout' })`
+ * and persist as fields in `properties` — the registry asserts the
+ * display-only contract (`validator(undefined) === true`,
+ * `exportAdapter(undefined) === ''`) at register time. This catalog stays
+ * limited to `kind: 'page' | 'section'` boundary entries.
+ */
+
+import type { OmSectionKind } from './jsonschema-extensions'
+
+export type LayoutCatalogEntry = {
+  id: string
+  kind: OmSectionKind
+  icon: string
+  displayNameKey: string
+}
+
+const PAGE_ENTRY: LayoutCatalogEntry = {
+  id: 'page',
+  kind: 'page',
+  icon: 'file-text',
+  displayNameKey: 'forms.studio.palette.layout.page',
+}
+
+const SECTION_ENTRY: LayoutCatalogEntry = {
+  id: 'section',
+  kind: 'section',
+  icon: 'rows',
+  displayNameKey: 'forms.studio.palette.layout.section',
+}
+
+const ENDING_ENTRY: LayoutCatalogEntry = {
+  id: 'ending',
+  kind: 'ending',
+  icon: 'flag',
+  displayNameKey: 'forms.studio.palette.layout.ending',
+}
+
+export const layoutCatalogEntries: ReadonlyArray<LayoutCatalogEntry> = [
+  PAGE_ENTRY,
+  SECTION_ENTRY,
+  ENDING_ENTRY,
+]
+
+const ENTRIES_BY_ID = new Map<string, LayoutCatalogEntry>(
+  layoutCatalogEntries.map((entry) => [entry.id, entry]),
+)
+
+export function getLayoutCatalogEntry(id: string): LayoutCatalogEntry | undefined {
+  return ENTRIES_BY_ID.get(id)
+}
+
+export function listLayoutCatalogEntries(): ReadonlyArray<LayoutCatalogEntry> {
+  return layoutCatalogEntries
+}

package/src/modules/forms/schema/signature-field.ts

@@ -0,0 +1,120 @@
+/**
+ * `signature` field type — W2 (CN-1, FD-4; partial CN-2 / CN-3).
+ *
+ * Captures a patient / signer e-signature with tamper-evident audit data. This
+ * is the defining capability for the consent / legal form category.
+ *
+ * Value shape (stored in the encrypted revision answers — never a side path):
+ *   {
+ *     mode: 'drawn' | 'typed',
+ *     image?: string,        // data URL (PNG) for drawn mode
+ *     typedName?: string,    // for typed mode
+ *     affirmed: true,        // explicit affirmation checkbox must be true
+ *     signedAt: string,      // ISO UTC timestamp (client-captured)
+ *     clauseSha256: string,  // SHA-256 of the exact consent clause text shown
+ *   }
+ *
+ * The signed record = version-pinned schema (`form_version`, immutable once
+ * published) + encrypted answers (incl. this signature payload — append-only,
+ * per-tenant envelope encryption) + submit metadata (IP / UA / UTC ts captured
+ * server-side at submit). Together these form the tamper-evident bundle. Full
+ * PDF reproduction of the signed record is W3.
+ *
+ * The `signature` type is ADDITIVE — registered through the standard
+ * `FieldTypeRegistry.register(...)` API; it does NOT appear in the FROZEN v1
+ * core list (`packages/forms/AGENTS.md § v1 Field Types`).
+ *
+ * New `x-om-*` keywords (all additive, registered in `jsonschema-extensions.ts`):
+ *   - `x-om-consent-clause` — `{ [locale]: string }` legal statement shown above
+ *     the signature area (the text whose SHA-256 the signer affirms).
+ *   - `x-om-signature-modes` — `('drawn'|'typed')[]` allowed capture modes
+ *     (default both).
+ */
+
+import type { FieldNode, FieldTypeSpec } from './field-type-registry'
+
+export const SIGNATURE_TYPE_KEY = 'signature' as const
+
+export const SIGNATURE_MODES = ['drawn', 'typed'] as const
+export type SignatureMode = (typeof SIGNATURE_MODES)[number]
+
+/** Value persisted in a `signature`-field answer. */
+export type SignatureValue = {
+  mode: SignatureMode
+  image?: string
+  typedName?: string
+  affirmed: true
+  signedAt: string
+  clauseSha256: string
+}
+
+const SHA256_HEX_PATTERN = /^[a-f0-9]{64}$/
+
+function isSignatureMode(value: unknown): value is SignatureMode {
+  return value === 'drawn' || value === 'typed'
+}
+
+/**
+ * Reads the allowed capture modes for a signature field. Absent / malformed
+ * `x-om-signature-modes` defaults to both modes. Unknown entries are dropped;
+ * an empty result also falls back to both modes (R: never lock a signer out of
+ * every mode through a bad config).
+ */
+export function readSignatureModes(fieldNode: FieldNode): SignatureMode[] {
+  const raw = (fieldNode as Record<string, unknown>)['x-om-signature-modes']
+  if (!Array.isArray(raw)) return [...SIGNATURE_MODES]
+  const modes = raw.filter(isSignatureMode)
+  return modes.length > 0 ? Array.from(new Set(modes)) : [...SIGNATURE_MODES]
+}
+
+export const SIGNATURE_TYPE: FieldTypeSpec = {
+  validator: (value, fieldNode) => {
+    if (value === null || value === undefined) return true
+    if (typeof value !== 'object' || Array.isArray(value)) {
+      return 'Signature must be an object.'
+    }
+    const candidate = value as Record<string, unknown>
+    if (!isSignatureMode(candidate.mode)) {
+      return 'Signature mode must be "drawn" or "typed".'
+    }
+    const allowedModes = readSignatureModes(fieldNode)
+    if (!allowedModes.includes(candidate.mode)) {
+      return `Signature mode "${candidate.mode}" is not allowed for this field.`
+    }
+    if (candidate.affirmed !== true) {
+      return 'You must affirm the consent statement before signing.'
+    }
+    if (typeof candidate.clauseSha256 !== 'string' || !SHA256_HEX_PATTERN.test(candidate.clauseSha256)) {
+      return 'Signature is missing the consent clause fingerprint.'
+    }
+    if (typeof candidate.signedAt !== 'string' || Number.isNaN(Date.parse(candidate.signedAt))) {
+      return 'Signature is missing a valid signed-at timestamp.'
+    }
+    if (candidate.mode === 'drawn') {
+      if (typeof candidate.image !== 'string' || candidate.image.length === 0) {
+        return 'A drawn signature requires a captured image.'
+      }
+    } else {
+      if (typeof candidate.typedName !== 'string' || candidate.typedName.trim().length === 0) {
+        return 'A typed signature requires a name.'
+      }
+    }
+    return true
+  },
+  renderer: null,
+  defaultUiSchema: { widget: 'signature' },
+  exportAdapter: (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return ''
+    const candidate = value as Record<string, unknown>
+    if (!isSignatureMode(candidate.mode)) return ''
+    const signedAt = typeof candidate.signedAt === 'string' ? candidate.signedAt : ''
+    const who =
+      candidate.mode === 'typed' && typeof candidate.typedName === 'string' && candidate.typedName.trim().length > 0
+        ? candidate.typedName.trim()
+        : 'drawn'
+    return signedAt.length > 0 ? `Signed by ${who} on ${signedAt}` : `Signed by ${who}`
+  },
+  category: 'input',
+  icon: 'pen-tool',
+  displayNameKey: 'forms.studio.palette.input.signature',
+}

package/src/modules/forms/schema/style-extensions.ts

@@ -0,0 +1,194 @@
+/**
+ * Forms custom-styling vocabulary (`x-om-theme`, `OmSection.style`, `x-om-style`).
+ *
+ * Styling is end-user *data*, never CSS (security keystone — see
+ * `.ai/specs/2026-05-22-forms-custom-styling.md` D1/D3/R-CS-1). The persisted
+ * vocabulary is a small typed object of enums, integers, and **hex-only** color
+ * strings; there is no member anywhere that accepts a raw CSS declaration,
+ * selector, `url()`, `var()`, `calc()`, `expression()`, or free text. A pure
+ * `style-compiler` (later task) turns a validated style object into a bounded
+ * set of scoped CSS custom properties that remap the existing DS tokens.
+ *
+ * The enum sets exported here are the single source of truth consumed by
+ * `style-validators.ts` (membership checks) and, later, the compiler.
+ */
+
+// ============================================================================
+// Colors (D3)
+// ============================================================================
+
+/** Curated DS-role token — resolves to an existing DS var at compile time. */
+export type OmColorToken =
+  | 'surface'
+  | 'surface-muted'
+  | 'foreground'
+  | 'muted-foreground'
+  | 'accent'
+  | 'border'
+  | 'transparent'
+  | 'inherit'
+
+/** A color: a curated role token OR a strict hex literal. Nothing else (D3). */
+export type OmColor = OmColorToken | `#${string}`
+
+/** Strict hex literal — `#rgb`, `#rrggbb`, or `#rrggbbaa`. No other syntax. */
+export const OM_HEX_COLOR = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/
+
+/** Single source of truth for the curated color tokens. */
+export const OM_COLOR_TOKENS: ReadonlySet<OmColorToken> = new Set<OmColorToken>([
+  'surface',
+  'surface-muted',
+  'foreground',
+  'muted-foreground',
+  'accent',
+  'border',
+  'transparent',
+  'inherit',
+])
+
+// ============================================================================
+// Scales / families / weights / alignment
+// ============================================================================
+
+export type OmSpaceScale = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl'
+export type OmRadiusScale = 'none' | 'sm' | 'md' | 'lg' | 'full'
+export type OmBorderScale = 'none' | 'subtle' | 'strong'
+export type OmFontFamily = 'system' | 'sans' | 'serif' | 'mono' | 'rounded'
+export type OmFontScale = 'sm' | 'md' | 'lg'
+export type OmTextWeight = 'normal' | 'medium' | 'semibold' | 'bold'
+export type OmContentWidth = 'sm' | 'md' | 'lg' | 'full'
+export type OmTextAlign = 'start' | 'center' | 'end'
+
+export const OM_SPACE_SCALE: ReadonlySet<OmSpaceScale> = new Set<OmSpaceScale>([
+  'none',
+  'xs',
+  'sm',
+  'md',
+  'lg',
+  'xl',
+])
+
+export const OM_RADIUS_SCALE: ReadonlySet<OmRadiusScale> = new Set<OmRadiusScale>([
+  'none',
+  'sm',
+  'md',
+  'lg',
+  'full',
+])
+
+export const OM_BORDER_SCALE: ReadonlySet<OmBorderScale> = new Set<OmBorderScale>([
+  'none',
+  'subtle',
+  'strong',
+])
+
+export const OM_FONT_FAMILY: ReadonlySet<OmFontFamily> = new Set<OmFontFamily>([
+  'system',
+  'sans',
+  'serif',
+  'mono',
+  'rounded',
+])
+
+export const OM_FONT_SCALE: ReadonlySet<OmFontScale> = new Set<OmFontScale>(['sm', 'md', 'lg'])
+
+export const OM_TEXT_WEIGHT: ReadonlySet<OmTextWeight> = new Set<OmTextWeight>([
+  'normal',
+  'medium',
+  'semibold',
+  'bold',
+])
+
+export const OM_CONTENT_WIDTH: ReadonlySet<OmContentWidth> = new Set<OmContentWidth>([
+  'sm',
+  'md',
+  'lg',
+  'full',
+])
+
+export const OM_TEXT_ALIGN: ReadonlySet<OmTextAlign> = new Set<OmTextAlign>([
+  'start',
+  'center',
+  'end',
+])
+
+// ============================================================================
+// Background (D6 — color + gradient in v1; image is Phase 2)
+// ============================================================================
+
+export type OmBackgroundKind = 'none' | 'color' | 'gradient'
+
+export const OM_BACKGROUND_KINDS: ReadonlySet<OmBackgroundKind> = new Set<OmBackgroundKind>([
+  'none',
+  'color',
+  'gradient',
+])
+
+export type OmBackground =
+  | { kind: 'none' }
+  | { kind: 'color'; color: OmColor }
+  | { kind: 'gradient'; from: OmColor; to: OmColor; angle: number }
+// Phase 2:
+// | { kind: 'image'; assetId: string; fit?: 'cover' | 'contain'; overlay?: OmColor }
+
+// ============================================================================
+// Three style levels (D4) — root theme, section style, field style
+// ============================================================================
+
+/**
+ * Logo / header image (Phase 2 of the styling spec). The author NEVER supplies a
+ * URL — only `assetId`, the id of an image uploaded through the forms logo route
+ * into the public attachments partition (no SSRF, no author-controlled fetch).
+ * The render seam resolves it to the public image route by id.
+ */
+export type OmLogoSize = 'sm' | 'md' | 'lg'
+
+export const OM_LOGO_SIZE: ReadonlySet<OmLogoSize> = new Set<OmLogoSize>(['sm', 'md', 'lg'])
+
+export type OmThemeLogo = {
+  assetId: string
+  alt?: string
+  align?: OmTextAlign
+  size?: OmLogoSize
+}
+
+/** Root — `x-om-theme`. */
+export type OmTheme = {
+  background?: OmBackground
+  surface?: OmColor
+  /** Body text color (remaps `--foreground`) — general copy, helper text, etc. */
+  foreground?: OmColor
+  /** Form-wide input/textarea/select text color, distinct from body (field `x-om-style.textColor` overrides). */
+  inputText?: OmColor
+  /** Form-wide field-label color, distinct from body text (field `x-om-style.labelColor` overrides). */
+  labelColor?: OmColor
+  /** Form-wide field-label weight (field `x-om-style.labelWeight` overrides). */
+  labelWeight?: OmTextWeight
+  accent?: OmColor
+  border?: OmColor
+  fontFamily?: OmFontFamily
+  fontScale?: OmFontScale
+  radius?: OmRadiusScale
+  contentWidth?: OmContentWidth
+  logo?: OmThemeLogo
+}
+
+/** Section — `OmSection.style`. */
+export type OmSectionStyle = {
+  background?: OmBackground
+  foreground?: OmColor
+  padding?: OmSpaceScale
+  border?: OmBorderScale
+  radius?: OmRadiusScale
+  card?: boolean
+  align?: OmTextAlign
+}
+
+/** Field — `x-om-style`. */
+export type OmFieldStyle = {
+  labelWeight?: OmTextWeight
+  labelColor?: OmColor
+  textColor?: OmColor
+  accent?: OmColor
+  align?: OmTextAlign
+}

package/src/modules/forms/schema/style-validators.ts

@@ -0,0 +1,252 @@
+/**
+ * Strict validators for the forms custom-styling vocabulary
+ * (`x-om-theme`, `OmSection.style`, `x-om-style`).
+ *
+ * Each validator returns the first violation message (a string) or `null` when
+ * the value is valid — mirroring the existing `OM_ROOT_VALIDATORS` /
+ * `OM_FIELD_VALIDATORS` contract in `jsonschema-extensions.ts`.
+ *
+ * Security keystone (D1/D3/R-CS-1): there is no value an author can persist
+ * that becomes an executable/parsed CSS declaration or selector. Colors are
+ * either a curated token or a strict hex literal — no `rgb()`, `hsl()`, named
+ * colors, `url()`, `var()`, `expression()`, or functional syntax. Every object
+ * rejects unknown keys (strict — no passthrough). All validators are pure (no
+ * I/O) and narrow `unknown` without `any`.
+ */
+
+import {
+  OM_BACKGROUND_KINDS,
+  OM_BORDER_SCALE,
+  OM_COLOR_TOKENS,
+  OM_CONTENT_WIDTH,
+  OM_FONT_FAMILY,
+  OM_FONT_SCALE,
+  OM_HEX_COLOR,
+  OM_LOGO_SIZE,
+  OM_RADIUS_SCALE,
+  OM_SPACE_SCALE,
+  OM_TEXT_ALIGN,
+  OM_TEXT_WEIGHT,
+} from './style-extensions'
+
+/** Attachment ids are server-minted UUIDs — the only assetId shape we accept. */
+const OM_ASSET_ID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/
+const LOGO_KEYS: ReadonlySet<string> = new Set(['assetId', 'alt', 'align', 'size'])
+
+type UnknownRecord = Record<string, unknown>
+
+function isPlainObject(value: unknown): value is UnknownRecord {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function unknownKey(candidate: UnknownRecord, allowed: ReadonlySet<string>, scope: string): string | null {
+  for (const key of Object.keys(candidate)) {
+    if (!allowed.has(key)) {
+      return `${scope} has an unknown key "${key}".`
+    }
+  }
+  return null
+}
+
+/**
+ * A color is either a curated DS-role token OR a strict hex literal
+ * (`#rgb`, `#rrggbb`, `#rrggbbaa`). Everything else — `rgb()`, `hsl()`, named
+ * colors, `url()`, `var()`, `expression()`, any functional/parenthesised
+ * syntax — is rejected (D3 / R-CS-1).
+ */
+export function validateOmColor(value: unknown): string | null {
+  if (typeof value !== 'string') {
+    return 'Color must be a curated token or a hex literal string.'
+  }
+  if (OM_COLOR_TOKENS.has(value as never)) return null
+  if (OM_HEX_COLOR.test(value)) return null
+  return 'Color must be a curated token or a strict hex literal (#rgb, #rrggbb, or #rrggbbaa) — no rgb()/hsl()/named/functional syntax.'
+}
+
+const BACKGROUND_KEYS_BY_KIND: Record<string, ReadonlySet<string>> = {
+  none: new Set(['kind']),
+  color: new Set(['kind', 'color']),
+  gradient: new Set(['kind', 'from', 'to', 'angle']),
+}
+
+export function validateOmBackground(value: unknown): string | null {
+  if (!isPlainObject(value)) {
+    return 'Background must be an object with a `kind` discriminator.'
+  }
+  const kind = value.kind
+  if (typeof kind !== 'string' || !OM_BACKGROUND_KINDS.has(kind as never)) {
+    return 'Background `kind` must be "none", "color", or "gradient".'
+  }
+  const unknown = unknownKey(value, BACKGROUND_KEYS_BY_KIND[kind], `Background (kind "${kind}")`)
+  if (unknown) return unknown
+
+  if (kind === 'none') {
+    return null
+  }
+  if (kind === 'color') {
+    const colorMessage = validateOmColor(value.color)
+    if (colorMessage) return `Background color: ${colorMessage}`
+    return null
+  }
+  // gradient
+  const fromMessage = validateOmColor(value.from)
+  if (fromMessage) return `Background gradient from: ${fromMessage}`
+  const toMessage = validateOmColor(value.to)
+  if (toMessage) return `Background gradient to: ${toMessage}`
+  const angle = value.angle
+  if (typeof angle !== 'number' || !Number.isInteger(angle) || angle < 0 || angle > 360) {
+    return 'Background gradient `angle` must be an integer in [0, 360].'
+  }
+  return null
+}
+
+function validateEnumMember(
+  candidate: UnknownRecord,
+  key: string,
+  allowed: ReadonlySet<string>,
+  label: string,
+): string | null {
+  if (candidate[key] === undefined) return null
+  const member = candidate[key]
+  if (typeof member !== 'string' || !allowed.has(member)) {
+    return `${label} must be one of ${[...allowed].map((entry) => `"${entry}"`).join(', ')}.`
+  }
+  return null
+}
+
+function validateColorMember(candidate: UnknownRecord, key: string, label: string): string | null {
+  if (candidate[key] === undefined) return null
+  const message = validateOmColor(candidate[key])
+  if (message) return `${label}: ${message}`
+  return null
+}
+
+function validateBackgroundMember(candidate: UnknownRecord, key: string, label: string): string | null {
+  if (candidate[key] === undefined) return null
+  const message = validateOmBackground(candidate[key])
+  if (message) return `${label}: ${message}`
+  return null
+}
+
+const THEME_KEYS: ReadonlySet<string> = new Set([
+  'background',
+  'surface',
+  'foreground',
+  'inputText',
+  'labelColor',
+  'labelWeight',
+  'accent',
+  'border',
+  'fontFamily',
+  'fontScale',
+  'radius',
+  'contentWidth',
+  'logo',
+])
+
+/**
+ * `logo` carries only an attachment id + display hints — never a URL or raw
+ * text that reaches the DOM unescaped. `assetId` must be a UUID (a server-minted
+ * attachment id); `alt` is a bounded plain string; `align`/`size` are fixed
+ * enums; unknown keys are rejected (D4 / R-CS-1).
+ */
+export function validateOmThemeLogo(value: unknown): string | null {
+  if (!isPlainObject(value)) {
+    return 'x-om-theme.logo must be an object.'
+  }
+  const unknown = unknownKey(value, LOGO_KEYS, 'x-om-theme.logo')
+  if (unknown) return unknown
+  if (typeof value.assetId !== 'string' || !OM_ASSET_ID.test(value.assetId)) {
+    return 'x-om-theme.logo.assetId must be an uploaded image id (UUID).'
+  }
+  if (value.alt !== undefined && (typeof value.alt !== 'string' || value.alt.length > 300)) {
+    return 'x-om-theme.logo.alt must be a string of at most 300 characters.'
+  }
+  return (
+    validateEnumMember(value, 'align', OM_TEXT_ALIGN, 'x-om-theme.logo.align')
+    || validateEnumMember(value, 'size', OM_LOGO_SIZE, 'x-om-theme.logo.size')
+  )
+}
+
+export function validateOmTheme(value: unknown): string | null {
+  if (!isPlainObject(value)) {
+    return 'x-om-theme must be an object.'
+  }
+  const unknown = unknownKey(value, THEME_KEYS, 'x-om-theme')
+  if (unknown) return unknown
+
+  return (
+    validateBackgroundMember(value, 'background', 'x-om-theme.background')
+    || validateColorMember(value, 'surface', 'x-om-theme.surface')
+    || validateColorMember(value, 'foreground', 'x-om-theme.foreground')
+    || validateColorMember(value, 'inputText', 'x-om-theme.inputText')
+    || validateColorMember(value, 'labelColor', 'x-om-theme.labelColor')
+    || validateEnumMember(value, 'labelWeight', OM_TEXT_WEIGHT, 'x-om-theme.labelWeight')
+    || validateColorMember(value, 'accent', 'x-om-theme.accent')
+    || validateColorMember(value, 'border', 'x-om-theme.border')
+    || validateEnumMember(value, 'fontFamily', OM_FONT_FAMILY, 'x-om-theme.fontFamily')
+    || validateEnumMember(value, 'fontScale', OM_FONT_SCALE, 'x-om-theme.fontScale')
+    || validateEnumMember(value, 'radius', OM_RADIUS_SCALE, 'x-om-theme.radius')
+    || validateEnumMember(value, 'contentWidth', OM_CONTENT_WIDTH, 'x-om-theme.contentWidth')
+    || (value.logo !== undefined ? validateOmThemeLogo(value.logo) : null)
+  )
+}
+
+const SECTION_STYLE_KEYS: ReadonlySet<string> = new Set([
+  'background',
+  'foreground',
+  'padding',
+  'border',
+  'radius',
+  'card',
+  'align',
+])
+
+export function validateOmSectionStyle(value: unknown): string | null {
+  if (!isPlainObject(value)) {
+    return 'Section `style` must be an object.'
+  }
+  const unknown = unknownKey(value, SECTION_STYLE_KEYS, 'Section `style`')
+  if (unknown) return unknown
+
+  const backgroundMessage = validateBackgroundMember(value, 'background', 'Section style.background')
+  if (backgroundMessage) return backgroundMessage
+  const foregroundMessage = validateColorMember(value, 'foreground', 'Section style.foreground')
+  if (foregroundMessage) return foregroundMessage
+  const paddingMessage = validateEnumMember(value, 'padding', OM_SPACE_SCALE, 'Section style.padding')
+  if (paddingMessage) return paddingMessage
+  const borderMessage = validateEnumMember(value, 'border', OM_BORDER_SCALE, 'Section style.border')
+  if (borderMessage) return borderMessage
+  const radiusMessage = validateEnumMember(value, 'radius', OM_RADIUS_SCALE, 'Section style.radius')
+  if (radiusMessage) return radiusMessage
+  if (value.card !== undefined && typeof value.card !== 'boolean') {
+    return 'Section style.card must be a boolean when present.'
+  }
+  const alignMessage = validateEnumMember(value, 'align', OM_TEXT_ALIGN, 'Section style.align')
+  if (alignMessage) return alignMessage
+  return null
+}
+
+const FIELD_STYLE_KEYS: ReadonlySet<string> = new Set([
+  'labelWeight',
+  'labelColor',
+  'textColor',
+  'accent',
+  'align',
+])
+
+export function validateOmFieldStyle(value: unknown): string | null {
+  if (!isPlainObject(value)) {
+    return 'x-om-style must be an object.'
+  }
+  const unknown = unknownKey(value, FIELD_STYLE_KEYS, 'x-om-style')
+  if (unknown) return unknown
+
+  return (
+    validateEnumMember(value, 'labelWeight', OM_TEXT_WEIGHT, 'x-om-style.labelWeight')
+    || validateColorMember(value, 'labelColor', 'x-om-style.labelColor')
+    || validateColorMember(value, 'textColor', 'x-om-style.textColor')
+    || validateColorMember(value, 'accent', 'x-om-style.accent')
+    || validateEnumMember(value, 'align', OM_TEXT_ALIGN, 'x-om-style.align')
+  )
+}