@flamingo-stack/openframe-frontend-core 0.0.664-snapshot.20260924171334 → 0.0.664

package/src/schemas/meeting-booking-schema.ts

@@ -86,25 +86,12 @@ export interface SchedulingLinksPayload {
   fetchedAt: string;
 }
 
-/**
- * One declared question as the host forwards it. `type` is HubSpot's
- * `fieldType` (the control HubSpot draws: `phonenumber`, `booleancheckbox`…)
- * VERBATIM, and `dataType` its `type` (the stored value's kind: `string`,
- * `enumeration`, `phone_number`…). Neither is a closed set: the widget resolves
- * ANY pair to a control through `resolveFormFieldControl`, so a type HubSpot
- * adds tomorrow renders as the nearest control instead of taking the form down.
- */
 export interface MeetingFormField {
   name: string;
   label: string;
   type: string;
-  /** HubSpot's property data type — the fallback when `type` is unknown. Optional: older hosts omit it. */
-  dataType?: string;
   required: boolean;
-  /** Option VALUES (what is submitted). */
   options?: string[];
-  /** Option value → display label, when HubSpot's label differs from the value. */
-  optionLabels?: Record<string, string>;
 }
 
 /**
@@ -171,25 +158,22 @@ export type MeetingBookingErrorCode = (typeof MEETING_BOOKING_ERROR_CODES)[numbe
 // ---------------------------------------------------------------------------
 
 /**
- * THE registry of CONTROLS the native form can draw — one entry per control,
- * and the ONLY place a control is declared. Everything else derives from it:
- * `SupportedFormFieldType` is its key union, `SUPPORTED_FORM_FIELD_TYPES` its
- * keys, and `makeBookingSchema` maps each answer through the entry's
- * validator. The widget's control table (`booking-form.tsx`) is a `Record`
- * over the same key union, so a control added here without a renderer is a
- * COMPILE error, not a silent gap.
+ * THE registry of HubSpot question types the native form supports — one entry
+ * per `fieldType`, and the ONLY place a type is declared. Everything else
+ * derives from it: `SupportedFormFieldType` is its key union,
+ * `SUPPORTED_FORM_FIELD_TYPES` its keys, `FORM_FIELD_TYPES_WITH_OPTIONS` the
+ * entries that carry `options`, and `makeBookingSchema` maps each answer
+ * through the entry's validator. The widget's control table
+ * (`booking-form.tsx`) is a `Record` over the same key union, so a type added
+ * here without a control is a COMPILE error, not a silent gap.
  *
- * These are controls, NOT HubSpot's type vocabulary. A HubSpot question
- * reaches a control through `resolveFormFieldControl` (exact `fieldType`, then
- * its data type, then a generic fallback), so the open set of HubSpot types
- * maps onto this closed set of controls and no type is ever "unsupported".
- * The one thing that still falls back to HubSpot's own page is a REQUIRED
- * question no control can answer (a file upload) — see `blocksNativeBooking`.
+ * Fail-closed: a `fieldType` with no entry makes the link "not natively
+ * bookable" and the card falls back to the HubSpot escape hatch.
  *
- * Every string control rides the wire as a STRING (HubSpot's book endpoint
- * takes `{ name, value: string }`); `checkbox` is the one boolean. `number` is
- * a decimal literal, `multiselect` HubSpot's `;`-joined enumeration value,
- * `date` an ISO `YYYY-MM-DD`.
+ * Every string type rides the wire as a STRING (HubSpot's book endpoint takes
+ * `{ name, value: string }`); `checkbox` is the one boolean. `number` is a
+ * Number property validated as a decimal literal — what `<input type="number">`
+ * emits and what the property stores.
  */
 export interface FormFieldTypeSpec {
   /** The answer's wire shape, which also decides how required/optional wraps it. */
@@ -215,32 +199,6 @@ const optionValidator: FormFieldTypeSpec['validator'] = (field, base) =>
 /** The wire shape of a number answer — what the form canonicalises TO and the validator checks. */
 export const DECIMAL_LITERAL_RE = /^-?\d+(\.\d+)?$/;
 
-/** HubSpot's separator for a multi-value enumeration (`a;b;c`). */
-export const MULTI_VALUE_SEPARATOR = ';';
-
-/** Split a multiselect answer into its values (empty string → none). */
-export const splitMultiValue = (value: unknown): string[] =>
-  typeof value === 'string' && value ? value.split(MULTI_VALUE_SEPARATOR) : [];
-
-/**
- * A phone answer: digits with the punctuation people actually type (`+1 (415)
- * 555-2671`, `020 7946 0958 ext. 12`). Deliberately a SHAPE check, not a
- * numbering-plan check — HubSpot stores the string as typed, and rejecting a
- * valid number we failed to parse is worse than accepting an odd one.
- */
-export const PHONE_RE = /^\+?[\d\s().\-/]+(?:\s*(?:x|ext\.?)\s*\d+)?$/i;
-const PHONE_MIN_DIGITS = 5;
-const PHONE_MAX_DIGITS = 20;
-const phoneDigits = (v: string) => v.replace(/\D/g, '').length;
-
-/** A date answer as `<input type="date">` emits it. */
-export const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-const isRealIsoDate = (v: string) => {
-  if (!ISO_DATE_RE.test(v)) return false;
-  const d = new Date(`${v}T00:00:00Z`);
-  return !Number.isNaN(d.getTime()) && d.toISOString().slice(0, 10) === v;
-};
-
 export const FORM_FIELD_TYPES = {
   text: {
     kind: 'string',
@@ -264,33 +222,8 @@ export const FORM_FIELD_TYPES = {
         .max(32, { message: `${field.label} is too long` })
         .regex(DECIMAL_LITERAL_RE, { message: `${field.label} must be a number` }),
   },
-  phone: {
-    kind: 'string',
-    hasOptions: false,
-    validator: (field, base) =>
-      base
-        .max(40, { message: `${field.label} is too long` })
-        .refine(
-          v => !v || (PHONE_RE.test(v) && phoneDigits(v) >= PHONE_MIN_DIGITS && phoneDigits(v) <= PHONE_MAX_DIGITS),
-          { message: `Please enter a valid phone number for ${field.label}` },
-        ),
-    placeholder: field => `Enter ${field.label}`,
-  },
-  date: {
-    kind: 'string',
-    hasOptions: false,
-    validator: (field, base) => base.refine(v => !v || isRealIsoDate(v), { message: `${field.label} must be a date` }),
-  },
   select: { kind: 'string', hasOptions: true, validator: optionValidator },
   radio: { kind: 'string', hasOptions: true, validator: optionValidator },
-  multiselect: {
-    kind: 'string',
-    hasOptions: true,
-    validator: (field, base) =>
-      base.refine(v => splitMultiValue(v).every(part => (field.options ?? []).includes(part)), {
-        message: `Please choose valid options for ${field.label}`,
-      }),
-  },
   checkbox: { kind: 'boolean', hasOptions: false, validator: () => z.boolean() },
 } as const satisfies Record<string, FormFieldTypeSpec>;
 
@@ -298,158 +231,22 @@ export type SupportedFormFieldType = keyof typeof FORM_FIELD_TYPES;
 
 export const SUPPORTED_FORM_FIELD_TYPES = Object.keys(FORM_FIELD_TYPES) as readonly SupportedFormFieldType[];
 
-// ---------------------------------------------------------------------------
-// HubSpot type → control resolution (open set in, closed set out)
-// ---------------------------------------------------------------------------
-
-/**
- * What a HubSpot question resolves to: a drawable control, `display` (a
- * read-only block — `html`, `calculation_*` — never rendered, never
- * submitted) or `unanswerable` (nothing the booking POST can carry, e.g. a
- * file upload).
- */
-export type FormFieldResolution = SupportedFormFieldType | 'display' | 'unanswerable';
-
-/**
- * HubSpot `fieldType` spellings → resolution. Keys are lower-cased. A spelling
- * missing here is NOT an error: resolution falls through to the data type and
- * then to a generic control. Add an entry only to draw a BETTER control for a
- * type, never to make one "work".
- *
- * `checkbox` is absent on purpose: in HubSpot it is "multiple checkboxes" (an
- * enumeration with options), while older links sent it for a single yes/no —
- * `resolveFormFieldControl` decides by whether options came with it.
- */
-const FIELD_TYPE_CONTROLS: Readonly<Record<string, FormFieldResolution>> = {
-  text: 'text',
-  textarea: 'textarea',
-  number: 'number',
-  select: 'select',
-  radio: 'radio',
-  booleancheckbox: 'checkbox',
-  phonenumber: 'phone',
-  date: 'date',
-  html: 'display',
-  file: 'unanswerable',
-};
-
-/** HubSpot property data types (`type`) → resolution, used when `fieldType` is unknown. */
-const DATA_TYPE_CONTROLS: Readonly<Record<string, FormFieldResolution>> = {
-  string: 'text',
-  number: 'number',
-  enumeration: 'select',
-  bool: 'checkbox',
-  date: 'date',
-  datetime: 'date',
-  phone_number: 'phone',
-};
-
-const hasDeclaredOptions = (field: MeetingFormField) => (field.options?.length ?? 0) > 0;
-
-/**
- * THE one mapping from a HubSpot question to what the form does with it.
- * Total: every input yields a resolution, so an unrecognised type can never
- * make a link unbookable — at worst it is a text box. An option control with
- * no options degrades to text (nothing to pick from, but still answerable).
- */
-export function resolveFormFieldControl(field: MeetingFormField): FormFieldResolution {
-  const fieldType = (field.type ?? '').toLowerCase();
-  const withOptions = hasDeclaredOptions(field);
-  const usable = (r: FormFieldResolution | undefined): FormFieldResolution | undefined => {
-    if (!r || r === 'display' || r === 'unanswerable') return r;
-    return FORM_FIELD_TYPES[r].hasOptions && !withOptions ? 'text' : r;
-  };
-
-  if (fieldType === 'checkbox') return withOptions ? 'multiselect' : 'checkbox';
-  if (fieldType.startsWith('calculation')) return 'display';
-  // A control name resolves to itself, so resolution is IDEMPOTENT: the form
-  // resolves once to draw, then hands the resolved fields to the schema
-  // factory, which resolves again (the server rebuild resolves raw ones).
-  const asControl = Object.prototype.hasOwnProperty.call(FORM_FIELD_TYPES, fieldType)
-    ? (fieldType as SupportedFormFieldType)
-    : undefined;
-  return (
-    usable(FIELD_TYPE_CONTROLS[fieldType] ?? asControl) ??
-    usable(DATA_TYPE_CONTROLS[(field.dataType ?? '').toLowerCase()]) ??
-    (withOptions ? 'select' : 'text')
-  );
-}
-
-/**
- * @deprecated Kept for hosts built against the closed six-type registry (they
- * asked this to decide whether to forward `options`). Answers for any HubSpot
- * type through the resolver: true when the type resolves to an option control
- * once options are present. New hosts forward options whenever HubSpot sends
- * them and do not need this.
- */
-export function formFieldTypeHasOptions(type: string): boolean {
-  const control = resolveFormFieldControl({ name: '', label: '', type, required: false, options: ['_'] });
-  return control !== 'display' && control !== 'unanswerable' && FORM_FIELD_TYPES[control].hasOptions;
-}
-
-/** @deprecated The option controls (see `formFieldTypeHasOptions`). */
+/** The types whose `options` the host must forward (select, radio). */
 export const FORM_FIELD_TYPES_WITH_OPTIONS: readonly SupportedFormFieldType[] = SUPPORTED_FORM_FIELD_TYPES.filter(
   type => FORM_FIELD_TYPES[type].hasOptions,
 );
 
-/**
- * Whether the question's `fieldType` is one the resolver maps EXPLICITLY — as
- * opposed to guessing from its data type or falling back to text. A host logs
- * the false case: the form still works, but a better control may be one table
- * entry away.
- */
-export function isRecognisedFormFieldType(type: string): boolean {
-  const t = (type ?? '').toLowerCase();
-  return (
-    t === 'checkbox' ||
-    t.startsWith('calculation') ||
-    Object.prototype.hasOwnProperty.call(FIELD_TYPE_CONTROLS, t) ||
-    Object.prototype.hasOwnProperty.call(FORM_FIELD_TYPES, t)
-  );
-}
-
-/** A declared question after resolution: `type` is the CONTROL, `hubspotType` what HubSpot sent. */
-export type SupportedMeetingFormField = MeetingFormField & { type: SupportedFormFieldType; hubspotType?: string };
-
-/** One question → its drawable form, or null when the form does not draw it (display / unanswerable). */
-export function normalizeFormField(
-  field: MeetingFormField & { hubspotType?: string },
-): SupportedMeetingFormField | null {
-  const control = resolveFormFieldControl(field);
-  if (control === 'display' || control === 'unanswerable') return null;
-  // A control that takes no options drops them (a `booleancheckbox` arrives
-  // with HubSpot's `true`/`false` pair), which also keeps a re-resolution of
-  // the result on the same control.
-  const normalized: SupportedMeetingFormField = {
-    ...field,
-    type: control,
-    hubspotType: field.hubspotType ?? field.type,
-  };
-  if (!FORM_FIELD_TYPES[control].hasOptions) {
-    delete normalized.options;
-    delete normalized.optionLabels;
-  }
-  return normalized;
-}
-
-/** The questions the native form draws and validates, in declared order. */
-export function normalizeFormFields(fields: readonly MeetingFormField[]): SupportedMeetingFormField[] {
-  return fields.flatMap(f => normalizeFormField(f) ?? []);
+/** Whether a raw HubSpot field type is one whose answers come from declared options. */
+export function formFieldTypeHasOptions(type: string): boolean {
+  return (FORM_FIELD_TYPES_WITH_OPTIONS as readonly string[]).includes(type);
 }
 
-/** Whether the native form draws this question (false for display blocks and unanswerable questions). */
-export function isSupportedFormField(field: MeetingFormField): boolean {
-  return normalizeFormField(field) !== null;
+export function isSupportedFormField(field: MeetingFormField): field is SupportedMeetingFormField {
+  return Object.prototype.hasOwnProperty.call(FORM_FIELD_TYPES, field.type);
 }
 
-/**
- * The ONLY reason left to hand a link to HubSpot's own page: a REQUIRED
- * question no control can answer. An optional one is simply left out — the
- * visitor can still book, and HubSpot does not require it.
- */
-export function blocksNativeBooking(field: MeetingFormField): boolean {
-  return field.required && resolveFormFieldControl(field) === 'unanswerable';
-}
+/** A declared question whose `type` is in the registry. */
+export type SupportedMeetingFormField = MeetingFormField & { type: SupportedFormFieldType };
 
 /**
  * The scheduler's fixed identity fields. HubSpot's book endpoint takes them
@@ -584,11 +381,8 @@ function buildBookingSchema<TStart extends z.ZodTypeAny, TDuration extends z.Zod
   slot: { startTimeMs: TStart; durationMs: TDuration; timezone: TZone },
 ) {
   const answers: Record<string, z.ZodTypeAny> = {};
-  // Resolved HERE, not by the caller: the server rebuild passes the link's raw
-  // questions, so client and server resolve every type through the same rule.
-  // Display blocks and unanswerable optional questions carry no answer.
-  const drawn = normalizeFormFields(formFields);
-  for (const field of drawn) {
+  for (const field of formFields) {
+    if (!isSupportedFormField(field)) continue; // unsupported types are fail-closed at render time
     const spec: FormFieldTypeSpec = FORM_FIELD_TYPES[field.type];
     // required/optional wrapping follows the answer's wire KIND, not its type:
     // a boolean is true-or-absent, a string is non-empty-or-empty. For strings
@@ -613,7 +407,7 @@ function buildBookingSchema<TStart extends z.ZodTypeAny, TDuration extends z.Zod
   // omitting the `formFields` key entirely would skip every per-question
   // rule. When the link declares at least one required supported question,
   // the object itself is required.
-  const hasRequiredAnswers = drawn.some(f => f.required);
+  const hasRequiredAnswers = formFields.some(f => isSupportedFormField(f) && f.required);
   const answersObject = z.object(answers);
 
   return (

package/src/utils/__tests__/hubspot-meetings-convention.test.ts

@@ -100,23 +100,14 @@ describe('makeBookingSchema × SUPPORTED_FORM_FIELD_TYPES', () => {
         label: `Question (${type})`,
         type,
         required: true,
-        options: type === 'select' || type === 'radio' || type === 'multiselect' ? ['a', 'b'] : undefined,
+        options: type === 'select' || type === 'radio' ? ['a', 'b'] : undefined,
       };
       expect(isSupportedFormField(field)).toBe(true);
       const schema = makeBookingSchema([field], null);
-      // One well-formed answer per control: a boolean for the box, an option for the
-      // pickers, `;`-joined options for the multi-picker, a decimal literal for a
-      // Number property, a phone and an ISO date for theirs, free text otherwise.
-      const ANSWERS: Record<string, unknown> = {
-        checkbox: true,
-        select: 'a',
-        radio: 'a',
-        multiselect: 'a;b',
-        number: '42',
-        phone: '+1 415 555 2671',
-        date: '2026-09-24',
-      };
-      const answer = ANSWERS[type] ?? 'hello';
+      // One well-formed answer per type: a boolean for the box, an option for the
+      // pickers, a decimal literal for a Number property, free text otherwise.
+      const answer =
+        type === 'checkbox' ? true : type === 'select' || type === 'radio' ? 'a' : type === 'number' ? '42' : 'hello';
       const ok = schema.safeParse({ ...base, formFields: { [field.name]: answer } });
       expect(ok.success).toBe(true);
       const missing = schema.safeParse({ ...base, formFields: {} });
@@ -124,7 +115,7 @@ describe('makeBookingSchema × SUPPORTED_FORM_FIELD_TYPES', () => {
     }
   });
 
-  it('an unanswerable question (file upload) is excluded from validation (fail-closed happens at render)', () => {
+  it('unsupported types are excluded from validation (fail-closed happens at render)', () => {
     const field: MeetingFormField = { name: 'q_file', label: 'Upload', type: 'file', required: true };
     expect(isSupportedFormField(field)).toBe(false);
     const schema = makeBookingSchema([field], null);

package/src/__tests__/meeting-form-field-types.test.tsx

@@ -1,240 +0,0 @@
-import { fireEvent, screen, waitFor } from '@testing-library/react';
-import { describe, expect, it } from 'vitest';
-import {
-  DECIMAL_LITERAL_RE,
-  FORM_FIELD_TYPES,
-  FORM_FIELD_TYPES_WITH_OPTIONS,
-  ISO_DATE_RE,
-  MULTI_VALUE_SEPARATOR,
-  PHONE_RE,
-  SUPPORTED_FORM_FIELD_TYPES,
-  blocksNativeBooking,
-  formFieldTypeHasOptions,
-  normalizeFormFields,
-  splitMultiValue,
-  type FormFieldResolution,
-  type FormFieldTypeSpec,
-  type SupportedMeetingFormField,
-  isRecognisedFormFieldType,
-  makeBookingSchema,
-  normalizeFormField,
-  resolveFormFieldControl,
-  type MeetingFormField,
-} from '../schemas/meeting-booking-schema';
-import { BOOKING_BASE, availabilityWith, fillIdentity, mountBookingForm, typeInto } from './fixtures/meeting-booking';
-
-const q = (type: string, extra: Partial<MeetingFormField> = {}): MeetingFormField => ({
-  name: `q_${type}`,
-  label: `Q ${type}`,
-  type,
-  required: false,
-  ...extra,
-});
-
-describe('resolveFormFieldControl — every HubSpot type lands on a control', () => {
-  // Every (type, fieldType) pair a HubSpot portal's contact properties carry
-  // (measured on the Flamingo portal, 2026-09-24), plus the ones no property
-  // uses yet. The resolver is TOTAL: none of these may make a link unbookable.
-  it.each([
-    ['text', 'string', undefined, 'text'],
-    ['textarea', 'string', undefined, 'textarea'],
-    ['number', 'number', undefined, 'number'],
-    ['phonenumber', 'string', undefined, 'phone'],
-    ['phonenumber', 'phone_number', undefined, 'phone'],
-    ['booleancheckbox', 'bool', undefined, 'checkbox'],
-    ['booleancheckbox', 'enumeration', ['true', 'false'], 'checkbox'],
-    ['checkbox', 'enumeration', ['a', 'b'], 'multiselect'],
-    ['checkbox', undefined, undefined, 'checkbox'],
-    ['select', 'enumeration', ['a'], 'select'],
-    ['select', 'enumeration', undefined, 'text'],
-    ['radio', 'enumeration', ['a'], 'radio'],
-    ['date', 'date', undefined, 'date'],
-    ['date', 'datetime', undefined, 'date'],
-    ['html', 'string', undefined, 'display'],
-    ['calculation_equation', 'number', undefined, 'display'],
-    ['calculation_rollup', 'datetime', undefined, 'display'],
-    ['file', 'string', undefined, 'unanswerable'],
-    // Types HubSpot has not shipped (yet): the data type decides, else text.
-    ['hologram', 'phone_number', undefined, 'phone'],
-    ['hologram', 'bool', undefined, 'checkbox'],
-    ['hologram', 'enumeration', ['a'], 'select'],
-    ['hologram', undefined, ['a'], 'select'],
-    ['hologram', undefined, undefined, 'text'],
-    ['PhoneNumber', undefined, undefined, 'phone'],
-  ] as const)('%s / %s (options: %s) → %s', (type, dataType, options, expected) => {
-    expect(resolveFormFieldControl(q(type, { dataType, options: options ? [...options] : undefined }))).toBe(expected);
-  });
-
-  it('is idempotent: a normalized field resolves to the same control again', () => {
-    const fields = [
-      q('phonenumber'),
-      q('checkbox', { options: ['a', 'b'] }),
-      q('booleancheckbox'),
-      q('booleancheckbox', { dataType: 'enumeration', options: ['true', 'false'] }),
-      q('date'),
-      q('select', { options: ['a'] }),
-      q('hologram'),
-    ];
-    for (const f of fields) {
-      const once = normalizeFormField(f);
-      expect(once && normalizeFormField(once)).toEqual(once);
-    }
-  });
-
-  it('tells a host which types were guessed rather than mapped', () => {
-    for (const t of [
-      'phonenumber',
-      'booleancheckbox',
-      'checkbox',
-      'calculation_equation',
-      'file',
-      'html',
-      'multiselect',
-    ]) {
-      expect(isRecognisedFormFieldType(t)).toBe(true);
-    }
-    expect(isRecognisedFormFieldType('hologram')).toBe(false);
-  });
-
-  it('only a REQUIRED unanswerable question blocks native booking', () => {
-    expect(blocksNativeBooking(q('file', { required: true }))).toBe(true);
-    expect(blocksNativeBooking(q('file'))).toBe(false);
-    expect(blocksNativeBooking(q('phonenumber', { required: true }))).toBe(false);
-    expect(blocksNativeBooking(q('hologram', { required: true }))).toBe(false);
-  });
-});
-
-describe('validators for the new controls', () => {
-  const parse = (field: MeetingFormField, value: unknown) =>
-    makeBookingSchema([field], null).safeParse({ ...BOOKING_BASE, formFields: { [field.name]: value } }).success;
-
-  it('phone accepts what people type and rejects what is not a number', () => {
-    const phone = q('phonenumber', { required: true });
-    for (const ok of ['+1 (415) 555-2671', '020 7946 0958', '+972-54-123-4567', '415.555.2671 ext. 12']) {
-      expect(parse(phone, ok)).toBe(true);
-    }
-    for (const bad of ['', 'call me', '123', '+1 415 555 2671 999 999 999 999']) {
-      expect(parse(phone, bad)).toBe(false);
-    }
-  });
-
-  it('date accepts a real ISO day only', () => {
-    const date = q('date', { required: true });
-    expect(parse(date, '2026-02-28')).toBe(true);
-    expect(parse(date, '2026-02-30')).toBe(false);
-    expect(parse(date, '28/02/2026')).toBe(false);
-  });
-
-  it('multiselect is a ;-joined subset of the declared options', () => {
-    const multi = q('checkbox', { required: true, options: ['rmm', 'psa', 'backup'] });
-    expect(parse(multi, 'rmm;backup')).toBe(true);
-    expect(parse(multi, 'rmm;crm')).toBe(false);
-    expect(parse(multi, '')).toBe(false);
-  });
-
-  it('an unknown type validates as text rather than being dropped', () => {
-    const unknown = q('hologram', { required: true });
-    expect(parse(unknown, 'anything')).toBe(true);
-    expect(parse(unknown, '')).toBe(false);
-  });
-
-  it('display blocks carry no answer and never make the form required', () => {
-    const html = q('html', { required: true });
-    expect(makeBookingSchema([html], null).safeParse({ ...BOOKING_BASE }).success).toBe(true);
-  });
-});
-
-describe('BookingForm — a link with a phone question (the reported outage)', () => {
-  it('renders every question and submits HubSpot-shaped values', async () => {
-    const onSubmit = mountBookingForm(
-      availabilityWith([
-        q('phonenumber', { name: 'phone', label: 'Phone number', dataType: 'string', required: true }),
-        q('checkbox', {
-          name: 'tools',
-          label: 'Tools',
-          dataType: 'enumeration',
-          options: ['rmm', 'psa'],
-          optionLabels: { rmm: 'RMM', psa: 'PSA' },
-        }),
-        q('hologram', { name: 'mystery', label: 'Mystery' }),
-        q('html', { name: 'blurb', label: 'Some rich text' }),
-      ]),
-    );
-
-    typeInto(screen.getByLabelText(/^Phone number/), ' +1 415 555 2671 ');
-    fireEvent.click(screen.getByLabelText('PSA'));
-    fireEvent.click(screen.getByLabelText('RMM'));
-    typeInto(screen.getByLabelText(/^Mystery/), 'still answerable');
-    expect(screen.queryByText('Some rich text')).not.toBeInTheDocument();
-    fillIdentity();
-    fireEvent.click(screen.getByRole('button', { name: 'Confirm Booking' }));
-
-    await waitFor(() => expect(onSubmit).toHaveBeenCalledTimes(1));
-    // Options are joined in DECLARED order, whatever order they were ticked in.
-    expect(onSubmit.mock.calls[0][0].formFields).toEqual({
-      phone: '+1 415 555 2671',
-      tools: 'rmm;psa',
-      mystery: 'still answerable',
-    });
-  });
-
-  it('blocks submit on a malformed phone number', async () => {
-    const onSubmit = mountBookingForm(
-      availabilityWith([q('phonenumber', { name: 'phone', label: 'Phone', required: true })]),
-    );
-    typeInto(screen.getByLabelText(/^Phone/), 'call me maybe');
-    fillIdentity();
-    fireEvent.click(screen.getByRole('button', { name: 'Confirm Booking' }));
-    expect(await screen.findByText('Please enter a valid phone number for Phone')).toBeInTheDocument();
-    expect(onSubmit).not.toHaveBeenCalled();
-  });
-});
-
-describe('registry exports', () => {
-  it('every control declares a spec with a validator, and options only where it picks from them', () => {
-    for (const type of SUPPORTED_FORM_FIELD_TYPES) {
-      const spec: FormFieldTypeSpec = FORM_FIELD_TYPES[type];
-      expect(typeof spec.validator).toBe('function');
-    }
-    expect([...FORM_FIELD_TYPES_WITH_OPTIONS].sort()).toEqual(['multiselect', 'radio', 'select']);
-  });
-
-  it('the wire-shape patterns accept exactly their shapes', () => {
-    expect(DECIMAL_LITERAL_RE.test('-12.5')).toBe(true);
-    expect(DECIMAL_LITERAL_RE.test('1e3')).toBe(false);
-    expect(PHONE_RE.test('+1 (415) 555-2671 x 12')).toBe(true);
-    expect(PHONE_RE.test('five five five')).toBe(false);
-    expect(ISO_DATE_RE.test('2026-09-24')).toBe(true);
-    expect(ISO_DATE_RE.test('24/09/2026')).toBe(false);
-  });
-
-  it('splitMultiValue reads the ;-joined wire value', () => {
-    expect(MULTI_VALUE_SEPARATOR).toBe(';');
-    expect(splitMultiValue('a;b')).toEqual(['a', 'b']);
-    expect(splitMultiValue('')).toEqual([]);
-    expect(splitMultiValue(undefined)).toEqual([]);
-  });
-
-  it('normalizeFormFields keeps declared order, drops what is not drawn, and records the HubSpot type', () => {
-    const drawn: SupportedMeetingFormField[] = normalizeFormFields([
-      q('phonenumber'),
-      q('html'),
-      q('file'),
-      q('booleancheckbox', { options: ['true', 'false'] }),
-    ]);
-    expect(drawn.map(f => [f.type, f.hubspotType])).toEqual([
-      ['phone', 'phonenumber'],
-      ['checkbox', 'booleancheckbox'],
-    ]);
-    expect(drawn[1].options).toBeUndefined();
-    const hidden: FormFieldResolution[] = ['display', 'unanswerable'];
-    expect(hidden).toContain(resolveFormFieldControl(q('html')));
-  });
-
-  it('formFieldTypeHasOptions (deprecated) still answers for hosts built on the old registry', () => {
-    for (const t of ['select', 'radio', 'checkbox', 'hologram']) expect(formFieldTypeHasOptions(t)).toBe(true);
-    for (const t of ['text', 'number', 'phonenumber', 'booleancheckbox', 'html', 'file']) {
-      expect(formFieldTypeHasOptions(t)).toBe(false);
-    }
-  });
-});