@crombolo/server 0.10.0 → 0.12.1

package/src/form-files.ts

@@ -12,7 +12,7 @@
 
 import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
-import type { SchemaForm } from '@crombolo/core'
+import type { FormTypes, SchemaForm } from '@crombolo/core'
 import {
   fileNameFor,
   loadSchemaDirectory,
@@ -28,6 +28,8 @@ export interface FormFileOptions {
   writable: boolean
   /** Publishes the directory to a shared store, when there is one. */
   onChanged?: () => Promise<void>
+  /** The field and workflow types the site's wired bundles add. */
+  formTypes?: FormTypes
 }
 
 export type FormWriteResult =
@@ -77,6 +79,7 @@ export function coerceForm(value: unknown): SchemaForm {
     notes: text('notes'),
     storeEntries: flag('storeEntries', true),
     requiresApproval: flag('requiresApproval', false),
+    ...(body.stepPages === true ? { stepPages: true } : {}),
     submitLabel: text('submitLabel'),
     nextLabel: text('nextLabel'),
     previousLabel: text('previousLabel'),
@@ -140,6 +143,8 @@ function coerceField(value: unknown): Field {
     cssClass: text('cssClass'),
     autocomplete: text('autocomplete'),
     values: strings(body.values),
+    ...coerceSource(body.source),
+    ...coerceSettings(body.settings),
     placeholder: text('placeholder'),
     defaultValue: text('defaultValue'),
     content: text('content'),
@@ -155,6 +160,35 @@ function coerceField(value: unknown): Field {
   }
 }
 
+/** Kept as sent: the validator names a kind it does not know. */
+/** A bundle type's settings, kept as the designer sent them; the validator holds them to the declarations. */
+function coerceSettings(value: unknown): { settings?: Field['settings'] } {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {}
+  const settings: NonNullable<Field['settings']> = {}
+  for (const [key, entry] of Object.entries(value as Record<string, unknown>)) {
+    if (entry === '' || entry === null || entry === undefined) continue
+    if (
+      typeof entry === 'string' ||
+      typeof entry === 'boolean' ||
+      (typeof entry === 'number' && Number.isFinite(entry))
+    )
+      settings[key] = entry
+    else if (Array.isArray(entry)) settings[key] = entry.filter((item) => typeof item === 'string')
+  }
+  return Object.keys(settings).length > 0 ? { settings } : {}
+}
+
+function coerceSource(value: unknown): { source?: Field['source'] } {
+  if (!value || typeof value !== 'object') return {}
+  const body = value as Record<string, unknown>
+  return {
+    source: {
+      kind: String(body.kind ?? '') as NonNullable<Field['source']>['kind'],
+      parent: typeof body.parent === 'string' ? body.parent : '',
+    },
+  }
+}
+
 function coerceCondition(value: unknown): Field['condition'] {
   if (!value || typeof value !== 'object') return undefined
   const body = value as Record<string, unknown>
@@ -196,18 +230,19 @@ export async function saveForm(
   // Written then read back with the strict parser, so the file the designer
   // would produce is held to exactly what a hand-written one is.
   const name = formFileName(candidate.alias || 'form')
-  const reparsed = parseForm(`schema/forms/${name}`, writeForm(candidate))
+  const reparsed = parseForm(`schema/forms/${name}`, writeForm(candidate), options.formTypes)
   if (!reparsed.value) return { ok: false, status: 'invalid', problems: reparsed.problems }
   const form = reparsed.value
 
   // Against the whole set, because an alias has to be unique across forms and a
   // workflow is held to a content type that exists.
-  const loaded = loadSchemaDirectory(options.schemaDir)
+  const loaded = loadSchemaDirectory(options.schemaDir, { formTypes: options.formTypes })
   const others = (loaded.set.forms ?? []).filter(
     (candidate) => candidate.alias.toLowerCase() !== form.alias.toLowerCase(),
   )
   const problems = validateForms([...others, form], {
     contentTypeAliases: new Set(loaded.set.contentTypes.map((type) => type.alias)),
+    types: options.formTypes,
   })
   if (problems.length > 0) return { ok: false, status: 'invalid', problems }
 

package/src/form-submit.ts

@@ -18,13 +18,16 @@
  */
 import {
   allFormFields,
+  BUILT_IN_FORM_TYPES,
   DEFAULT_UPLOAD_SETTINGS,
   FORM_HONEYPOT_FIELD,
+  FORM_PAGE_FIELD,
   FORM_RENDERED_FIELD,
   FORM_RESERVED_FIELDS,
   FORM_TOKEN_FIELD,
   type FormFieldError,
   type FormSubmissionState,
+  type FormTypes,
   isUploadAllowed,
   type SchemaForm,
   type SubmittedValues,
@@ -58,6 +61,8 @@ export interface FormRegistry {
   byKey(key: string): SchemaForm | undefined
   /** Drops the memo, for a test or after a schema write. */
   invalidate(): void
+  /** The field and workflow types the forms were read with. */
+  readonly types: FormTypes
 }
 
 /**
@@ -70,8 +75,9 @@ export interface FormRegistry {
  */
 export function createFormRegistry(
   schemaDir: string,
-  options: { ttlMs?: number } = {},
+  options: { ttlMs?: number; formTypes?: FormTypes } = {},
 ): FormRegistry {
+  const types = options.formTypes ?? BUILT_IN_FORM_TYPES
   const ttl = options.ttlMs ?? 1000
   let at = 0
   let forms: readonly SchemaForm[] = []
@@ -80,7 +86,7 @@ export function createFormRegistry(
   const refresh = () => {
     if (at !== 0 && Date.now() - at < ttl) return
     try {
-      forms = loadSchemaDirectory(schemaDir).set.forms ?? []
+      forms = loadSchemaDirectory(schemaDir, { formTypes: types }).set.forms ?? []
       byKey = new Map(forms.map((form) => [form.key ?? form.alias, form]))
     } catch (error) {
       // A broken schema directory fails the boot, so reaching here means it
@@ -105,6 +111,7 @@ export function createFormRegistry(
     invalidate() {
       at = 0
     },
+    types,
   }
 }
 
@@ -206,6 +213,8 @@ export interface FormSubmitDeps {
   uploads?: UploadSettings
   /** Resolves a document key to the URL to send the visitor to. */
   urlOf?: (key: string) => Promise<string | undefined>
+  /** Fills in the options of choices drawn from a source, as the page rendered them. */
+  resolveForm?: (form: SchemaForm) => Promise<SchemaForm>
 }
 
 export type FormSubmitOutcome =
@@ -213,6 +222,8 @@ export type FormSubmitOutcome =
   | { status: 'badToken' }
   | { status: 'full'; form: SchemaForm }
   | { status: 'invalid'; form: SchemaForm; state: FormSubmissionState }
+  /** One page of a stepped form checked; nothing was stored, uploaded or run. */
+  | { status: 'checked'; form: SchemaForm; errors: FormFieldError[] }
   | {
       status: 'ok'
       form: SchemaForm
@@ -255,8 +266,9 @@ export async function submitForm(
   formKey: string,
   options: { ip?: string; now?: number } = {},
 ): Promise<FormSubmitOutcome> {
-  const form = deps.forms.byKey(formKey)
-  if (!form) return { status: 'notFound' }
+  const definition = deps.forms.byKey(formKey)
+  if (!definition) return { status: 'notFound' }
+  const form = deps.resolveForm ? await deps.resolveForm(definition) : definition
 
   const secret = await formSigningSecret(deps.db)
   const data = await request.formData()
@@ -268,6 +280,10 @@ export async function submitForm(
   // submission without a good one did not come from a page this site rendered.
   if (!verifyFormToken(secret, formKey, renderedAt, token)) return { status: 'badToken' }
 
+  // A stepped form moving forward: this page's answers checked, and nothing else.
+  const checking = data.get(FORM_PAGE_FIELD)
+  if (checking !== null) return checkPage(deps, form, data, Number(checking))
+
   // Two guards, both silent. A bot is told the submission worked, because
   // telling it otherwise is how it learns to get past them.
   const honeypot = String(data.get(FORM_HONEYPOT_FIELD) ?? '').trim() !== ''
@@ -317,7 +333,7 @@ export async function submitForm(
     if (placed.length > 0) submitted[field.alias] = placed
   }
 
-  const result = validateSubmission(form, submitted)
+  const result = validateSubmission(form, submitted, { types: deps.forms.types })
   // What the file rules refused, which core cannot know: it has no notion of a
   // file's bytes or of what a server could be made to execute.
   result.errors.push(...refusedUploads)
@@ -388,6 +404,47 @@ export async function submitForm(
   }
 }
 
+/**
+ * One page of a stepped form, checked the way the final submission will be.
+ * An upload is judged by its name and size and then dropped: it is written
+ * nowhere until the form is submitted.
+ */
+function checkPage(
+  deps: FormSubmitDeps,
+  form: SchemaForm,
+  data: FormData,
+  page: number,
+): FormSubmitOutcome {
+  const fields = form.pages[page]?.groups.flatMap((group) => group.fields)
+  if (!fields) return { status: 'checked', form, errors: [] }
+  const onPage = new Set(fields.map((field) => field.alias))
+  const submitted = readBody(data)
+  const errors: FormFieldError[] = []
+  for (const field of fields.filter((candidate) => candidate.type === 'fileUpload')) {
+    const files = data.getAll(field.alias).filter((value): value is File => value instanceof File)
+    const name = field.caption || field.alias
+    const named: string[] = []
+    for (const file of files) {
+      if (file.size === 0) continue
+      if (!isUploadAllowed(file.name, deps.uploads ?? DEFAULT_UPLOAD_SETTINGS))
+        errors.push({
+          field: field.alias,
+          message: `${name} cannot be a ${extensionOf(file.name)} file`,
+        })
+      else if (field.maxSizeKb !== undefined && file.size > field.maxSizeKb * 1024)
+        errors.push({
+          field: field.alias,
+          message: `${name} must be smaller than ${field.maxSizeKb}KB`,
+        })
+      else named.push(file.name)
+    }
+    submitted[field.alias] = named
+  }
+  const result = validateSubmission(form, submitted, { page, types: deps.forms.types })
+  errors.push(...result.errors.filter((error) => onPage.has(error.field)))
+  return { status: 'checked', form, errors }
+}
+
 /** Whether the caller wants JSON rather than a redirect back to the page. */
 export function wantsJson(request: Request): boolean {
   if (request.headers.get('x-requested-with') === 'fetch') return true

package/src/form-types.ts

@@ -0,0 +1,187 @@
+/**
+ * The public contract for a form field type or workflow type a server bundle
+ * adds (story 095, `docs/forms.md`, "Types from a bundle"). A bundle exports
+ * definitions; `collectFormTypes` turns the wired bundles' into the registry
+ * the parser, validator, renderer and runner are handed.
+ */
+import {
+  BUILT_IN_FORM_TYPES,
+  type FormSettingDeclaration,
+  type FormSettingValue,
+  type FormTypes,
+  formTypesWith,
+} from '@crombolo/core'
+import type { FormFieldRenderer } from '@crombolo/render'
+import type { EmailMessage, EmailResult } from './email.ts'
+
+export type { FormFieldRenderer, FormFieldRenderProps } from '@crombolo/render'
+export type { FormSettingDeclaration, FormSettingValue }
+
+/** A field type: what its settings are, how its value is checked, and how it draws. */
+export interface FormFieldTypeDefinition {
+  /** camelCase, unique across the built-ins and every wired bundle. */
+  type: string
+  /** What the designer's type list calls it. */
+  label: string
+  /**
+   * Which built-in kind it stores as, which decides coercion and the entry: a
+   * value is always a list of strings, so entries, exports and workflows read it
+   * as they read any other field. `none` collects nothing, as a heading does.
+   */
+  stores: 'string' | 'strings' | 'number' | 'boolean' | 'none'
+  /** Whether it takes a choice list (`values` or a `source`). */
+  choices?: boolean
+  /** Edited in the designer from these, and held to them in the file. */
+  settings?: readonly FormSettingDeclaration[]
+  /** After the kind's own checks: a message when the value is wrong. */
+  validate?(
+    values: readonly string[],
+    settings: Readonly<Record<string, FormSettingValue>>,
+  ): string | undefined
+  /** The control, in the form's markup. The label, help and error are drawn around it. */
+  render: FormFieldRenderer
+}
+
+/** What a bundle's workflow handler is given: the submission and narrow capabilities, no database. */
+export interface FormWorkflowRunContext {
+  form: { key: string; alias: string; name: string }
+  /** Each stored field's values, by alias; with labels where a field's choices have them. */
+  values: Readonly<Record<string, readonly string[]>>
+  labels: Readonly<Record<string, readonly string[]>>
+  entryId: string | null
+  settings: Readonly<Record<string, unknown>>
+  /** Which attempt this is, from 1; the queue makes up to five. */
+  attempt: number
+  /** Aborted with `signal` unless the call passes its own. */
+  fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>
+  /** Answers `ok: false` when the site has no e-mail configured. */
+  sendEmail(message: EmailMessage): Promise<EmailResult>
+  log: {
+    info(message: string, properties?: Record<string, unknown>): void
+    warn(message: string, properties?: Record<string, unknown>): void
+    error(message: string, properties?: Record<string, unknown>): void
+  }
+  /** Aborted when the run has taken too long. */
+  signal: AbortSignal
+}
+
+/**
+ * Done, or failed: `retry` true tries again on the built-ins' backoff (1, 5, 15
+ * and 60 minutes, five attempts in all), false gives up at once. A throw counts
+ * as a failure worth retrying.
+ */
+export type FormWorkflowRunResult =
+  | { ok: true; detail?: string }
+  | { ok: false; error: string; retry: boolean }
+
+export interface FormWorkflowTypeDefinition {
+  type: string
+  label: string
+  settings?: readonly FormSettingDeclaration[]
+  /** Across its settings, after the declarations pass: a message when they are wrong. */
+  validate?(settings: Readonly<Record<string, unknown>>): string | undefined
+  run(context: FormWorkflowRunContext): FormWorkflowRunResult | Promise<FormWorkflowRunResult>
+}
+
+/** What a server bundle's `forms` adds. */
+export interface BundleForms {
+  fields?: readonly FormFieldTypeDefinition[]
+  workflows?: readonly FormWorkflowTypeDefinition[]
+}
+
+export interface CollectedFormTypes {
+  types: FormTypes
+  renderers: ReadonlyMap<string, FormFieldRenderer>
+  workflows: ReadonlyMap<string, FormWorkflowTypeDefinition>
+  problems: string[]
+}
+
+const STORES = new Set(['string', 'strings', 'number', 'boolean', 'none'])
+
+/** Every wired bundle's form types, merged over the built-ins, or why they cannot be. Pure. */
+export function collectFormTypes(
+  bundles: readonly { id: string; forms?: BundleForms }[],
+): CollectedFormTypes {
+  let types = BUILT_IN_FORM_TYPES
+  const renderers = new Map<string, FormFieldRenderer>()
+  const workflows = new Map<string, FormWorkflowTypeDefinition>()
+  const problems: string[] = []
+  for (const bundle of bundles) {
+    const forms = bundle.forms
+    if (!forms) continue
+    const fields = (forms.fields ?? []).filter((field) => {
+      if (STORES.has(field.stores) && typeof field.render === 'function') return true
+      problems.push(
+        `The bundle "${bundle.id}"'s field type "${field.type}" needs a render function and stores of string, strings, number, boolean or none.`,
+      )
+      return false
+    })
+    const added = formTypesWith(types, bundle.id, {
+      fields: fields.map((field) => ({
+        type: field.type,
+        label: field.label,
+        stores: field.stores,
+        choices: field.choices ?? false,
+        presentational: field.stores === 'none',
+        declared: field.settings ?? [],
+        validate: field.validate,
+      })),
+      workflows: (forms.workflows ?? []).map((workflow) => ({
+        type: workflow.type,
+        label: workflow.label,
+        declared: workflow.settings ?? [],
+        validate: workflow.validate,
+      })),
+    })
+    problems.push(...added.problems)
+    types = added.types
+    for (const field of fields)
+      if (types.fields.get(field.type)?.bundle === bundle.id)
+        renderers.set(field.type, field.render)
+    for (const workflow of forms.workflows ?? [])
+      if (types.workflows.get(workflow.type)?.bundle === bundle.id)
+        workflows.set(workflow.type, workflow)
+  }
+  return { types, renderers, workflows, problems }
+}
+
+const collected = new WeakMap<readonly unknown[], CollectedFormTypes>()
+const NONE: readonly { id: string; forms?: BundleForms }[] = []
+
+/** The form types a site's wired bundles add, worked out once per bundle list. */
+export function formTypesOf(config: {
+  bundles?: readonly { id: string; forms?: BundleForms }[]
+}): CollectedFormTypes {
+  const bundles = config.bundles ?? NONE
+  const known = collected.get(bundles)
+  if (known) return known
+  const result = collectFormTypes(bundles)
+  collected.set(bundles, result)
+  return result
+}
+
+/** As `formTypesOf`, the registry alone: what schema loading and validation take. */
+export const formTypesFor = (config: {
+  bundles?: readonly { id: string; forms?: BundleForms }[]
+}): FormTypes => formTypesOf(config).types
+
+/** The types as the designer reads them: what each is called, stores, and which settings it edits. */
+export function describeFormTypes(types: FormTypes) {
+  return {
+    fields: [...types.fields.values()].map((info) => ({
+      type: info.type,
+      label: info.label,
+      stores: info.stores,
+      choices: info.choices,
+      presentational: info.presentational,
+      settings: info.declared,
+      builtIn: info.bundle === undefined,
+    })),
+    workflows: [...types.workflows.values()].map((info) => ({
+      type: info.type,
+      label: info.label,
+      settings: info.declared,
+      builtIn: info.bundle === undefined,
+    })),
+  }
+}

package/src/form-workflows.ts

@@ -26,6 +26,7 @@ import {
   type NodeSchemaState,
 } from '@crombolo/data'
 import type { EmailAttachment, EmailPort } from './email.ts'
+import type { FormWorkflowTypeDefinition } from './form-types.ts'
 import { logger } from './logging.ts'
 import type { MediaFileStore } from './media-files.ts'
 
@@ -40,8 +41,13 @@ export interface WorkflowContext {
   form: SchemaForm
   values: readonly FormValueToStore[]
   entryId: string | null
+  /** Which attempt this is, from 1. */
+  attempt?: number
 }
 
+/** How long a bundle's workflow may run before its signal aborts. */
+const BUNDLE_WORKFLOW_TIMEOUT_MS = 60_000
+
 export interface WorkflowDeps {
   db: Db
   /** Absent when the site has no e-mail; a `sendEmail` workflow then says so. */
@@ -52,6 +58,8 @@ export interface WorkflowDeps {
   nodeId?: string
   /** Told when a workflow published something, so the cache is dropped. */
   onContentChanged?: () => void
+  /** The workflow types wired bundles add, by type. */
+  bundleWorkflows?: ReadonlyMap<string, FormWorkflowTypeDefinition>
 }
 
 export type WorkflowResult =
@@ -61,10 +69,13 @@ export type WorkflowResult =
 
 // ------------------------------------------------------------------ substitution
 
-const firstValue = (values: readonly FormValueToStore[], alias: string): string =>
-  values
-    .find((value) => value.fieldAlias.toLowerCase() === alias.toLowerCase())
-    ?.values.join(', ') ?? ''
+/** What a person reads for a value: the label a visitor chose, for a choice from a source. */
+const shown = (value: FormValueToStore): string[] => value.labels ?? value.values
+
+const firstValue = (values: readonly FormValueToStore[], alias: string): string => {
+  const found = values.find((value) => value.fieldAlias.toLowerCase() === alias.toLowerCase())
+  return found ? shown(found).join(', ') : ''
+}
 
 /**
  * `{fieldAlias}` in a workflow setting becomes what was submitted for it.
@@ -79,7 +90,7 @@ export function substitute(text: string, values: readonly FormValueToStore[]): s
     const found = values.find((value) => value.fieldAlias.toLowerCase() === alias.toLowerCase())
     // An unknown alias is left as it was written, so a stray brace in a subject
     // line reads as itself rather than vanishing.
-    return found ? found.values.join(', ') : whole
+    return found ? shown(found).join(', ') : whole
   })
 }
 
@@ -102,7 +113,7 @@ export function plainSummary(context: WorkflowContext): string {
   const lines = context.values.map(
     (value) =>
       `${captions.get(value.fieldAlias) ?? value.fieldAlias}: ${
-        value.values.length > 0 ? value.values.join(', ') : '(not answered)'
+        value.values.length > 0 ? shown(value).join(', ') : '(not answered)'
       }`,
   )
   return [`${context.form.name}`, '', ...lines].join('\n')
@@ -298,6 +309,54 @@ export async function runWorkflow(
     case 'sendToUrl':
       return sendToUrl(workflow, context, deps)
   }
+  const bundled = deps.bundleWorkflows?.get(workflow.type)
+  if (!bundled)
+    return {
+      ok: false,
+      retry: false,
+      error: `No wired bundle provides the workflow type "${workflow.type}".`,
+    }
+  return runBundleWorkflow(bundled, workflow, context, deps)
+}
+
+/** A bundle's handler, given the submission and narrow capabilities rather than the deps. */
+async function runBundleWorkflow(
+  definition: FormWorkflowTypeDefinition,
+  workflow: SchemaFormWorkflow,
+  context: WorkflowContext,
+  deps: WorkflowDeps,
+): Promise<WorkflowResult> {
+  const values: Record<string, readonly string[]> = {}
+  const labels: Record<string, readonly string[]> = {}
+  for (const value of context.values) {
+    values[value.fieldAlias] = value.values
+    if (value.labels) labels[value.fieldAlias] = value.labels
+  }
+  const named = logger('forms', workflow.type)
+  const signal = AbortSignal.timeout(BUNDLE_WORKFLOW_TIMEOUT_MS)
+  return definition.run({
+    form: {
+      key: context.form.key ?? context.form.alias,
+      alias: context.form.alias,
+      name: context.form.name,
+    },
+    values,
+    labels,
+    entryId: context.entryId,
+    settings: workflow.settings,
+    attempt: context.attempt ?? 1,
+    fetch: (input, init) => (deps.fetch ?? fetch)(input, { signal, ...init }),
+    sendEmail: async (message) =>
+      deps.email
+        ? deps.email.send(message)
+        : { ok: false, error: 'This site has no e-mail set up.' },
+    log: {
+      info: (message, properties) => named.info(message, properties),
+      warn: (message, properties) => named.warn(message, properties),
+      error: (message, properties) => named.error(message, properties),
+    },
+    signal,
+  })
 }
 
 export interface WorkflowRunReport {
@@ -344,6 +403,7 @@ export function createWorkflowRunner(
       form,
       values: run.payload,
       entryId: run.entryId,
+      attempt: run.attempts,
     }
     let result: WorkflowResult
     try {

package/src/forms.ts

@@ -10,6 +10,7 @@
  * what a render would use.
  */
 
+import type { FormTypes } from '@crombolo/core'
 import type { FormEntryState } from '@crombolo/data'
 import { allFormFields, type SchemaForm, storingFormFields } from '@crombolo/schema'
 
@@ -26,14 +27,14 @@ export interface FormSummary {
   workflowCount: number
 }
 
-export function formSummary(form: SchemaForm): FormSummary {
+export function formSummary(form: SchemaForm, types?: FormTypes): FormSummary {
   return {
     // A form with no key in its file still has to be addressable, and its alias
     // is unique within the set, so it stands in until a key is written.
     key: form.key ?? form.alias,
     alias: form.alias,
     name: form.name,
-    fieldCount: storingFormFields(form).length,
+    fieldCount: storingFormFields(form, types).length,
     pageCount: form.pages.length,
     storeEntries: form.storeEntries,
     requiresApproval: form.requiresApproval,
@@ -59,6 +60,7 @@ export function formDetail(form: SchemaForm): Record<string, unknown> {
       mandatory: field.mandatory,
       sensitive: field.sensitive,
       values: field.values,
+      source: field.source ?? null,
     })),
     workflows: form.workflows.map((workflow) => ({
       type: workflow.type,
@@ -82,10 +84,10 @@ export function formsByKey(forms: readonly SchemaForm[]): Map<string, SchemaForm
  * not allowed them, so the redaction is on the way out of the server.
  */
 export function redactSensitive(
-  entry: { values: { fieldAlias: string; values: string[] }[] },
+  entry: { values: { fieldAlias: string; values: string[]; labels?: string[] }[] },
   form: SchemaForm | undefined,
   maySeeSensitive: boolean,
-): { fieldAlias: string; values: string[]; redacted: boolean }[] {
+): { fieldAlias: string; values: string[]; labels?: string[]; redacted: boolean }[] {
   const sensitive = new Set(
     (form ? allFormFields(form) : [])
       .filter((field) => field.sensitive)
@@ -96,6 +98,7 @@ export function redactSensitive(
     return {
       fieldAlias: value.fieldAlias,
       values: hide ? [] : value.values,
+      ...(value.labels && !hide ? { labels: value.labels } : {}),
       redacted: hide,
     }
   })
@@ -117,6 +120,8 @@ function csvCell(value: string): string {
 }
 
 export interface EntriesCsvOptions {
+  /** The field types in play, so a bundle's type that collects nothing gets no column. */
+  types?: FormTypes
   /** Without it, a sensitive column is refused rather than silently blank. */
   includeSensitive: boolean
 }
@@ -138,11 +143,11 @@ export function entriesCsv(
     createDate: Date
     state: string
     spam: boolean
-    values: { fieldAlias: string; values: string[] }[]
+    values: { fieldAlias: string; values: string[]; labels?: string[] }[]
   }[],
   options: EntriesCsvOptions,
 ): EntriesCsvResult {
-  const fields = storingFormFields(form)
+  const fields = storingFormFields(form, options.types)
   const sensitive = fields.filter((field) => field.sensitive)
   if (sensitive.length > 0 && !options.includeSensitive)
     return {
@@ -158,7 +163,10 @@ export function entriesCsv(
     entry.state,
     String(entry.spam),
     ...fields.map((field) =>
-      (entry.values.find((value) => value.fieldAlias === field.alias)?.values ?? []).join('; '),
+      (() => {
+        const value = entry.values.find((candidate) => candidate.fieldAlias === field.alias)
+        return (value?.labels ?? value?.values ?? []).join('; ')
+      })(),
     ),
   ])
   return {

package/src/index.ts

@@ -1,8 +1,10 @@
+export * from './adapters/audit.ts'
 export * from './adapters/blueprints.ts'
 export * from './adapters/bundles.ts'
 export * from './adapters/content.ts'
 export * from './adapters/documents.ts'
 export * from './adapters/elements.ts'
+export * from './adapters/health.ts'
 export * from './adapters/media.ts'
 export * from './adapters/member-groups.ts'
 export * from './adapters/members.ts'
@@ -11,10 +13,12 @@ export * from './adapters/redirects.ts'
 export * from './adapters/references.ts'
 export * from './adapters/template-files.ts'
 export * from './backup.ts'
+export * from './boot-failure.ts'
 export * from './bundle-install.ts'
 export * from './bundle-sections.ts'
 export * from './bundle-tables.ts'
 export * from './bundles.ts'
+export * from './busy.ts'
 export * from './components.ts'
 export * from './config.ts'
 export * from './content-type-udt.ts'
@@ -33,6 +37,7 @@ export * from './extensions-notice.ts'
 export * from './file-intake.ts'
 export * from './form-files.ts'
 export * from './form-submit.ts'
+export * from './form-types.ts'
 export * from './form-workflows.ts'
 export * from './forms.ts'
 export * from './git.ts'
@@ -57,9 +62,16 @@ export * from './ports.ts'
 export * from './redirects.ts'
 export * from './schema.ts'
 export * from './schema-store.ts'
+export * from './secrets.ts'
 export * from './seo.ts'
 export * from './server.ts'
 export * from './server-events.ts'
+export * from './setup.ts'
 export * from './status.ts'
+export * from './transfer-dashboard.ts'
 export * from './udt.ts'
+export * from './upgrade-summary.ts'
+export * from './url-settings.ts'
 export * from './view-runtime.ts'
+export * from './webhook-files.ts'
+export * from './webhooks.ts'