@appinternalleads/ui 0.2.0

package/src/fields/ToggleField.tsx

@@ -0,0 +1,72 @@
+import { Box, Icon, Pressable, Switch, Text } from '../core';
+import { useDs } from '../tokens';
+import { resolveHint } from './control';
+import { controlOf } from './control';
+import type { ToggleFieldSpec } from './types';
+
+/**
+ * `toggle`, as a switch or a checkbox.
+ *
+ * **This is the one field type whose label sits BESIDE the control, not above it**, so it does
+ * not use `FieldShell`. A switch under a label reads as a heading with an orphaned control; the
+ * label is the thing being switched, and putting it on the same line says so. The hint still
+ * goes underneath, where every other field puts it.
+ */
+export function ToggleField({
+  field,
+  value,
+  onChange,
+  error,
+}: {
+  field: ToggleFieldSpec;
+  value: boolean | undefined;
+  onChange: (next: boolean) => void;
+  error?: string;
+}) {
+  const { colors } = useDs();
+  const on = value ?? field.default ?? false;
+  const hint = resolveHint(field);
+  const checkbox = controlOf(field) === 'checkbox';
+
+  return (
+    <Box gap="s2">
+      <Box row align="center" justify="space-between" gap="s4">
+        <Text variant="label" nativeID={`${field.key}-label`}>
+          {field.label}
+        </Text>
+
+        {checkbox ? (
+          <Pressable
+            onPress={() => onChange(!on)}
+            hit={44}
+            aria-label={field.label}
+            /* The box is 22pt inside a 44pt target. The target is padding, not the mark. */
+            style={{ alignItems: 'flex-end' }}>
+            <Box
+              width={22}
+              height={22}
+              align="center"
+              justify="center"
+              radius="part.skeleton"
+              bg={on ? 'accentFill' : 'surface1'}
+              edge={on ? undefined : 'field'}>
+              {on ? <Icon name="tick" size={14} color={colors.accentOnFill} /> : null}
+            </Box>
+          </Pressable>
+        ) : (
+          <Switch value={on} onChange={onChange} aria-label={field.label} />
+        )}
+      </Box>
+
+      {error ? (
+        <Text variant="caption" color="status.error" accessibilityLiveRegion="polite">
+          {error}
+        </Text>
+      ) : hint ? (
+        <Text variant="caption" color="textSecondary">
+          {hint}
+        </Text>
+      ) : null}
+    </Box>
+  );
+}

package/src/fields/VariantField.tsx

@@ -0,0 +1,149 @@
+import { useState } from 'react';
+import { Box, Icon, Pressable, Scroll, Sheet, Text } from '../core';
+import { useDs } from '../tokens';
+import { FieldRenderer } from './FieldRenderer';
+import { controlOf, resolveHint } from './control';
+import type { FieldErrors, ResolvedOptions, VariantFieldSpec, VariantValue } from './types';
+
+/**
+ * `variant` — pick one branch, fill in that branch.
+ *
+ * **Each branch keeps its own answer when you switch away and back.** Discarding it would punish
+ * a user for looking at the other option, and looking is the entire point of a control that
+ * offers two. The tag alone moves; the payloads stay in a draft map.
+ *
+ * Only the selected branch is validated — the others are answers the user did not give, not
+ * answers they gave badly.
+ */
+export function VariantField({
+  field, value, onChange, error, errors, path, options,
+}: {
+  field: VariantFieldSpec;
+  value: VariantValue | undefined;
+  onChange: (next: VariantValue) => void;
+  error?: string;
+  errors?: FieldErrors;
+  path: string;
+  options?: ResolvedOptions;
+}) {
+  const { colors } = useDs();
+  const current = value ?? field.default;
+  const selected = field.children.find(c => c.key === current?.variant) ?? field.children[0];
+  const [drafts, setDrafts] = useState<Record<string, unknown>>(() =>
+    current?.variant ? { [current.variant]: current.value } : {},
+  );
+  const [open, setOpen] = useState(false);
+  const hint = resolveHint(field);
+
+  if (!selected) return null;
+
+  /**
+   * **A branch selector is named for the CHOICE, not the branch.** Unqualified, the tab and the
+   * field it reveals carry the same name — a screen reader reads "Email button" and then "Email
+   * textbox", and nothing says the first one switches and the second one collects.
+   */
+  const tabLabel = (label: string) => `${field.label}: ${label}`;
+
+  const pick = (key: string) => {
+    setOpen(false);
+    onChange({ variant: key, value: drafts[key] });
+  };
+
+  const setBranchValue = (next: unknown) => {
+    setDrafts(d => ({ ...d, [selected.key]: next }));
+    onChange({ variant: selected.key, value: next });
+  };
+
+  return (
+    <Box gap="s3" role="group" aria-label={field.label}>
+      <Box gap="s1">
+        <Text variant="eyebrow" color="textTertiary" uppercase>
+          {field.label}
+        </Text>
+        {error ? (
+          <Text variant="caption" color="status.error">
+            {error}
+          </Text>
+        ) : hint ? (
+          <Text variant="caption" color="textSecondary">
+            {hint}
+          </Text>
+        ) : null}
+      </Box>
+
+      {controlOf(field) === 'select' ? (
+        <>
+          <Pressable
+            onPress={() => setOpen(true)}
+            row
+            align="center"
+            justify="space-between"
+            px="s3"
+            py="s3"
+            radius="field"
+            bg="surface1"
+            aria-label={field.label}
+            style={{ minHeight: 44 }}>
+            <Text>{selected.label}</Text>
+            <Icon name="caretDown" size={14} color={colors.textTertiary} />
+          </Pressable>
+          <Sheet visible={open} onDismiss={() => setOpen(false)} testID={`${field.key}-sheet`}>
+            <Text variant="heading">{field.label}</Text>
+            <Scroll gap="s1">
+              {field.children.map(c => (
+                <Pressable
+                  key={c.key}
+                  onPress={() => pick(c.key)}
+                  row
+                  align="center"
+                  justify="flex-start"
+                  py="s3"
+                  px="s3"
+                  radius="row"
+                  bg={c.key === selected.key ? 'accentTint' : undefined}
+                  aria-label={tabLabel(c.label)}
+                  style={{ minHeight: 44 }}>
+                  <Text color={c.key === selected.key ? 'accentInk' : 'textPrimary'}>
+                    {c.label}
+                  </Text>
+                </Pressable>
+              ))}
+            </Scroll>
+          </Sheet>
+        </>
+      ) : (
+        /* Tabs. Visually a segmented control, but it switches a form SECTION rather than
+           picking a value — which is why it is not `EnumField`'s control reused. */
+        <Box row p="s1" gap="s1" radius="field" bg="surfaceSunken" role="group">
+          {field.children.map(c => {
+            const on = c.key === selected.key;
+            return (
+              <Pressable
+                key={c.key}
+                onPress={() => pick(c.key)}
+                py="s2"
+                px="s3"
+                radius="chip"
+                bg={on ? 'surface1' : undefined}
+                aria-label={tabLabel(c.label)}
+                style={{ flex: 1 }}>
+                <Text variant="caption" color={on ? 'accentInk' : 'textSecondary'} numberOfLines={1}>
+                  {c.label}
+                </Text>
+              </Pressable>
+            );
+          })}
+        </Box>
+      )}
+
+      <FieldRenderer
+        field={selected}
+        path={`${path}.${selected.key}`}
+        value={drafts[selected.key]}
+        onChange={setBranchValue}
+        errors={errors}
+        options={options}
+      />
+    </Box>
+  );
+}

package/src/fields/answer.ts

@@ -0,0 +1,58 @@
+import type { AnswerBlock, Answers, QuestionBlockSpec } from './types';
+
+/**
+ * **Assemble the `answer/1` envelope.**
+ *
+ * Always the envelope, never a bare value (decision Q8b): an agent that cannot tell *skipped*
+ * from *never answered* will re-ask, or proceed as though it had an answer. It travels alone
+ * (Q9a) — the block is not echoed back, because whoever asked still has it.
+ *
+ * This is a helper, not a policy. The host decides when an ask is answered, skipped or failed;
+ * nothing here watches a widget and decides for it (Q7a).
+ */
+export function answerBlock(
+  block: QuestionBlockSpec,
+  answers: Answers,
+  opts: Partial<Omit<AnswerBlock, 'schema' | 'slug' | 'answers'>> = {},
+): AnswerBlock {
+  return {
+    schema: 'answer/1',
+    slug: block.slug,
+    at: opts.at ?? new Date().toISOString(),
+    state: opts.state ?? 'answered',
+    /* An `action` has no value — firing it IS the answer, and it lives in `outcome`. */
+    answers,
+    outcome: opts.outcome ?? 'accept',
+    ...(opts.rejection ? { rejection: opts.rejection } : {}),
+    ...(opts.overrode ? { overrode: opts.overrode } : {}),
+    ...(opts.degraded === undefined ? {} : { degraded: opts.degraded }),
+    ...(opts.superseded === undefined ? {} : { superseded: opts.superseded }),
+  };
+}
+
+/**
+ * The user chose against a scored recommendation.
+ *
+ * Worth recording precisely because the system was wrong — a run that never learns which of its
+ * rankings get overturned keeps making the same one.
+ */
+export function overrode(
+  chose: string,
+  over: string,
+  score?: number,
+): NonNullable<AnswerBlock['overrode']> {
+  return score === undefined ? { chose, over } : { chose, over, score };
+}
+
+/**
+ * **Re-opening an answered ask.**
+ *
+ * ⚠ This sets a flag. **What it means is the host's obligation, not this library's** — on
+ * `superseded: true` the host must treat every downstream step derived from that answer as
+ * invalid, re-plan from this ask rather than resuming after it, and keep the previous answer
+ * because *what changed* is often the useful part. Nothing here can enforce any of that; see
+ * `spec/QUESTION-SCHEMA.md` §12.
+ */
+export function supersede(previous: AnswerBlock): AnswerBlock {
+  return { ...previous, state: 'superseded', superseded: true, at: new Date().toISOString() };
+}

package/src/fields/control.ts

@@ -0,0 +1,357 @@
+import type {
+  Answers, FieldErrors, FieldSpec, FieldType, ListFieldSpec, OptionEntry, QuestionBlockSpec,
+  ResolvedOptions, VariantValue,
+} from './types';
+
+/**
+ * The spec one element of a list is validated and rendered against.
+ *
+ * Synthesised rather than declared, because a list states its element type once and its elements
+ * are positional. The key is the index, so a nested error lands at `tags.2` — the same dotted
+ * path the renderer looks itself up by.
+ */
+export function itemSpec(field: ListFieldSpec, index: number): FieldSpec {
+  return {
+    key: String(index),
+    type: field.itemType ?? 'text',
+    label: `${field.label} ${index + 1}`,
+    options: field.options,
+    source: field.source,
+  } as FieldSpec;
+}
+
+/**
+ * The default control for each type, so a spec that omits `control` still renders.
+ *
+ * This table and §5 of `spec/QUESTION-SCHEMA.md` are the same table. The schema's `default`
+ * keywords are documentation — ajv does not apply defaults unless asked, and relying on it to
+ * would put the fallback in the validator rather than in the renderer, which is the one place
+ * it is always needed.
+ */
+export const DEFAULT_CONTROL: Record<FieldType, string> = {
+  text: 'single',
+  email: 'single',
+  number: 'single',
+  toggle: 'switch',
+  date: 'picker',
+  datetime: 'picker',
+  enum: 'select',
+  list: 'tags',
+  group: 'section',
+  variant: 'tabs',
+  json: 'code',
+  range: 'track',
+  counters: 'rows',
+  share: 'donut',
+  file: 'dropzone',
+  media: 'audio',
+  action: 'buttons',
+};
+
+/**
+ * **The `preferred` hint, resolved.** Returns the widget a spec asks for, or `undefined`.
+ *
+ * A hint is honoured only when it is legal for the field's own type and control (decision Q2b).
+ * An illegal one is **dropped, not rejected** — that is the whole safety property: a stored
+ * `preferred` that a later schema change makes illegal degrades to the derived widget instead of
+ * failing a question that was valid when it was written.
+ */
+export const LEGAL_PREFERRED: Partial<Record<FieldType, readonly string[]>> = {
+  text: ['text-input-field', 'text-field', 'text-area'],
+  email: ['text-input-field', 'text-field'],
+  number: ['slider', 'numerical-holder'],
+  enum: ['dropdown', 'radio-button', 'horizontal-list-picker', 'card-picker', 'arc-picker', 'checkboxes'],
+  date: ['date-time-picker'],
+  datetime: ['date-time-picker'],
+  range: ['range-picker'],
+  counters: ['counter-group'],
+  share: ['pie-chart-picker'],
+  file: ['file-upload'],
+  media: ['voice-recorder'],
+  action: ['button'],
+};
+
+export function preferredOf(field: FieldSpec): string | undefined {
+  const want = field.preferred;
+  if (!want) return undefined;
+  /* Multi-select cannot be drawn by a single-select widget, whatever the hint says. */
+  const multi = field.type === 'enum' && field.multiple === true;
+  const singleOnly = ['dropdown', 'radio-button', 'arc-picker', 'horizontal-list-picker'];
+  if (multi && singleOnly.includes(want)) return undefined;
+  if (!multi && want === 'checkboxes') return undefined;
+  return LEGAL_PREFERRED[field.type]?.includes(want) ? want : undefined;
+}
+
+export function controlOf(field: FieldSpec): string {
+  return field.control ?? DEFAULT_CONTROL[field.type];
+}
+
+/**
+ * Interpolate `{default}` and `{constraints.*}` into a hint.
+ *
+ * The copy that motivated this read *"Top 10 of 47 will be shown for review"* with both numbers
+ * written out — correct exactly until someone changes `max`, and then it is a lie that nothing
+ * detects. An unresolvable reference is left visible as `{whatever}` rather than blanked: a
+ * broken template that shows its own braces gets noticed and fixed, one that silently renders
+ * an empty gap does not.
+ */
+/** `default` is absent on three of the seventeen types — a file, a recording and an action. */
+function defaultOf(field: FieldSpec): unknown {
+  return 'default' in field ? field.default : undefined;
+}
+
+export function resolveHint(field: FieldSpec): string | undefined {
+  if (!field.hint) return undefined;
+  return field.hint.replace(/\{([a-z]+(?:\.[a-zA-Z]+)?)\}/g, (whole, path: string) => {
+    if (path === 'default') {
+      const d = defaultOf(field);
+      return d === undefined ? whole : String(d);
+    }
+    const [head, tail] = path.split('.');
+    if (head === 'constraints' && tail) {
+      /* `in` rather than a cast: `toggle` genuinely has no `constraints`, and the union is
+         right to say so. A template referencing one on a toggle resolves to nothing and stays
+         visible, which is the same failure mode as any other unresolvable reference. */
+      const c = 'constraints' in field ? (field.constraints as Record<string, unknown>) : undefined;
+      const v = c?.[tail];
+      return v === undefined ? whole : String(v);
+    }
+    return whole;
+  });
+}
+
+/** A field renders only when every `showIf` entry matches the answers so far. */
+export function isVisible(field: FieldSpec, answers: Answers): boolean {
+  if (!field.showIf) return true;
+  return Object.entries(field.showIf).every(([k, v]) => answers[k] === v);
+}
+
+/** Seed answers from `default`. A field with no default starts absent, never as `''`. */
+export function initialAnswers(block: QuestionBlockSpec): Answers {
+  const out: Answers = {};
+  for (const f of block.fields) {
+    const d = defaultOf(f);
+    if (d !== undefined) out[f.key] = d;
+    /* `counters` seeds from its rows rather than from one `default` object, because each row
+       carries its own — and a row with no default still has to exist in the answer. */
+    if (f.type === 'counters' && d === undefined) {
+      out[f.key] = Object.fromEntries(f.rows.map(r => [r.key, r.default ?? 0]));
+    }
+  }
+  return out;
+}
+
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+/**
+ * UTF-8 byte length, without `TextEncoder`.
+ *
+ * **`TextEncoder` is not in React Native's type environment** — it exists at runtime on Hermes but
+ * `tsc` in an app with no DOM lib rejects it, which is exactly how this file failed the moment a
+ * consumer typechecked against the package. Counting the code points is portable and needs no lib.
+ */
+function utf8Bytes(s: string): number {
+  let n = 0;
+  for (const ch of s) {
+    const c = ch.codePointAt(0) ?? 0;
+    n += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
+  }
+  return n;
+}
+
+/**
+ * Runtime validation of one answer.
+ *
+ * The JSON Schema constrains what an AUTHOR may write; this constrains what a USER may enter.
+ * They are different jobs on the same keys, which is why `maxLength` appears in both and means
+ * something different in each.
+ *
+ * Returns an error string, or `undefined` when the value is acceptable.
+ */
+export function validateField(
+  field: FieldSpec,
+  value: unknown,
+  options?: string[],
+): string | undefined {
+  /* `false` is an ANSWER on a toggle, not an absence. Treating it as empty would make every
+     unchecked required checkbox unsubmittable while looking answered. */
+  const empty =
+    field.type === 'toggle'
+      ? value === undefined || value === null
+      : value === undefined || value === null || value === '';
+  if (empty && field.type !== 'group' && field.type !== 'variant') {
+    return field.required ? `${field.label} is required.` : undefined;
+  }
+
+  if (field.type === 'enum') {
+    const allowed = options ?? field.options;
+    /* No `options` and no resolved list means the host has not answered `source` yet. That is a
+       loading state, not an invalid answer — reporting it as one would blame the user for the
+       app's timing. */
+    if (!allowed) return undefined;
+
+    /**
+     * ⚠ **Normalised, because `options` and `field.options` are different shapes.**
+     *
+     * A resolved list is `string[]`; a spec's own list is `OptionEntry[]`, which is *either*
+     * bare strings or `{ value, label }` objects. Comparing against the raw array matched bare
+     * strings and never matched a rich option — so every `cards`, `chips` or noted `radio` field
+     * reported *"… is not one of the options"* for an answer that came from its own list.
+     * Measured on `15-horizontal-list-picker`: `default: 'balanced'`, an option with that exact
+     * value, and the block would not submit.
+     */
+    const values = (allowed as OptionEntry[]).map(o => (typeof o === 'string' ? o : o.value));
+
+    /**
+     * **`multiple` answers with an ARRAY, and each element is checked on its own.**
+     *
+     * `String(['maya','tobias'])` is `'maya,tobias'`, which is in no option list ever written —
+     * so a multi-select could not be valid at all. Decision Q3a put multi-select on `enum` as a
+     * flag; the validator had not followed it here.
+     */
+    if (field.multiple === true) {
+      if (!Array.isArray(value)) return `${field.label} is not one of the options.`;
+      return value.every(v => values.includes(String(v)))
+        ? undefined
+        : `${field.label} is not one of the options.`;
+    }
+
+    return values.includes(String(value)) ? undefined : `${field.label} is not one of the options.`;
+  }
+
+  if (field.type === 'group') {
+    /* A group has no error of its own — everything wrong with it is wrong with a child, and
+       reporting "Contact is required" above three fields that each say what they need is noise
+       stacked on top of the answer. */
+    return undefined;
+  }
+
+  if (field.type === 'variant') {
+    const v = value as VariantValue | undefined;
+    if (!v?.variant) return field.required ? `${field.label} is required.` : undefined;
+    return field.children.some(c => c.key === v.variant)
+      ? undefined
+      : `${field.label} is not one of the options.`;
+  }
+
+  if (field.type === 'list') {
+    const items = Array.isArray(value) ? value : [];
+    const { minItems, maxItems } = field.constraints ?? {};
+    if (minItems !== undefined && items.length < minItems) {
+      return `${field.label} needs at least ${minItems} ${minItems === 1 ? 'item' : 'items'}.`;
+    }
+    if (maxItems !== undefined && items.length > maxItems) {
+      return `${field.label} allows at most ${maxItems} ${maxItems === 1 ? 'item' : 'items'}.`;
+    }
+    return undefined;
+  }
+
+  if (field.type === 'date' || field.type === 'datetime') {
+    const s = String(value);
+    if (Number.isNaN(Date.parse(s))) return `${field.label} is not a valid date.`;
+    const { min, max } = field.constraints ?? {};
+    /* Compared as ISO STRINGS, not as Dates. ISO sorts lexicographically, and parsing a
+       date-only value to a Date drags in a timezone the field never had — which is how a date
+       one day inside the bound starts failing for users west of UTC. */
+    if (min !== undefined && s < min) return `${field.label} must be ${min} or later.`;
+    if (max !== undefined && s > max) return `${field.label} must be ${max} or earlier.`;
+    return undefined;
+  }
+
+  if (field.type === 'json') {
+    const s = String(value);
+    const max = field.constraints?.maxBytes;
+    if (max !== undefined && utf8Bytes(s) > max) {
+      return `${field.label} must be ${max} bytes or fewer.`;
+    }
+    try {
+      JSON.parse(s);
+    } catch {
+      return `${field.label} is not valid JSON.`;
+    }
+    return undefined;
+  }
+
+  if (field.type === 'text' || field.type === 'email') {
+    const s = String(value);
+    const c = field.constraints ?? {};
+    if ('minLength' in c && typeof c.minLength === 'number' && s.length < c.minLength) {
+      return `${field.label} must be at least ${c.minLength} characters.`;
+    }
+    if (typeof c.maxLength === 'number' && s.length > c.maxLength) {
+      return `${field.label} must be ${c.maxLength} characters or fewer.`;
+    }
+    if (field.type === 'email' && !EMAIL.test(s)) return 'Enter a valid email address.';
+    if ('pattern' in c && typeof c.pattern === 'string' && !new RegExp(c.pattern).test(s)) {
+      return `${field.label} is not in the expected format.`;
+    }
+    return undefined;
+  }
+
+  if (field.type === 'number') {
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n)) return `${field.label} must be a number.`;
+    const c = field.constraints ?? {};
+    if (typeof c.min === 'number' && n < c.min) return `${field.label} must be ${c.min} or more.`;
+    if (typeof c.max === 'number' && n > c.max) return `${field.label} must be ${c.max} or less.`;
+    return undefined;
+  }
+
+  return undefined;
+}
+
+/** Every error in the block, keyed by field. Skips fields hidden by `showIf`. */
+/**
+ * Validates one field and everything inside it, writing dotted paths into `out`.
+ *
+ * **A composite reports its own error AND its children's.** A list that is too short and whose
+ * second element is also invalid has two problems, and surfacing one at a time makes the user
+ * fix, resubmit, and discover the next — which is the slowest possible way to fill in a form.
+ */
+export function collectErrors(
+  field: FieldSpec,
+  value: unknown,
+  path: string,
+  options: ResolvedOptions | undefined,
+  out: FieldErrors,
+): void {
+  const own = validateField(field, value, options?.[path] ?? options?.[field.key]);
+  if (own) out[path] = own;
+
+  if (field.type === 'list') {
+    const items = Array.isArray(value) ? value : [];
+    items.forEach((item, i) => {
+      collectErrors(itemSpec(field, i), item, `${path}.${i}`, options, out);
+    });
+  }
+
+  if (field.type === 'group') {
+    const obj = (value ?? {}) as Record<string, unknown>;
+    for (const child of field.children) {
+      if (!isVisible(child, obj)) continue;
+      collectErrors(child, obj[child.key], `${path}.${child.key}`, options, out);
+    }
+  }
+
+  if (field.type === 'variant') {
+    /* **Only the SELECTED branch is validated.** The others are not incomplete answers, they
+       are answers the user did not give — reporting them would make every variant permanently
+       invalid no matter what was filled in. */
+    const v = value as VariantValue | undefined;
+    const child = field.children.find(c => c.key === v?.variant);
+    if (child) collectErrors(child, v?.value, `${path}.${child.key}`, options, out);
+  }
+}
+
+export function validateBlock(
+  block: QuestionBlockSpec,
+  answers: Answers,
+  options?: ResolvedOptions,
+): FieldErrors {
+  const errors: FieldErrors = {};
+  for (const f of block.fields) {
+    if (!isVisible(f, answers)) continue;
+    collectErrors(f, answers[f.key], f.key, options, errors);
+  }
+  return errors;
+}

package/src/fields/index.ts

@@ -0,0 +1,21 @@
+export { QuestionBlock, type QuestionBlockProps } from './QuestionBlock';
+export { TextInputField } from './TextInputField';
+export { NumberField } from './NumberField';
+export { ToggleField } from './ToggleField';
+export { EnumField } from './EnumField';
+export { JsonField } from './JsonField';
+export { DateField } from './DateField';
+export { ListField } from './ListField';
+export { GroupField } from './GroupField';
+export { VariantField } from './VariantField';
+export { FieldRenderer, type FieldRendererProps } from './FieldRenderer';
+export { FieldShell } from './FieldShell';
+export {
+  DEFAULT_CONTROL, LEGAL_PREFERRED, controlOf, collectErrors, initialAnswers, isVisible,
+  itemSpec, preferredOf, resolveHint, validateBlock, validateField,
+} from './control';
+export {
+  SOFT_FIELD_LIMIT, lintQuestion, type LintFinding, type LintLevel,
+} from './lint';
+export { answerBlock, overrode, supersede } from './answer';
+export * from './types';