@crombolo/schema 0.0.0-stage → 0.10.0

package/src/model.ts

@@ -0,0 +1,156 @@
+import type { SchemaForm } from '@crombolo/core'
+
+/**
+ * The schema-as-code model: what a site's `schema/*.toml` files describe.
+ * The shapes mirror the TOML vocabulary in docs/schema-as-code.md, with
+ * defaults applied, so the rest of the system never sees a missing key.
+ */
+export interface SchemaProperty {
+  key?: string
+  alias: string
+  name: string
+  description?: string
+  notes?: string
+  /** A data type alias, built in or defined in `schema/data-types/`. */
+  type: string
+  mandatory: boolean
+  mandatoryMessage?: string
+  regex?: string
+  regexMessage?: string
+  variesByCulture: boolean
+  variesBySegment: boolean
+  labelOnTop: boolean
+  /** Member types only: shown to the member on their profile. */
+  memberCanView?: boolean
+  /** Member types only: editable by the member on their profile. */
+  memberCanEdit?: boolean
+  /** Member types only: hidden from users without sensitive-data access. */
+  sensitive?: boolean
+  /** Fills existing content when a required property is added to a type with pages. */
+  default?: unknown
+  since?: string
+}
+
+export interface SchemaGroup {
+  name: string
+  alias?: string
+  properties: SchemaProperty[]
+}
+
+export interface SchemaTab {
+  name: string
+  alias?: string
+  properties: SchemaProperty[]
+  groups: SchemaGroup[]
+}
+
+export interface SchemaCleanup {
+  prevent: boolean
+  keepAllNewerThanDays?: number
+  keepLatestPerDayForDays?: number
+}
+
+export interface SchemaContentType {
+  key?: string
+  alias: string
+  name: string
+  description?: string
+  notes?: string
+  icon: string
+  allowAtRoot: boolean
+  isElement: boolean
+  allowInLibrary: boolean
+  variesByCulture: boolean
+  variesBySegment: boolean
+  compositions: string[]
+  allowChildren: string[]
+  components: string[]
+  defaultComponent?: string
+  collection?: string
+  /** Tree placement in the backoffice, `A/B`; not part of the type's meaning. */
+  folder?: string
+  cleanup: SchemaCleanup
+  since?: string
+  /** Properties outside any tab. */
+  properties: SchemaProperty[]
+  /** Groups outside any tab — `[[group]]`; Umbraco's built-in media types use one. */
+  groups?: SchemaGroup[]
+  tabs: SchemaTab[]
+}
+
+export interface SchemaDataType {
+  key?: string
+  alias: string
+  name: string
+  notes?: string
+  editor: string
+  editorUi?: string
+  folder?: string
+  config: Record<string, unknown>
+  since?: string
+}
+
+export interface SchemaLanguage {
+  iso: string
+  name: string
+  default: boolean
+  mandatory: boolean
+  fallback?: string
+}
+
+export interface SchemaSet {
+  /** From schema/schema.toml; "0" when the file is absent. */
+  version: string
+  contentTypes: SchemaContentType[]
+  /** `schema/media-types/*.toml`: the same vocabulary under `[media-type]`, without templates or cleanup. */
+  mediaTypes?: SchemaContentType[]
+  /** `schema/member-types/*.toml`: under `[member-type]`, no templates, cleanup or allowed children. */
+  memberTypes?: SchemaContentType[]
+  dataTypes: SchemaDataType[]
+  languages: SchemaLanguage[]
+  /** `schema/forms/*.toml` — form definitions; see `docs/forms.md`. */
+  forms?: SchemaForm[]
+}
+
+/** A problem found while parsing or validating, always locatable. */
+export interface SchemaProblem {
+  file: string
+  /** A dotted path into the file, e.g. `tab[1].property[0].type`. */
+  path: string
+  message: string
+}
+
+/** Which kind of content type a file defines. */
+export type SchemaTypeKind = 'document' | 'media' | 'member'
+
+/** The table header and directory for each kind. */
+export const TYPE_KIND_FILES: Record<SchemaTypeKind, { header: string; dir: string }> = {
+  document: { header: 'content-type', dir: 'content-types' },
+  media: { header: 'media-type', dir: 'media-types' },
+  member: { header: 'member-type', dir: 'member-types' },
+}
+
+/** The files-map key for a type: content types by bare alias, others prefixed. */
+export function typeFileKey(kind: SchemaTypeKind, alias: string): string {
+  return kind === 'document' ? alias : `${TYPE_KIND_FILES[kind].header}:${alias}`
+}
+
+export class SchemaError extends Error {
+  constructor(readonly problems: SchemaProblem[]) {
+    super(
+      `${problems.length} schema problem${problems.length === 1 ? '' : 's'}:\n` +
+        problems.map((p) => `  ${p.file}: ${p.path ? `${p.path}: ` : ''}${p.message}`).join('\n'),
+    )
+  }
+}
+
+/** Every property of a type, including tabbed and grouped ones, in editor order. */
+export function allProperties(type: SchemaContentType): SchemaProperty[] {
+  const out = [...type.properties]
+  for (const group of type.groups ?? []) out.push(...group.properties)
+  for (const tab of type.tabs) {
+    out.push(...tab.properties)
+    for (const group of tab.groups) out.push(...group.properties)
+  }
+  return out
+}

package/src/parse-forms.ts

@@ -0,0 +1,229 @@
+/**
+ * TOML → a form definition. Strict in the same way as the type parser: an
+ * unknown key is an error, because a misspelt one hides what someone meant.
+ *
+ * Separate from `parse.ts` only because a form has a deeper tree than a content
+ * type and the two share nothing but the reader.
+ */
+import {
+  FORM_CONDITION_OPERATORS,
+  FORM_FIELD_TYPE_NAMES,
+  FORM_WORKFLOW_TYPES,
+  type FormCondition,
+  type FormConditionOperator,
+  type FormConditionRule,
+  type FormFieldType,
+  type FormWorkflowTrigger,
+  type FormWorkflowType,
+  formFieldType,
+  type SchemaForm,
+  type SchemaFormField,
+  type SchemaFormGroup,
+  type SchemaFormPage,
+  type SchemaFormWorkflow,
+} from '@crombolo/core'
+import { type ParseResult, Reader, type Toml, toml } from './reader.ts'
+
+const FORM_KEYS = [
+  'key',
+  'alias',
+  'name',
+  'notes',
+  'store-entries',
+  'requires-approval',
+  'submit-label',
+  'next-label',
+  'previous-label',
+  'message-on-submit',
+  'redirect-to',
+  'theme',
+  'honeypot',
+  'minimum-submit-seconds',
+  'max-entries',
+  'since',
+] as const
+
+const PAGE_KEYS = ['caption', 'group', 'condition'] as const
+const GROUP_KEYS = ['caption', 'columns', 'field', 'condition'] as const
+const FIELD_KEYS = [
+  'key',
+  'alias',
+  'type',
+  'caption',
+  'help-text',
+  'mandatory',
+  'mandatory-message',
+  'pattern',
+  'pattern-message',
+  'sensitive',
+  'css-class',
+  'autocomplete',
+  'values',
+  'placeholder',
+  'default-value',
+  'content',
+  'maxlength',
+  'rows',
+  'min',
+  'max',
+  'step',
+  'accept',
+  'max-size-kb',
+  'multiple',
+  'condition',
+] as const
+const CONDITION_KEYS = ['action', 'match', 'rule'] as const
+const RULE_KEYS = ['field', 'operator', 'value'] as const
+const WORKFLOW_KEYS = ['key', 'type', 'name', 'on', 'settings'] as const
+
+function condition(r: Reader, value: unknown, path: string): FormCondition | undefined {
+  if (value === undefined) return undefined
+  const t = r.table(value, path)
+  if (!t) return undefined
+  r.unknown(t, CONDITION_KEYS, path)
+
+  const action = r.str(t, 'action', path) ?? 'show'
+  if (action !== 'show' && action !== 'hide')
+    r.problem(`${path}.action`, "expected 'show' or 'hide'")
+  const match = r.str(t, 'match', path) ?? 'all'
+  if (match !== 'all' && match !== 'any') r.problem(`${path}.match`, "expected 'all' or 'any'")
+
+  const rules: FormConditionRule[] = r.tables(t.rule, `${path}.rule`).map((rule, index) => {
+    const rulePath = `${path}.rule[${index}]`
+    r.unknown(rule, RULE_KEYS, rulePath)
+    const operator = r.str(rule, 'operator', rulePath, true) ?? 'is'
+    if (!FORM_CONDITION_OPERATORS.includes(operator as FormConditionOperator))
+      r.problem(
+        `${rulePath}.operator`,
+        `unknown operator; expected one of ${FORM_CONDITION_OPERATORS.join(', ')}`,
+      )
+    return {
+      field: r.str(rule, 'field', rulePath, true) ?? '',
+      operator: operator as FormConditionOperator,
+      value: r.str(rule, 'value', rulePath),
+    }
+  })
+  if (rules.length === 0) r.problem(`${path}.rule`, 'a condition needs at least one rule')
+
+  return {
+    action: action === 'hide' ? 'hide' : 'show',
+    match: match === 'any' ? 'any' : 'all',
+    rules,
+  }
+}
+
+function field(r: Reader, t: Toml, path: string): SchemaFormField {
+  r.unknown(t, FIELD_KEYS, path)
+  const type = r.str(t, 'type', path, true) ?? ''
+  if (type && !formFieldType(type))
+    r.problem(
+      `${path}.type`,
+      `unknown field type; expected one of ${FORM_FIELD_TYPE_NAMES.join(', ')}`,
+    )
+  // Consent is mandatory unless the form says otherwise: a consent box that can
+  // be skipped records agreement nobody gave.
+  const mandatoryByDefault = type === 'dataConsent'
+  return {
+    key: r.str(t, 'key', path),
+    alias: r.str(t, 'alias', path, true) ?? '',
+    type: type as FormFieldType,
+    caption: r.str(t, 'caption', path, true) ?? '',
+    helpText: r.str(t, 'help-text', path),
+    mandatory: r.bool(t, 'mandatory', path, mandatoryByDefault),
+    mandatoryMessage: r.str(t, 'mandatory-message', path),
+    pattern: r.str(t, 'pattern', path),
+    patternMessage: r.str(t, 'pattern-message', path),
+    sensitive: r.bool(t, 'sensitive', path, false),
+    cssClass: r.str(t, 'css-class', path),
+    autocomplete: r.str(t, 'autocomplete', path),
+    values: r.strs(t, 'values', path),
+    placeholder: r.str(t, 'placeholder', path),
+    defaultValue: r.str(t, 'default-value', path),
+    content: r.str(t, 'content', path),
+    maxlength: r.num(t, 'maxlength', path),
+    rows: r.num(t, 'rows', path),
+    min: r.num(t, 'min', path),
+    max: r.num(t, 'max', path),
+    step: r.num(t, 'step', path),
+    accept: r.strs(t, 'accept', path),
+    maxSizeKb: r.num(t, 'max-size-kb', path),
+    ...(t.multiple !== undefined ? { multiple: r.bool(t, 'multiple', path, false) } : {}),
+    condition: condition(r, t.condition, `${path}.condition`),
+  }
+}
+
+function group(r: Reader, t: Toml, path: string): SchemaFormGroup {
+  r.unknown(t, GROUP_KEYS, path)
+  return {
+    caption: r.str(t, 'caption', path),
+    columns: r.num(t, 'columns', path) ?? 1,
+    fields: r.tables(t.field, `${path}.field`).map((f, i) => field(r, f, `${path}.field[${i}]`)),
+    condition: condition(r, t.condition, `${path}.condition`),
+  }
+}
+
+function page(r: Reader, t: Toml, path: string): SchemaFormPage {
+  r.unknown(t, PAGE_KEYS, path)
+  return {
+    caption: r.str(t, 'caption', path),
+    groups: r.tables(t.group, `${path}.group`).map((g, i) => group(r, g, `${path}.group[${i}]`)),
+    condition: condition(r, t.condition, `${path}.condition`),
+  }
+}
+
+function workflow(r: Reader, t: Toml, path: string): SchemaFormWorkflow {
+  r.unknown(t, WORKFLOW_KEYS, path)
+  const type = r.str(t, 'type', path, true) ?? ''
+  if (type && !FORM_WORKFLOW_TYPES.includes(type as FormWorkflowType))
+    r.problem(
+      `${path}.type`,
+      `unknown workflow type; expected one of ${FORM_WORKFLOW_TYPES.join(', ')}`,
+    )
+  const on = r.str(t, 'on', path) ?? 'submit'
+  if (on !== 'submit' && on !== 'approve') r.problem(`${path}.on`, "expected 'submit' or 'approve'")
+  const settings = t.settings === undefined ? {} : r.table(t.settings, `${path}.settings`)
+  return {
+    key: r.str(t, 'key', path),
+    type: type as FormWorkflowType,
+    name: r.str(t, 'name', path, true) ?? '',
+    on: on as FormWorkflowTrigger,
+    settings: (settings ?? {}) as Record<string, unknown>,
+  }
+}
+
+export function parseForm(file: string, source: string): ParseResult<SchemaForm> {
+  const r = new Reader(file)
+  const root = toml(source, r)
+  if (!root) return { value: undefined, problems: r.problems }
+  r.unknown(root, ['form', 'page', 'workflow'], '')
+  const t = r.table(root.form, 'form')
+  if (!t) {
+    r.problem('form', 'a [form] table is required')
+    return { value: undefined, problems: r.problems }
+  }
+  const path = 'form'
+  r.unknown(t, FORM_KEYS, path)
+  const value: SchemaForm = {
+    key: r.str(t, 'key', path),
+    alias: r.str(t, 'alias', path, true) ?? '',
+    name: r.str(t, 'name', path, true) ?? '',
+    notes: r.str(t, 'notes', path),
+    // Entries are kept unless a form opts out: a form that quietly discarded
+    // what people typed would be the worst possible default.
+    storeEntries: r.bool(t, 'store-entries', path, true),
+    requiresApproval: r.bool(t, 'requires-approval', path, false),
+    submitLabel: r.str(t, 'submit-label', path),
+    nextLabel: r.str(t, 'next-label', path),
+    previousLabel: r.str(t, 'previous-label', path),
+    messageOnSubmit: r.str(t, 'message-on-submit', path),
+    redirectTo: r.str(t, 'redirect-to', path),
+    theme: r.str(t, 'theme', path),
+    honeypot: r.bool(t, 'honeypot', path, true),
+    minimumSubmitSeconds: r.num(t, 'minimum-submit-seconds', path),
+    maxEntries: r.num(t, 'max-entries', path),
+    since: r.str(t, 'since', path),
+    pages: r.tables(root.page, 'page').map((p, i) => page(r, p, `page[${i}]`)),
+    workflows: r.tables(root.workflow, 'workflow').map((w, i) => workflow(r, w, `workflow[${i}]`)),
+  }
+  return { value: r.problems.length === 0 ? value : undefined, problems: r.problems }
+}

package/src/parse.ts

@@ -0,0 +1,260 @@
+/**
+ * TOML → model. Strict: an unknown key is an error, because a misspelt key is
+ * the most common mistake a non-developer makes and silently ignoring it would
+ * hide the thing they were trying to do.
+ */
+import {
+  type SchemaContentType,
+  type SchemaDataType,
+  type SchemaGroup,
+  type SchemaLanguage,
+  type SchemaProperty,
+  type SchemaTab,
+  type SchemaTypeKind,
+  TYPE_KIND_FILES,
+} from './model.ts'
+import { type ParseResult, Reader, type Toml, toml } from './reader.ts'
+
+export type { ParseResult }
+
+const PROPERTY_KEYS = [
+  'member-can-view',
+  'member-can-edit',
+  'sensitive',
+  'key',
+  'alias',
+  'name',
+  'description',
+  'notes',
+  'type',
+  'mandatory',
+  'mandatory-message',
+  'regex',
+  'regex-message',
+  'varies-by-culture',
+  'varies-by-segment',
+  'label-on-top',
+  'default',
+  'since',
+] as const
+const GROUP_KEYS = ['name', 'alias', 'property'] as const
+const TAB_KEYS = ['name', 'alias', 'property', 'group'] as const
+const TYPE_KEYS = [
+  'key',
+  'alias',
+  'name',
+  'description',
+  'notes',
+  'icon',
+  'allow-at-root',
+  'is-element',
+  'allow-in-library',
+  'varies-by-culture',
+  'varies-by-segment',
+  'compositions',
+  'allow-children',
+  'components',
+  'default-component',
+  'collection',
+  'folder',
+  'cleanup',
+  'since',
+] as const
+const CLEANUP_KEYS = [
+  'prevent',
+  'keep-all-newer-than-days',
+  'keep-latest-per-day-for-days',
+] as const
+const DATA_TYPE_KEYS = [
+  'key',
+  'alias',
+  'name',
+  'notes',
+  'editor',
+  'editor-ui',
+  'folder',
+  'config',
+  'since',
+] as const
+const LANGUAGE_KEYS = ['iso', 'name', 'default', 'mandatory', 'fallback'] as const
+
+function property(r: Reader, t: Toml, path: string): SchemaProperty {
+  r.unknown(t, PROPERTY_KEYS, path)
+  return {
+    key: r.str(t, 'key', path),
+    alias: r.str(t, 'alias', path, true) ?? '',
+    name: r.str(t, 'name', path, true) ?? '',
+    description: r.str(t, 'description', path),
+    notes: r.str(t, 'notes', path),
+    type: r.str(t, 'type', path, true) ?? '',
+    mandatory: r.bool(t, 'mandatory', path, false),
+    mandatoryMessage: r.str(t, 'mandatory-message', path),
+    regex: r.str(t, 'regex', path),
+    regexMessage: r.str(t, 'regex-message', path),
+    variesByCulture: r.bool(t, 'varies-by-culture', path, false),
+    variesBySegment: r.bool(t, 'varies-by-segment', path, false),
+    labelOnTop: r.bool(t, 'label-on-top', path, false),
+    ...(t['member-can-view'] !== undefined
+      ? { memberCanView: r.bool(t, 'member-can-view', path, false) }
+      : {}),
+    ...(t['member-can-edit'] !== undefined
+      ? { memberCanEdit: r.bool(t, 'member-can-edit', path, false) }
+      : {}),
+    ...(t.sensitive !== undefined ? { sensitive: r.bool(t, 'sensitive', path, false) } : {}),
+    default: t.default,
+    since: r.str(t, 'since', path),
+  }
+}
+
+function group(r: Reader, t: Toml, path: string): SchemaGroup {
+  r.unknown(t, GROUP_KEYS, path)
+  return {
+    name: r.str(t, 'name', path, true) ?? '',
+    alias: r.str(t, 'alias', path),
+    properties: r
+      .tables(t.property, `${path}.property`)
+      .map((p, i) => property(r, p, `${path}.property[${i}]`)),
+  }
+}
+
+function tab(r: Reader, t: Toml, path: string): SchemaTab {
+  r.unknown(t, TAB_KEYS, path)
+  return {
+    name: r.str(t, 'name', path, true) ?? '',
+    alias: r.str(t, 'alias', path),
+    properties: r
+      .tables(t.property, `${path}.property`)
+      .map((p, i) => property(r, p, `${path}.property[${i}]`)),
+    groups: r.tables(t.group, `${path}.group`).map((g, i) => group(r, g, `${path}.group[${i}]`)),
+  }
+}
+
+/** Media types have no templates and no version cleanup policy. */
+const MEDIA_TYPE_KEYS = TYPE_KEYS.filter(
+  (k) => k !== 'components' && k !== 'default-component' && k !== 'cleanup',
+)
+/** Member types, besides, allow no children: members are not a tree. */
+const MEMBER_TYPE_KEYS = MEDIA_TYPE_KEYS.filter((k) => k !== 'allow-children')
+
+export function parseContentType(
+  file: string,
+  source: string,
+  kind: SchemaTypeKind = 'document',
+): ParseResult<SchemaContentType> {
+  const r = new Reader(file)
+  const root = toml(source, r)
+  if (!root) return { value: undefined, problems: r.problems }
+  const header = TYPE_KIND_FILES[kind].header
+  r.unknown(root, [header, 'tab', 'group', 'property'], '')
+  const t = r.table(root[header], header)
+  if (!t) {
+    r.problem(header, `a [${header}] table is required`)
+    return { value: undefined, problems: r.problems }
+  }
+  const path = header
+  r.unknown(
+    t,
+    kind === 'media' ? MEDIA_TYPE_KEYS : kind === 'member' ? MEMBER_TYPE_KEYS : TYPE_KEYS,
+    path,
+  )
+  const cleanupTable = t.cleanup === undefined ? undefined : r.table(t.cleanup, `${path}.cleanup`)
+  if (cleanupTable) r.unknown(cleanupTable, CLEANUP_KEYS, `${path}.cleanup`)
+  const value: SchemaContentType = {
+    key: r.str(t, 'key', path),
+    alias: r.str(t, 'alias', path, true) ?? '',
+    name: r.str(t, 'name', path, true) ?? '',
+    description: r.str(t, 'description', path),
+    notes: r.str(t, 'notes', path),
+    icon: r.str(t, 'icon', path) ?? 'icon-document',
+    allowAtRoot: r.bool(t, 'allow-at-root', path, false),
+    isElement: r.bool(t, 'is-element', path, false),
+    allowInLibrary: r.bool(t, 'allow-in-library', path, false),
+    variesByCulture: r.bool(t, 'varies-by-culture', path, false),
+    variesBySegment: r.bool(t, 'varies-by-segment', path, false),
+    compositions: r.strs(t, 'compositions', path),
+    allowChildren: r.strs(t, 'allow-children', path),
+    components: r.strs(t, 'components', path),
+    defaultComponent: r.str(t, 'default-component', path),
+    collection: r.str(t, 'collection', path),
+    folder: r.str(t, 'folder', path),
+    cleanup: {
+      prevent: cleanupTable ? r.bool(cleanupTable, 'prevent', `${path}.cleanup`, false) : false,
+      keepAllNewerThanDays: cleanupTable
+        ? r.num(cleanupTable, 'keep-all-newer-than-days', `${path}.cleanup`)
+        : undefined,
+      keepLatestPerDayForDays: cleanupTable
+        ? r.num(cleanupTable, 'keep-latest-per-day-for-days', `${path}.cleanup`)
+        : undefined,
+    },
+    since: r.str(t, 'since', path),
+    properties: r.tables(root.property, 'property').map((p, i) => property(r, p, `property[${i}]`)),
+    tabs: r.tables(root.tab, 'tab').map((x, i) => tab(r, x, `tab[${i}]`)),
+    groups: r.tables(root.group, 'group').map((g, i) => group(r, g, `group[${i}]`)),
+  }
+  return { value: r.problems.length === 0 ? value : undefined, problems: r.problems }
+}
+
+export function parseMediaType(file: string, source: string): ParseResult<SchemaContentType> {
+  return parseContentType(file, source, 'media')
+}
+
+export function parseMemberType(file: string, source: string): ParseResult<SchemaContentType> {
+  return parseContentType(file, source, 'member')
+}
+
+export function parseDataType(file: string, source: string): ParseResult<SchemaDataType> {
+  const r = new Reader(file)
+  const root = toml(source, r)
+  if (!root) return { value: undefined, problems: r.problems }
+  r.unknown(root, ['data-type'], '')
+  const t = r.table(root['data-type'], 'data-type')
+  if (!t) {
+    r.problem('data-type', 'a [data-type] table is required')
+    return { value: undefined, problems: r.problems }
+  }
+  const path = 'data-type'
+  r.unknown(t, DATA_TYPE_KEYS, path)
+  const config = t.config === undefined ? {} : r.table(t.config, `${path}.config`)
+  const value: SchemaDataType = {
+    key: r.str(t, 'key', path),
+    alias: r.str(t, 'alias', path, true) ?? '',
+    name: r.str(t, 'name', path, true) ?? '',
+    notes: r.str(t, 'notes', path),
+    editor: r.str(t, 'editor', path, true) ?? '',
+    editorUi: r.str(t, 'editor-ui', path),
+    folder: r.str(t, 'folder', path),
+    config: (config ?? {}) as Record<string, unknown>,
+    since: r.str(t, 'since', path),
+  }
+  return { value: r.problems.length === 0 ? value : undefined, problems: r.problems }
+}
+
+export function parseLanguages(file: string, source: string): ParseResult<SchemaLanguage[]> {
+  const r = new Reader(file)
+  const root = toml(source, r)
+  if (!root) return { value: undefined, problems: r.problems }
+  r.unknown(root, ['language'], '')
+  const value = r.tables(root.language, 'language').map((t, i) => {
+    const path = `language[${i}]`
+    r.unknown(t, LANGUAGE_KEYS, path)
+    return {
+      iso: r.str(t, 'iso', path, true) ?? '',
+      name: r.str(t, 'name', path, true) ?? '',
+      default: r.bool(t, 'default', path, false),
+      mandatory: r.bool(t, 'mandatory', path, false),
+      fallback: r.str(t, 'fallback', path),
+    } satisfies SchemaLanguage
+  })
+  return { value: r.problems.length === 0 ? value : undefined, problems: r.problems }
+}
+
+export function parseSchemaVersion(file: string, source: string): ParseResult<string> {
+  const r = new Reader(file)
+  const root = toml(source, r)
+  if (!root) return { value: undefined, problems: r.problems }
+  r.unknown(root, ['schema'], '')
+  const t = r.table(root.schema, 'schema')
+  const version = t ? r.str(t, 'version', 'schema', true) : undefined
+  if (t) r.unknown(t, ['version'], 'schema')
+  return { value: r.problems.length === 0 ? version : undefined, problems: r.problems }
+}