{
  "$schema": "https://ui.shadcn.com/schema/registry-item.json",
  "name": "time-field",
  "title": "Time field",
  "description": "A time of day in one field frame: hour and minute spin-button cells that wrap, a day-period cell on a 12-hour clock, a zone affix, optional min/max bounds; the 24-hour \"HH:MM\" value reaches Base UI Form and FormData.",
  "dependencies": [
    "@base-ui/react@1.9.0"
  ],
  "registryDependencies": [
    "@keyline-ui/keyline",
    "utils",
    "@keyline-ui/field"
  ],
  "files": [
    {
      "path": "src/registry/keyline/ui/time-field.tsx",
      "content": "\"use client\";\n\nimport * as React from \"react\";\nimport { Field as FieldPrimitive } from \"@base-ui/react/field\";\n\nimport { cn } from \"@/lib/utils\";\nimport { FieldMessages, useDescribedByMirror, type FieldParticipantProps } from \"./field\";\n\ntype TimeFieldProps = FieldParticipantProps & {\n  /** Visible label (visually hidden with layout=\"cell\"). Names the group; each part is named too. */\n  label: React.ReactNode;\n  /** \"HH:MM\", 24-hour, whatever the hour cycle shown. null (or \"\") is no time. */\n  value?: string | null;\n  defaultValue?: string | null;\n  /** Called with \"HH:MM\" (24-hour) once every part holds a value, and with null when one is cleared. */\n  onValueChange?: (value: string | null) => void;\n  /** 24: hours 00–23 (default). 12: hours 01–12 and a day-period part (AM/PM, named by `locale`). */\n  hourCycle?: 12 | 24;\n  /** Names the day periods and decides whether the period comes before the hours (e.g. \"ko\", \"zh\"). Default: the runtime's. */\n  locale?: string;\n  /** Arrow keys move minutes by this much (and snap to it). Default 1. */\n  minuteStep?: number;\n  /** Earliest and latest allowed time, \"HH:MM\" 24-hour. Arrow keys never step outside them (they wrap to the\n   *  other bound); a typed time outside them is invalid with `rangeMessage`. */\n  min?: string;\n  max?: string;\n  /** Error for a time outside min/max. Default \"Choose a time from {min} to {max}.\" in the shown clock. */\n  rangeMessage?: string;\n  /** Form name; the submitted value is \"HH:MM\", 24-hour (or \"\" when incomplete). */\n  name?: string;\n  required?: boolean;\n  disabled?: boolean;\n  readOnly?: boolean;\n  /** Trailing affix cell in the Code voice: a time zone (\"CET\"), \"local\". */\n  zone?: React.ReactNode;\n  /** control: its own 2px frame. cell: a cell of an enclosing frame (no border, label visually hidden). */\n  layout?: \"control\" | \"cell\";\n  hourLabel?: string;\n  minuteLabel?: string;\n  /** Accessible name of the day-period part (12-hour). Default \"AM/PM\". */\n  periodLabel?: string;\n  id?: string;\n  className?: string;\n};\n\ntype Period = \"\" | \"am\" | \"pm\";\ntype Parts = [string, string, Period];\ntype Part = 0 | 1 | 2;\n\nconst pad = (n: number) => String(n).padStart(2, \"0\");\nconst parse = (v: string | null | undefined, cycle: 12 | 24): Parts => {\n  const m = v ? /^(\\d{1,2}):(\\d{1,2})$/.exec(v) : null;\n  if (!m) return [\"\", \"\", \"\"];\n  const [, hours = \"\", minutes = \"\"] = m;\n  const h = Math.min(23, +hours);\n  const mi = pad(Math.min(59, +minutes));\n  return cycle === 24 ? [pad(h), mi, \"\"] : [pad(h % 12 || 12), mi, h < 12 ? \"am\" : \"pm\"];\n};\n/** The 24-hour value the parts make, or null while one is missing. */\nconst toValue = (p: Parts, cycle: 12 | 24): string | null => {\n  if (p[0] === \"\" || p[1] === \"\" || +p[0] > (cycle === 12 ? 12 : 23) || (cycle === 12 && (+p[0] < 1 || !p[2])))\n    return null;\n  const h = cycle === 24 ? +p[0] : (+p[0] % 12) + (p[2] === \"pm\" ? 12 : 0);\n  return `${pad(h)}:${pad(+p[1])}`;\n};\n\n/** \"HH:MM\" as the field shows it: 24-hour as is, 12-hour in the locale's words (\"6:00 AM\"). */\nconst showTime = (v: string, cycle: 12 | 24, locale?: string) => {\n  if (cycle === 24) return v;\n  const [h, m] = v.split(\":\").map(Number);\n  return new Intl.DateTimeFormat(locale, { hour: \"2-digit\", minute: \"2-digit\", hour12: true }).format(\n    new Date(2020, 0, 1, h, m),\n  );\n};\n/** Is \"HH:MM\" outside [min, max]? (Zero-padded 24-hour strings compare in clock order.) */\nconst outside = (v: string | null, min?: string, max?: string) =>\n  v != null && ((min != null && v < min) || (max != null && v > max));\n\n/** The locale's day-period names and whether it puts them before the hours. */\nfunction dayPeriods(locale?: string): { names: [string, string]; first: boolean } {\n  try {\n    const f = new Intl.DateTimeFormat(locale, { hour: \"numeric\", minute: \"2-digit\", hour12: true });\n    const parts = (h: number) => f.formatToParts(new Date(2020, 0, 1, h, 30));\n    const name = (h: number) => parts(h).find((x) => x.type === \"dayPeriod\")?.value;\n    const am = parts(9);\n    const first = am.findIndex((x) => x.type === \"dayPeriod\") < am.findIndex((x) => x.type === \"hour\");\n    return { names: [name(9) ?? \"AM\", name(21) ?? \"PM\"], first };\n  } catch {\n    return { names: [\"AM\", \"PM\"], first: false };\n  }\n}\n\n/** An hour, minute or day-period cell: exactly two tabular digits wide, so the frame never changes width while the time\n *  steps or is typed. The part being edited takes the cursor tint, so it is clear which one the arrows will move. */\nconst partClass = cn(\n  \"kl-field-input box-border w-[calc(2ch+2*10px)] flex-none px-2.5 text-center tabular-nums caret-kl-ink\",\n  \"placeholder:text-kl-ink-3 focus:bg-kl-tint\",\n);\n\n/**\n * A time of day in one field frame: two spin-button cells (three for a 12-hour clock) and a zone affix.\n *\n *   Pickup\n *   ┌──────┬───┬──────┬─────┐            ┌──────┬───┬──────┬────┬─────┐\n *   │  14  │ : │  30  │ CET │  24-hour   │  02  │ : │  30  │ PM │ CET │  12-hour\n *   └──────┴───┴──────┴─────┘            └──────┴───┴──────┴────┴─────┘\n *\n * - Each part is an input with role=\"spinbutton\" (aria-valuenow/min/max/text), so it is announced as a\n *   spin button with its value, not as a text box. Tab moves through the parts in reading order.\n * - Arrow Up/Down step and WRAP (23 → 00, 12 → 01, 59 → 00): a clock has no end. Page Up/Down move hours\n *   by 6 (3 on a 12-hour clock) and minutes by 10. Home/End go to the first and last value.\n * - Typing: digits only. Hours advance after two digits, or one digit that cannot start a two-digit hour\n *   (\"7\" is 07; on a 12-hour clock \"2\" is 02). On a 12-hour clock minutes advance to the period the same\n *   way. The period takes \"a\" or \"p\" (or a letter only one of the locale's names has), and the arrows\n *   switch it. Backspace in an empty part returns to the one before. Blur pads (\"7\" → \"07\").\n * - The value is always 24-hour \"HH:MM\", so changing `hourCycle` never changes what is stored or\n *   submitted. On a 12-hour clock the value is complete only once the period is chosen.\n * - Field: the frame, focus edge, ! cell, hatch and messages are Field's. The value reaches Base UI Form\n *   (and FormData) through a hidden Field control named `name`; `required` is checked there (\"Enter a time\").\n * - RTL: the ! cell and zone follow the page; the time itself stays in clock order (dir=\"ltr\"), with the\n *   period where the locale puts it.\n */\nfunction TimeField({\n  label,\n  value,\n  defaultValue = null,\n  onValueChange,\n  hourCycle = 24,\n  locale,\n  minuteStep = 1,\n  min: minT,\n  max: maxT,\n  rangeMessage,\n  name,\n  required,\n  disabled,\n  readOnly,\n  zone,\n  layout = \"control\",\n  hourLabel = \"Hours\",\n  minuteLabel = \"Minutes\",\n  periodLabel = \"AM/PM\",\n  id: idProp,\n  className,\n  invalid,\n  error,\n  description,\n  validate,\n  validationMode,\n  orientation,\n}: TimeFieldProps) {\n  const autoId = React.useId();\n  const id = idProp ?? autoId;\n  const labelId = `${id}-label`;\n  const cycle = hourCycle;\n  const periods = React.useMemo(() => dayPeriods(locale), [locale]);\n  // the parts as typed (may be one digit while editing); a controlled value re-seeds them when it changes\n  const [parts, setParts] = React.useState<Parts>(() => parse(value !== undefined ? value : defaultValue, cycle));\n  const lastValue = React.useRef(value);\n  const lastCycle = React.useRef(cycle);\n  if (cycle !== lastCycle.current) {\n    // the same time, shown on the other clock\n    const v = value !== undefined ? value : toValue(parts, lastCycle.current);\n    lastCycle.current = cycle;\n    lastValue.current = value;\n    setParts(parse(v, cycle));\n  } else if (value !== undefined && value !== lastValue.current) {\n    // a new controlled value re-seeds the parts, unless they already make it (an echo of our own change)\n    lastValue.current = value;\n    if (toValue(parts, cycle) !== (value || null)) setParts(parse(value, cycle));\n  }\n  // the latest parts, for handlers that run before React re-renders (moving focus on advance fires the\n  // hours blur synchronously, inside the same change event; reading `parts` there would undo the change)\n  const partsRef = React.useRef(parts);\n  partsRef.current = parts;\n  const refs = [\n    React.useRef<HTMLInputElement>(null),\n    React.useRef<HTMLInputElement>(null),\n    React.useRef<HTMLInputElement>(null),\n  ] as const;\n  const order: Part[] = cycle === 24 ? [0, 1] : periods.first ? [2, 0, 1] : [0, 1, 2];\n  const step = (part: Part, by: 1 | -1) => order[order.indexOf(part) + by];\n  const focusPart = (part: Part | undefined) => {\n    if (part === undefined) return;\n    refs[part].current?.focus();\n    refs[part].current?.select();\n  };\n  // A part holding one digit is mid-entry (\"2\" on the way to \"21\"): the field keeps its last complete value until the\n  // digit is padded (on advance or blur), so nothing is emitted, validated or marked invalid between keystrokes.\n  // (typing \"21\" over \"21:30\" with min/max emitted \"02:30\", flashed the ! cell and resized the frame.)\n  const midEntry = (p: Parts) => p[0].length === 1 || p[1].length === 1;\n  const settled = React.useRef<string | null>(toValue(parts, cycle));\n  const valueOf = (p: Parts) => (midEntry(p) ? settled.current : toValue(p, cycle));\n  const formValue = valueOf(parts) ?? \"\";\n  const lo = cycle === 12 ? 1 : 0;\n  const hi = cycle === 12 ? 12 : 23;\n\n  const commit = (next: Parts) => {\n    const before = partsRef.current;\n    partsRef.current = next;\n    setParts(next);\n    const was = valueOf(before);\n    const out = valueOf(next);\n    if (!midEntry(next)) settled.current = out;\n    if (out !== was) onValueChange?.(out);\n  };\n  const setPart = (part: Part, v: string) => {\n    const next: Parts = [...partsRef.current];\n    if (part === 2) next[2] = v as Period;\n    else next[part] = v;\n    commit(next);\n  };\n\n  // a stepped time stays inside min/max: stepping past one bound wraps to the other (as the parts wrap),\n  // Home/End and the period land on the nearer bound\n  const bound = (next: Parts, dir: 1 | -1 | 0) => {\n    const v = toValue(next, cycle);\n    if (outside(v, minT, maxT)) {\n      const over = maxT != null && v! > maxT;\n      const to = dir === 1 && over && minT ? minT : dir === -1 && !over && maxT ? maxT : over ? maxT! : minT!;\n      next = parse(to, cycle);\n    }\n    commit(next);\n  };\n\n  const spin = (part: 0 | 1, e: React.KeyboardEvent<HTMLInputElement>) => {\n    if (readOnly || disabled) return;\n    const min = part === 0 ? lo : 0;\n    const max = part === 0 ? hi : 59;\n    const by = part === 0 ? 1 : minuteStep;\n    const big = part === 0 ? (cycle === 12 ? 3 : 6) : 10;\n    const cur = partsRef.current[part] === \"\" ? null : +partsRef.current[part];\n    const span = max - min + 1;\n    const wrap = (x: number) => ((((x - min) % span) + span) % span) + min;\n    const last = part === 0 ? max : max - (max % by);\n    let n: number | null = null;\n    switch (e.key) {\n      case \"ArrowUp\":\n        n = cur == null ? min : wrap(Math.floor(cur / by) * by + by);\n        break;\n      case \"ArrowDown\":\n        n = cur == null ? last : wrap(Math.ceil(cur / by) * by - by);\n        break;\n      case \"PageUp\":\n        n = wrap((cur ?? min) + big);\n        break;\n      case \"PageDown\":\n        n = wrap((cur ?? min) - big);\n        break;\n      case \"Home\":\n        n = min;\n        break;\n      case \"End\":\n        n = last;\n        break;\n      case \"Backspace\":\n        if (partsRef.current[part] === \"\" && step(part, -1) !== undefined) {\n          e.preventDefault();\n          focusPart(step(part, -1));\n        }\n        return;\n      default:\n        return;\n    }\n    e.preventDefault();\n    const next: Parts = [...partsRef.current];\n    next[part] = pad(n);\n    bound(next, e.key === \"ArrowUp\" || e.key === \"PageUp\" ? 1 : e.key === \"ArrowDown\" || e.key === \"PageDown\" ? -1 : 0);\n    // keep the part selected, so a digit typed after stepping replaces the value instead of appending\n    const el = e.currentTarget;\n    requestAnimationFrame(() => el === document.activeElement && el.select());\n  };\n\n  // Typing goes through change events (not keydown), so it works with virtual keyboards and paste. The\n  // part keeps its last two digits; when they make no valid value, the last digit starts a new one.\n  const type = (part: 0 | 1, raw: string) => {\n    const digits = raw.replace(/\\D/g, \"\").slice(-2);\n    const min = part === 0 ? lo : 0;\n    const max = part === 0 ? hi : 59;\n    const v = digits === \"\" ? \"\" : digits.length === 2 && (+digits > max || +digits < min) ? digits.slice(-1) : digits;\n    // advance once the part is unambiguous; a single digit is padded now (\"7\" → \"07\"), because moving\n    // focus blurs this part before the change has rendered\n    const firstMax = Math.floor(max / 10);\n    const after = step(part, 1);\n    const advance = after !== undefined && (v.length === 2 || (v.length === 1 && +v > firstMax));\n    setPart(part, advance ? pad(+v) : v);\n    if (advance) focusPart(after);\n  };\n\n  const pad2OnBlur = (part: 0 | 1) => {\n    const v = partsRef.current[part];\n    if (v.length !== 1) return;\n    // \"0\" is no hour on a 12-hour clock: clear it rather than pad it to an invalid 00\n    setPart(part, part === 0 && +v < lo ? \"\" : pad(+v));\n  };\n\n  const periodKey = (e: React.KeyboardEvent<HTMLInputElement>) => {\n    if (readOnly || disabled) return;\n    const cur = partsRef.current[2];\n    let n: Period | null = null;\n    switch (e.key) {\n      case \"ArrowUp\":\n      case \"ArrowDown\":\n      case \"PageUp\":\n      case \"PageDown\":\n        n = cur === \"\" ? (e.key === \"ArrowDown\" || e.key === \"PageDown\" ? \"pm\" : \"am\") : cur === \"am\" ? \"pm\" : \"am\";\n        break;\n      case \"Home\":\n        n = \"am\";\n        break;\n      case \"End\":\n        n = \"pm\";\n        break;\n      case \"Backspace\":\n      case \"Delete\":\n        e.preventDefault();\n        if (cur === \"\" && e.key === \"Backspace\") focusPart(step(2, -1));\n        else setPart(2, \"\");\n        return;\n      default:\n        return;\n    }\n    e.preventDefault();\n    const next: Parts = [...partsRef.current];\n    next[2] = n;\n    bound(next, 0);\n    const el = e.currentTarget;\n    requestAnimationFrame(() => el === document.activeElement && el.select());\n  };\n  // typed letters (and virtual keyboards): \"a\" / \"p\", or a letter only one of the locale's names contains\n  const typePeriod = (raw: string) => {\n    if (readOnly || disabled) return;\n    const shown = partsRef.current[2] === \"\" ? \"\" : periods.names[partsRef.current[2] === \"am\" ? 0 : 1];\n    const typed = raw.startsWith(shown) ? raw.slice(shown.length) : raw;\n    const c = typed.slice(-1).toLocaleLowerCase(locale);\n    if (raw === \"\") return setPart(2, \"\");\n    const [a, p] = [periods.names[0].toLocaleLowerCase(locale), periods.names[1].toLocaleLowerCase(locale)];\n    const n: Period | null =\n      c === \"a\" || (a.includes(c) && !p.includes(c))\n        ? \"am\"\n        : c === \"p\" || (p.includes(c) && !a.includes(c))\n          ? \"pm\"\n          : null;\n    if (n) {\n      setPart(2, n);\n      const after = step(2, 1);\n      if (after !== undefined) focusPart(after);\n    }\n  };\n\n  const required$ = React.useCallback(\n    (v: unknown, all: Record<string, unknown>) => {\n      if (required && !v) return \"Enter a time.\";\n      if (typeof v === \"string\" && outside(v, minT, maxT))\n        return (\n          rangeMessage ??\n          (minT && maxT\n            ? `Choose a time from ${showTime(minT, cycle, locale)} to ${showTime(maxT, cycle, locale)}.`\n            : minT\n              ? `Choose ${showTime(minT, cycle, locale)} or later.`\n              : `Choose ${showTime(maxT!, cycle, locale)} or earlier.`)\n        );\n      return validate ? validate(v, all) : null;\n    },\n    [required, validate, minT, maxT, rangeMessage, cycle, locale],\n  );\n\n  // A press that focuses a part selects it whole, so the digits typed next replace it. WebKit clears that\n  // selection on the mouseup that follows (and puts the caret where the press was, so \"14\" + \"0\" would read\n  // \"104\"); the mouseup after a focusing press is cancelled to keep it.\n  const justFocused = React.useRef(false);\n  const common = {\n    role: \"spinbutton\",\n    autoComplete: \"off\",\n    \"aria-invalid\": invalid || undefined,\n    \"aria-required\": required || undefined,\n    disabled,\n    readOnly,\n    onFocus: (e: React.FocusEvent<HTMLInputElement>) => {\n      justFocused.current = true;\n      e.target.select();\n    },\n    onMouseUp: (e: React.MouseEvent<HTMLInputElement>) => {\n      if (justFocused.current) e.preventDefault();\n      justFocused.current = false;\n    },\n    onBlur: () => {\n      justFocused.current = false;\n    },\n  };\n  const spinProps = (part: 0 | 1) => {\n    const v = parts[part];\n    return {\n      ...common,\n      inputMode: \"numeric\" as const,\n      placeholder: \"––\",\n      \"aria-label\": part === 0 ? hourLabel : minuteLabel,\n      \"aria-valuemin\": part === 0 ? lo : 0,\n      \"aria-valuemax\": part === 0 ? hi : 59,\n      \"aria-valuenow\": v === \"\" ? undefined : +v,\n      \"aria-valuetext\": v === \"\" ? \"Empty\" : pad(+v),\n      value: v,\n      onKeyDown: (e: React.KeyboardEvent<HTMLInputElement>) => spin(part, e),\n      onChange: (e: React.ChangeEvent<HTMLInputElement>) => type(part, e.target.value),\n      onBlur: () => {\n        justFocused.current = false;\n        pad2OnBlur(part);\n      },\n      className: partClass,\n    };\n  };\n  const period =\n    cycle === 12 ? (\n      // the input and a hidden sizer per name share one grid cell, so the cell is as wide as the longer name\n      <span data-slot=\"time-field-period\" className=\"grid flex-none *:[grid-area:1/1]\">\n        <input\n          ref={refs[2]}\n          {...common}\n          role=\"spinbutton\"\n          inputMode=\"text\"\n          placeholder=\"––\"\n          aria-label={periodLabel}\n          aria-valuemin={0}\n          aria-valuemax={1}\n          aria-valuenow={parts[2] === \"\" ? undefined : parts[2] === \"am\" ? 0 : 1}\n          aria-valuetext={parts[2] === \"\" ? \"Empty\" : periods.names[parts[2] === \"am\" ? 0 : 1]}\n          value={parts[2] === \"\" ? \"\" : periods.names[parts[2] === \"am\" ? 0 : 1]}\n          onKeyDown={periodKey}\n          onChange={(e) => typePeriod(e.target.value)}\n          data-slot=\"time-field-period-input\"\n          className={cn(partClass, \"w-0 min-w-full px-2\")}\n        />\n        {periods.names.map((n) => (\n          <span\n            key={n}\n            data-slot=\"time-field-period-sizer\"\n            className=\"invisible box-border px-2 font-(--kl-weight-strong) whitespace-nowrap\"\n            aria-hidden\n          >\n            {n}\n          </span>\n        ))}\n      </span>\n    ) : null;\n\n  // the parts are what focus lands on, so they carry the description and error (only the hidden control did)\n  const frameRef = React.useRef<HTMLDivElement>(null);\n  useDescribedByMirror(frameRef, '[role=\"spinbutton\"]');\n  return (\n    <FieldPrimitive.Root\n      data-kl-layout={layout}\n      data-kl-orientation={orientation}\n      data-kl-cycle={cycle}\n      name={name}\n      disabled={disabled}\n      invalid={invalid}\n      validate={required$}\n      validationMode={validationMode}\n      className={cn(\n        // as a cell it hugs its parts, so a neighbouring cell (a date) takes the room\n        \"kl-field group/time-field justify-items-start data-[kl-layout=cell]:flex-none data-[kl-layout=cell]:justify-items-stretch\",\n        className,\n      )}\n      data-slot=\"time-field\"\n    >\n      <span id={labelId} className={cn(\"kl-field-label\", layout === \"cell\" && \"kl-sr\")}>\n        {label}\n      </span>\n      {/* A press on the frame's padding focuses the first part, for the pointer only; the keyboard reaches each\n          part directly, so the group needs no key handler. */}\n      {/* oxlint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-noninteractive-element-interactions -- pointer convenience; see above */}\n      <div\n        ref={frameRef}\n        role=\"group\"\n        aria-labelledby={labelId}\n        data-kl-layout={layout}\n        data-slot=\"time-field-frame\"\n        className=\"kl-ctl kl-cells kl-field-frame kl-edge w-max max-w-full data-[kl-layout=cell]:w-auto\"\n        onClick={(e) => e.target === e.currentTarget && focusPart(order[0])}\n      >\n        <span className=\"kl-slot kl-field-bang\" aria-hidden>\n          <span>\n            <span>!</span>\n          </span>\n        </span>\n        {/* a clock time reads in clock order in every script, so the value is one LTR cell (in RTL the\n            ! cell and zone still follow the page; Tab still goes through the parts in clock order) */}\n        <span data-slot=\"time-field-value\" className=\"flex flex-none items-stretch *:border-0\" dir=\"ltr\">\n          {periods.first ? period : null}\n          <input ref={refs[0]} id={id} {...spinProps(0)} />\n          <span\n            data-slot=\"time-field-join\"\n            className={cn(\n              \"grid flex-none place-items-center px-px text-[15px] font-(--kl-weight-strong) text-kl-ink-2\",\n              \"group-data-disabled/time-field:text-kl-dis\",\n            )}\n            aria-hidden\n          >\n            :\n          </span>\n          <input ref={refs[1]} {...spinProps(1)} />\n          {periods.first ? null : period}\n        </span>\n        {zone != null ? (\n          <span\n            data-slot=\"time-field-zone\"\n            className={cn(\n              // a zone keeps its own order in RTL (\"°C\" would otherwise read \"C°\"): the <bdi> isolates it\n              \"kl-field-affix border-s-(length:--kl-k1) border-s-kl-line-soft group-data-disabled/time-field:text-kl-dis\",\n            )}\n          >\n            <bdi>{zone}</bdi>\n          </span>\n        ) : null}\n        <FieldPrimitive.Control type=\"hidden\" value={formValue} onValueChange={() => {}} />\n      </div>\n      <FieldMessages description={description} error={error} invalid={invalid} layout={layout} />\n    </FieldPrimitive.Root>\n  );\n}\n\nexport { TimeField, outside as timeOutside, type TimeFieldProps };\n",
      "type": "registry:ui",
      "target": "components/keyline/ui/time-field.tsx"
    }
  ],
  "type": "registry:ui"
}