@michaelthielemann/kestrel 4.1.2 → 5.0.0

package/layers/admin/app/utils/edit-form.ts

@@ -1,267 +0,0 @@
-import { toRaw } from 'vue'
-import type { FieldDef, SerializedField } from '@michaelthielemann/kestrel-core'
-import { resolveFieldEmpty } from '../../../ui/app/utils/field-empty'
-
-export interface ServerIssue {
-  path: (string | number)[]
-  message: string
-  code?: string
-}
-
-export interface MappedErrors {
-  fields: Record<string, string>
-  form?: string
-}
-
-export interface FetchErrorInfo {
-  statusCode?: number
-  statusMessage?: string
-  issues: ServerIssue[]
-  /** The error body when it is NOT a Zod-issue array — e.g. `{ savedUpdatedAt }` from a failed write effect. */
-  data?: Record<string, unknown>
-}
-
-// The wire `SerializedField` is structurally what every Field* widget and `validateField` read
-// (flat type + options record + relation); only its discriminated-union typing differs. Narrow here.
-export function asFieldDef(field: SerializedField): FieldDef {
-  return field as unknown as FieldDef
-}
-
-// Read an ofetch/H3 error envelope: top-level statusCode/statusMessage, Zod issues nested at err.data.data.
-// The BODY's statusMessage wins over the response's: ofetch maps `statusMessage` from `response.statusText`,
-// and HTTP/2 has no reason phrase — behind any h2 proxy that arrives as '' and the real message is only in
-// the JSON. Anything else under `data` (not an issue array) is handed back for the caller to act on.
-export function readFetchError(e: unknown): FetchErrorInfo {
-  const err = e as { statusCode?: number; statusMessage?: string; data?: { data?: ServerIssue[] } & Record<string, unknown> }
-  const body = Array.isArray(err.data) ? undefined : err.data
-  const raw = body?.data ?? err.data
-  return {
-    statusCode: err.statusCode,
-    statusMessage: (body?.statusMessage as string | undefined) || err.statusMessage,
-    issues: Array.isArray(raw) ? (raw as ServerIssue[]) : [],
-    ...(body && !Array.isArray(body.data) ? { data: body } : {}),
-  }
-}
-
-// `field.default` on a block-picker's field comes from `useBlocks()`'s `useState`-backed list — a Vue
-// reactive Proxy for any object/array value. `structuredClone` cannot clone a Proxy (`DataCloneError`,
-// deterministic, not a race) — `toRaw` unwraps it first, same fix `cloneBlockTree` reaches for via a JSON
-// round-trip; `toRaw` + `structuredClone` keeps real Date/Map values a JSON round-trip would mangle.
-function cloneDefault(value: unknown): unknown {
-  return value !== null && typeof value === 'object' ? structuredClone(toRaw(value)) : value
-}
-
-function emptyForField(field: SerializedField): unknown {
-  switch (field.type) {
-    case 'text':
-      return ''
-    case 'boolean':
-      return false
-    case 'repeater':
-      return []
-    case 'choice':
-      return field.options?.multiple ? [] : null
-    case 'relation':
-      return field.relation?.many ? [] : null
-    case 'media':
-      return field.options?.multiple ? [] : null
-    default:
-      // A consumer-defined type may register its blank shape (array/object-backed → [] / {}); else null.
-      return resolveFieldEmpty(field.type)?.() ?? null
-  }
-}
-
-/** Build a blank form state: a present (JSON-safe) default wins, else a type-appropriate empty. */
-export function initialValues(fields: Record<string, SerializedField>): Record<string, unknown> {
-  const out: Record<string, unknown> = {}
-  for (const [name, field] of Object.entries(fields)) {
-    out[name] = 'default' in field ? cloneDefault(field.default) : emptyForField(field)
-  }
-  return out
-}
-
-/** Map a 400 body's Zod issues to per-field errors (by path[0]) and a single form-level error (empty path). */
-export function mapServerErrors(issues: ServerIssue[] | null | undefined): MappedErrors {
-  const fields: Record<string, string> = {}
-  let form: string | undefined
-  for (const issue of issues ?? []) {
-    const head = issue.path?.[0]
-    if (head === undefined || head === null || head === '') {
-      if (form === undefined) form = issue.message
-    } else {
-      const name = String(head)
-      if (!(name in fields)) fields[name] = issue.message
-    }
-  }
-  return form === undefined ? { fields } : { fields, form }
-}
-
-/** Per-block (keyed by the stable `block.id`), per-field error map for inline block-content errors. */
-export type BlockErrorMap = Record<string, Record<string, string>>
-
-interface BlockLike {
-  id?: unknown
-  props?: Record<string, unknown>
-  slots?: Record<string, unknown>
-}
-
-function blockId(block: unknown): string | null {
-  const id = (block as BlockLike | undefined)?.id
-  return typeof id === 'string' && id !== '' ? id : null
-}
-
-/**
- * Parse nested block-content issues into a per-block, per-field error map keyed by the block's
- * stable `id`. The server reports a *position* path — `[key, i, 'props', field, …]` for a top-level
- * block, `[key, i, 'slots', name, j, 'props', field, …]` for one nested in a slot (any depth). We
- * walk that path through the submitted `content` to find the target block and pin the error to its
- * id, so it survives a later reorder at any level. First wins per field; an unresolvable path is
- * skipped.
- */
-export function parseBlockErrors(
-  issues: ServerIssue[] | null | undefined,
-  content: readonly unknown[] | null | undefined,
-  key = 'content',
-): BlockErrorMap {
-  const out: BlockErrorMap = {}
-  for (const issue of issues ?? []) {
-    const path = issue.path ?? []
-    if (path[0] !== key) continue
-    const hit = resolveBlockField(path.slice(1), content)
-    if (!hit) continue
-    out[hit.id] ??= {}
-    if (!(hit.field in out[hit.id]!)) out[hit.id]![hit.field] = issue.message
-  }
-  return out
-}
-
-/**
- * Walk a position path (after the `content` head) through the block tree to the block whose
- * `props.<field>` the issue targets. Steps over `<index>, 'slots', <name>` segments into nested
- * slot arrays. Returns the target block's stable id + the field name, or null if the path is not a
- * `…props.<field>` leaf or any segment doesn't resolve to an identified block.
- */
-function resolveBlockField(
-  path: readonly (string | number)[],
-  blocks: readonly unknown[] | null | undefined,
-): { id: string; field: string } | null {
-  let arr: readonly unknown[] | null | undefined = blocks
-  for (let i = 0; i < path.length; ) {
-    const index = path[i]
-    if (typeof index !== 'number' || !Array.isArray(arr)) return null
-    const block = arr[index] as BlockLike | undefined
-    const next = path[i + 1]
-    if (next === 'props') {
-      const field = path[i + 2]
-      const id = blockId(block)
-      return typeof field === 'string' && id !== null ? { id, field } : null
-    }
-    if (next === 'slots') {
-      const name = path[i + 2]
-      if (typeof name !== 'string') return null
-      const slot = block?.slots?.[name]
-      arr = Array.isArray(slot) ? slot : null
-      i += 3
-      continue
-    }
-    return null
-  }
-  return null
-}
-
-/**
- * Carry block errors across a `content` change. A block (identified by its stable `id`, top-level or nested in
- * a slot at any depth) keeps its errors while it merely moves — a pure reorder, whether of its slot or of an
- * ancestor — and is dropped when removed; added blocks never gain an error. Reconciliation is PER-FIELD: an
- * edit clears only the edited field's stale message, so a still-invalid sibling field of the same block keeps
- * its error instead of all of them flickering away until the next save.
- */
-export function reconcileBlockErrors(
-  errors: BlockErrorMap,
-  prev: readonly unknown[] | null | undefined,
-  next: readonly unknown[] | null | undefined,
-): BlockErrorMap {
-  const prevById = new Map<string, BlockLike>()
-  const nextById = new Map<string, BlockLike>()
-  flattenBlocksById(prev, prevById)
-  flattenBlocksById(next, nextById)
-  const out: BlockErrorMap = {}
-  for (const [id, errs] of Object.entries(errors)) {
-    const before = prevById.get(id)
-    const after = nextById.get(id)
-    if (!before || !after) continue // removed → drop
-    const beforeProps = (before.props ?? {}) as Record<string, unknown>
-    const afterProps = (after.props ?? {}) as Record<string, unknown>
-    const kept: Record<string, string> = {}
-    for (const [field, message] of Object.entries(errs)) {
-      // Keep a field's error only while THAT field's value is unchanged; editing it clears its own stale message.
-      if (valuesEqual(beforeProps[field], afterProps[field])) kept[field] = message
-    }
-    if (Object.keys(kept).length) out[id] = kept
-  }
-  return out
-}
-
-/** Index every block in the tree (top-level and nested in slots) by its stable id. */
-function flattenBlocksById(blocks: readonly unknown[] | null | undefined, into: Map<string, BlockLike>): void {
-  for (const block of blocks ?? []) {
-    const id = blockId(block)
-    if (id !== null) into.set(id, block as BlockLike)
-    const slots = (block as BlockLike | undefined)?.slots
-    if (slots) for (const arr of Object.values(slots)) if (Array.isArray(arr)) flattenBlocksById(arr, into)
-  }
-}
-
-/** One stale reference a record holds. Wire shape of `DeadRef` (kept structural here so this module stays
- *  Vue-free and doesn't import the admin-only `dead-refs.ts` type file). */
-interface DeadRefLike {
-  field: string
-  blockId?: string
-}
-
-/**
- * Carry dead-reference warnings across a `content` change, mirroring `reconcileBlockErrors`: a warning at
- * a block (by stable id) is dropped once THAT field's value changes (the user swapped the broken
- * reference) or the block is removed; it survives a pure reorder. Root-level (non-block) dead refs are
- * untouched here — `setField` drops those directly when their own field is edited.
- */
-export function reconcileDeadRefs<T extends DeadRefLike>(
-  refs: readonly T[],
-  prev: readonly unknown[] | null | undefined,
-  next: readonly unknown[] | null | undefined,
-): T[] {
-  const prevById = new Map<string, BlockLike>()
-  const nextById = new Map<string, BlockLike>()
-  flattenBlocksById(prev, prevById)
-  flattenBlocksById(next, nextById)
-  return refs.filter((r) => {
-    if (!r.blockId) return true
-    const before = prevById.get(r.blockId)
-    const after = nextById.get(r.blockId)
-    if (!before || !after) return false
-    const beforeVal = (before.props ?? {})[r.field]
-    const afterVal = (after.props ?? {})[r.field]
-    return valuesEqual(beforeVal, afterVal)
-  })
-}
-
-/** Structural deep-equality for the value shapes the editor tracks (primitives, arrays, plain objects). */
-export function valuesEqual(a: unknown, b: unknown): boolean {
-  if (a === b) return true
-  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false
-
-  const aArr = Array.isArray(a)
-  const bArr = Array.isArray(b)
-  if (aArr !== bArr) return false
-  if (aArr && bArr) {
-    if (a.length !== b.length) return false
-    return a.every((item, i) => valuesEqual(item, b[i]))
-  }
-
-  const aRec = a as Record<string, unknown>
-  const bRec = b as Record<string, unknown>
-  const aKeys = Object.keys(aRec)
-  const bKeys = Object.keys(bRec)
-  if (aKeys.length !== bKeys.length) return false
-  return aKeys.every((k) => Object.prototype.hasOwnProperty.call(bRec, k) && valuesEqual(aRec[k], bRec[k]))
-}

package/layers/admin/app/utils/editor-expose.ts

@@ -1,36 +0,0 @@
-import type { PublishStatusData } from '../composables/usePublishStatus'
-
-/**
- * The handle `CollectionEditor` exposes via `defineExpose` — the header hosts (`[collection]/[id].vue`
- * and `SingletonEditor.vue`) drive Save / undo / preview and read the status ampel through it. ONE typed
- * contract instead of three drifting inline copies: Vue does not type-check a template `ref="editorRef"`
- * against `defineExpose`, so without a shared interface a renamed/removed key (e.g. `previewUrl`) compiles
- * in both hosts and silently becomes `undefined` at runtime. Type both host refs as `EditorExpose | null`.
- */
-export interface EditorExpose {
-  dirty: boolean
-  saving: boolean
-  canUndo: boolean
-  canRedo: boolean
-  undo: () => void
-  redo: () => void
-  hasStatus: boolean
-  status: string
-  /** The last SAVED publish status (baseline), for the right lamp's draft/published decision. */
-  savedStatus: string
-  previewUrl: string | null
-  pageLike: boolean
-  live: PublishStatusData | null
-  /** The record's own title (see `recordTitle`), or `''` — the header then shows "Edit {collection} #{id}". */
-  recordTitle: string
-  /** Save, then write the static output (ADR-0008) — a draft is promoted to published on the way. */
-  publish: () => Promise<void>
-  publishing: boolean
-  /** False when `output.publishOnSave` is on — a save republishes, so the hosts hide the Publish button. */
-  canPublish: boolean
-  /** Open the record in a new tab: the saved URL, or the unsaved state carried by a preview ticket. */
-  openPreview: () => Promise<void>
-  previewOpening: boolean
-  /** The loaded row is the quarantine shape — read-only, hosts must hide Save/Publish. */
-  quarantined: boolean
-}

package/layers/admin/app/utils/editor-form-context.ts

@@ -1,82 +0,0 @@
-import type { ComputedRef, InjectionKey, Ref } from 'vue'
-import type { FieldDef, LayoutNode } from '@michaelthielemann/kestrel-core'
-import type { BlockErrorMap } from './edit-form'
-import type { DeadRef } from './dead-refs'
-
-/**
- * The form context `CollectionEditor` (the generic shell) provides to whichever editor **body** the
- * registry resolves (fields · blocks · an extension's, e.g. node-graph). It carries the load-bearing
- * `useEditForm` surface a body needs to read and mutate the record, so a body swaps in without a giant
- * prop list — the same provide/inject seam as `recordEditContextKey`, one level up.
- *
- * Provide it BEFORE the shell's top-level `await` (after an await the setup instance is gone and `provide`
- * silently no-ops), exactly like the record-edit context.
- */
-/** Props for the shared page-fields pane. Defined once here so the shell's pre-built bindings and
- *  `PageFieldsPane`'s own `defineProps` stay a single type (a widened `Record` would break the v-bind). */
-export interface PageFieldsBindings {
-  translatable?: boolean
-  collection: string
-  id: string
-  mode: 'single' | 'multi'
-  locale: string
-  translations: Record<string, number | null>
-  group?: string
-  fields: Record<string, FieldDef>
-  /** Normalized admin editor layout for the page fields (undefined → one field per row). */
-  fieldLayout?: LayoutNode[]
-  values: Record<string, unknown>
-  errors: Record<string, string>
-  deadFields?: Set<string>
-  pageLike?: boolean
-  seo?: boolean
-  status?: boolean
-  disabled?: boolean
-}
-
-export interface EditorFormContext {
-  /** Reactive form values / per-field errors (from `useEditForm`; reactive objects, not refs). */
-  values: Record<string, unknown>
-  errors: Record<string, string>
-  formError: Ref<string>
-  blockErrors: Ref<BlockErrorMap>
-  /** Route every mutation through this (→ block-error reconciliation, dirty tracking, history). The
-   *  optional `coalesceAs` lets a caller (e.g. a block-tree structural op) tag its own undo-history key
-   *  instead of coalescing under the bare field name. */
-  setField: (name: string, value: unknown, coalesceAs?: string) => void
-  locale: Ref<string>
-  translations: Ref<Record<string, number | null>>
-  translationGroup: Ref<string | undefined>
-  deadRefs: Ref<DeadRef[]>
-  saving: Ref<boolean>
-  mode: Ref<'multi' | 'single'>
-  translatable: Ref<boolean>
-  pageLike: Ref<boolean>
-  hasSeo: Ref<boolean>
-  hasStatus: Ref<boolean>
-  blocksAllowed: Ref<string[] | undefined>
-  /** Collection (page-root) fields as `FieldDef`s, ready for the field Renderer. */
-  renderable: ComputedRef<Record<string, FieldDef>>
-  /** The record's localized public URL (saved pageLike record with a path), or null (new/unsaved,
-   *  non-pageLike). The shell computes it once for the header's open-in-new-tab AND the live preview. */
-  previewUrl: ComputedRef<string | null>
-  undo: () => void
-  redo: () => void
-  applyFrom: (row: Record<string, unknown>) => void
-  /** Pre-bound props/handlers for the shared page-fields pane, rendered by both the fields and blocks
-   *  bodies (identical binding, differing only in layout chrome). */
-  pageFieldsBindings: ComputedRef<PageFieldsBindings>
-  pageFieldsHandlers: Record<string, (...args: never[]) => void>
-  /** A body registers how to reveal a validation failure (e.g. the blocks body focuses the offending
-   *  block). The shell calls it on a failed save, staying agnostic of the body's internals. */
-  registerRevealError: (fn: () => void) => void
-}
-
-export const editorFormContextKey = Symbol('kestrel.editorForm') as InjectionKey<EditorFormContext>
-
-/** Inject the editor form context inside a body component; throws if used outside `CollectionEditor`. */
-export function useEditorFormContext(): EditorFormContext {
-  const ctx = inject(editorFormContextKey)
-  if (!ctx) throw new Error('[kestrel] editor body used outside CollectionEditor (no editor form context)')
-  return ctx
-}

package/layers/admin/app/utils/editor-registry.ts

@@ -1,20 +0,0 @@
-import type { Component } from 'vue'
-
-/**
- * Registry of admin editor *bodies* keyed by editor type (the `editor` field on a serialized collection).
- * Mirrors the field-widget registry (`layers/ui/app/utils/field-registry.ts`), one level up: instead of
- * picking a widget per field type, it picks the whole editor body per collection.
- *
- * The built-in `fields` / `blocks` bodies register themselves when the admin editor loads (see
- * `register-editors`); extensions add their own via a `*.client.ts` plugin (auto-discovered through
- * `extends`), exactly like `registerFieldComponent`. The frame — the admin rail (layout) and the record
- * header/toolbar + form state (`CollectionEditor` / the host pages) — stays generic; only this body swaps.
- */
-export const editorComponents: Record<string, Component> = {}
-
-export const resolveCollectionEditor = (type: string): Component | undefined => editorComponents[type]
-
-/** Register an editor body for a type. Mutates the singleton; a later call overrides the same type. */
-export function registerCollectionEditor(type: string, component: Component): void {
-  editorComponents[type] = component
-}

package/layers/admin/app/utils/field-keys.ts

@@ -1,11 +0,0 @@
-import type { SerializedField } from '@michaelthielemann/kestrel-core'
-
-/**
- * The jsKey (wire key) for a field — NOT a DB column name. The server marks single relation/media fields
- * with `single` (stored as a `<name>Id` FK column, e.g. `author` -> `authorId`); everything else keeps the
- * field name. The editor binds widgets by field name but must read/write rows, request bodies and list
- * queries by this key — reading the server flag instead of re-deriving the rule (which silently drifts).
- */
-export function jsKey(name: string, field: SerializedField): string {
-  return field.single ? `${name}Id` : name
-}

package/layers/admin/app/utils/list-cell.ts

@@ -1,46 +0,0 @@
-// Cell rendering for the collection list: how a raw row value becomes the string in a table cell.
-import type { ListColumn } from './list-columns'
-import { humanizeFieldName } from '../../../ui/app/utils/humanize'
-
-const dateFmt = new Intl.DateTimeFormat(undefined, { year: 'numeric', month: 'short', day: '2-digit' })
-// A date-only value ('YYYY-MM-DD', from a datetime field with precision 'date') parses as UTC midnight;
-// formatting it in the local zone would shift the calendar day, so pin it to UTC. Full ISO timestamps
-// (createdAt/updatedAt carry a 'Z') and local datetimes keep the local-zone formatter.
-const dateOnlyFmt = new Intl.DateTimeFormat(undefined, { year: 'numeric', month: 'short', day: '2-digit', timeZone: 'UTC' })
-
-export function isDateColumn(col: ListColumn): boolean {
-  return col.key === 'createdAt' || col.key === 'updatedAt' || col.field?.type === 'datetime'
-}
-
-export function cellText(value: unknown): string {
-  if (value == null) return ''
-  if (typeof value === 'string') return value.replace(/<[^>]*>/g, '').slice(0, 80)
-  if (typeof value === 'object') return JSON.stringify(value).slice(0, 80)
-  return String(value)
-}
-
-export function cellDisplay(col: ListColumn, row: Record<string, unknown>): string {
-  const value = row[col.key]
-  if (isDateColumn(col) && value != null) {
-    const dateOnly = typeof value === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(value)
-    const d = new Date(value as string)
-    if (!Number.isNaN(d.getTime())) return (dateOnly ? dateOnlyFmt : dateFmt).format(d)
-  }
-  return cellText(value)
-}
-
-/** A column header's text: a field column humanizes its own name, chrome columns translate a key. */
-export function columnLabel(col: ListColumn, t: (key: string) => string): string {
-  return col.type === 'field' ? humanizeFieldName(col.name ?? col.key) : t(col.labelKey ?? col.key)
-}
-
-/** A row's human label: the first visible non-sidecar cell that has a value, else the bare id — used for
- *  the per-row checkbox / action aria-labels so each control names its row. */
-export function rowLabel(columns: ListColumn[], row: Record<string, unknown>): string {
-  for (const c of columns) {
-    if (c.type === 'translations' || c.type === 'deadRefs') continue
-    const d = cellDisplay(c, row)
-    if (d) return d
-  }
-  return `#${row.id}`
-}

package/layers/admin/app/utils/list-columns.ts

@@ -1,142 +0,0 @@
-import { META_FILTER_KIND, fieldFilterKind } from '@michaelthielemann/kestrel-core/client'
-import type { FilterKind } from '@michaelthielemann/kestrel-core/client'
-import type { SerializedCollection, SerializedField } from '@michaelthielemann/kestrel-core'
-import { jsKey } from './field-keys'
-
-export type ListColumnType = 'meta' | 'field' | 'translations' | 'deadRefs'
-
-export interface ListColumn {
-  /** The wire/row key: used to read `row[key]` and as the sort/filter field. The translations column
-   *  uses the server sidecar key `$translations`, which is never sent as a sort/filter (not a real column). */
-  key: string
-  type: ListColumnType
-  /** Field display name (only for `type:'field'`) — used directly as the column label. */
-  name?: string
-  /** i18n key for the column label (meta + translations columns). */
-  labelKey?: string
-  field?: SerializedField
-  sortable: boolean
-  filterable: boolean
-  /** The column's filter kind (present iff `filterable`) — drives the operator set + typed value control. */
-  filterKind?: FilterKind
-}
-
-/** The sidecar key the server attaches per row for translation status (mirrors `$media`). */
-export const TRANSLATIONS_KEY = '$translations'
-
-/** The sidecar key the server attaches per row when any reference it holds points at a dead/unpublished
- *  target (the derived stale-reference warning). Like `$translations`, never a real sort/filter column. */
-export const DEAD_REFS_KEY = '$hasDeadRefs'
-
-/** Whether a collection holds any field/block that can reference another record — gates the dead-reference
- *  column (mirrors the server's `collectionMayReference`, over the serialized schema). */
-export function hasReferenceFields(schema: SerializedCollection): boolean {
-  if (schema.blocks.enabled) return true
-  if (schema.seo) return true // the `seo` system column carries a media ref (the social image)
-  return Object.values(schema.fields).some(fieldMayReference)
-}
-function fieldMayReference(field: SerializedField): boolean {
-  switch (field.type) {
-    case 'relation':
-    case 'media':
-    case 'link':
-    case 'richtext':
-      return true
-    case 'repeater':
-      return Object.values((field.options?.fields ?? {}) as Record<string, SerializedField>).some(fieldMayReference)
-    default:
-      return false
-  }
-}
-
-const META_LABEL: Record<string, string> = {
-  id: 'list.col.id',
-  path: 'list.col.slug',
-  status: 'list.col.status',
-  createdAt: 'list.col.createdAt',
-  updatedAt: 'list.col.updatedAt',
-}
-
-/** Whether a field can be meaningfully SORTED as a single scalar DB column. JSON-backed fields
- *  (richtext/json/repeater/link, multi-value choice/relation/media) cannot. (Filterability is a separate,
- *  richer question — see `fieldFilterKind`: richtext and the multi-value fields ARE filterable, via
- *  substring / JSON-array membership, even though they are not sortable.) */
-function isSortableField(f: SerializedField): boolean {
-  switch (f.type) {
-    case 'richtext':
-    case 'json':
-    case 'repeater':
-    case 'link':
-      return false
-    case 'choice':
-      return !f.options?.multiple
-    case 'relation':
-    case 'media':
-      return !!f.single
-    default:
-      return true // text, number, boolean, datetime
-  }
-}
-
-/** Whether a field column is shown by default — only plain scalar display types. Heavier/structured fields
- *  (richtext, json, repeater, link, relation, media, multi-choice) are available but off by default. */
-function isDefaultFieldColumn(f: SerializedField): boolean {
-  switch (f.type) {
-    case 'text':
-    case 'number':
-    case 'boolean':
-    case 'datetime':
-      return true
-    case 'choice':
-      return !f.options?.multiple
-    default:
-      return false
-  }
-}
-
-/** A meta/system column, filterable iff it has a FilterKind (id/path/status/timestamps all do). */
-function metaColumn(key: string): ListColumn {
-  const filterKind = META_FILTER_KIND[key]
-  return { key, type: 'meta', labelKey: META_LABEL[key], sortable: true, filterable: !!filterKind, ...(filterKind ? { filterKind } : {}) }
-}
-
-/** Every column a collection list can offer, in display order: id · fields · slug · status · timestamps ·
- *  translations. The user picks which are visible (see `defaultVisibleKeys` / `resolveVisibleColumns`). */
-export function availableColumns(schema: SerializedCollection): ListColumn[] {
-  const cols: ListColumn[] = [metaColumn('id')]
-  for (const [name, field] of Object.entries(schema.fields)) {
-    const filterKind = fieldFilterKind(field)
-    cols.push({ key: jsKey(name, field), type: 'field', name, field, sortable: isSortableField(field), filterable: filterKind !== null, ...(filterKind ? { filterKind } : {}) })
-  }
-  if (schema.pageLike) cols.push(metaColumn('path'))
-  if (schema.status) cols.push(metaColumn('status'))
-  cols.push(metaColumn('createdAt'))
-  cols.push(metaColumn('updatedAt'))
-  if (schema.translatable && schema.mode === 'multi') {
-    cols.push({ key: TRANSLATIONS_KEY, type: 'translations', labelKey: 'list.translations', sortable: false, filterable: false })
-  }
-  // A compact warning column (a triangle on rows holding a stale reference) — only where refs are possible.
-  if (hasReferenceFields(schema)) {
-    cols.push({ key: DEAD_REFS_KEY, type: 'deadRefs', labelKey: 'list.deadRefs', sortable: false, filterable: false })
-  }
-  return cols
-}
-
-/** The default visible set: everything except `id` and the heavier field types — i.e. the scalar fields
- *  plus slug, status, timestamps and translations. */
-export function defaultVisibleKeys(schema: SerializedCollection): string[] {
-  return availableColumns(schema)
-    .filter((c) => {
-      if (c.key === 'id') return false
-      if (c.type === 'field') return isDefaultFieldColumn(c.field!)
-      return true
-    })
-    .map((c) => c.key)
-}
-
-/** Project the requested keys onto the available columns: preserves the canonical column order and silently
- *  drops keys that no longer exist (e.g. a removed field still listed in a saved preference). */
-export function resolveVisibleColumns(available: ListColumn[], keys: string[]): ListColumn[] {
-  const wanted = new Set(keys)
-  return available.filter((c) => wanted.has(c.key))
-}