diff --git a/AGENTS.md b/AGENTS.md
index 9a16809..2359e81 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -15,7 +15,8 @@ This file is the canonical agent guide for every tool (`CLAUDE.md` is just
 
 1. **Zero runtime dependencies.** Nothing under `dependencies`, ever. `Intl.*` is
    allowed (built into every runtime). React appears only as an optional peer for
-   `./react`. Mechanically gated: `packages/lingo/scripts/check-zero-deps.mjs`
+   `./react` and `./react-native`. Mechanically gated:
+   `packages/lingo/scripts/check-zero-deps.mjs`
    (part of `bun run check` and CI).
 2. **Size budgets are enforced** (`bun run size`, min+gzip via esbuild).
    **`packages/lingo/scripts/size.mjs` is the single source of truth for budget
@@ -127,6 +128,7 @@ Inside `packages/lingo/` the same scripts run directly (`bun run test`, etc.).
 - `dom/` — headless input controller (entry `./dom`)
 - `element/` — custom-element wrapper over the DOM controller (entry `./element`)
 - `react/` — React hook adapter (entry `./react`)
+- `react-native/` — DOM-free React Native TextInput hook (entry `./react-native`)
 - `ai/` — Standard Schema fields for LLM structured output (entry `./ai`)
 - `mcp/` — Model Context Protocol tool helpers (entry `./mcp`)
 
diff --git a/CONTEXT.md b/CONTEXT.md
index bac9210..681ef88 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -112,8 +112,8 @@ its value. Fields never rewrite text while typing (D6).
 ## Infrastructure nouns
 
 **Entry:** a published subpath — `.`, `./core`, `./date`, `./dom`, `./element`,
-`./describe`, `./catalog`, `./schema`, `./ai`, `./mcp`, `./react`, `./complete`,
-`./locales/*`. *Avoid: subpackage, plugin.*
+`./describe`, `./catalog`, `./schema`, `./ai`, `./mcp`, `./react`,
+`./react-native`, `./complete`, `./locales/*`. *Avoid: subpackage, plugin.*
 
 **Catalog:** the read-only query surface (`./catalog`) over built-in
 unit/kind/currency data — list kinds/units, resolve refs, related units,
diff --git a/apps/site/package.json b/apps/site/package.json
index 0274c17..66105bf 100644
--- a/apps/site/package.json
+++ b/apps/site/package.json
@@ -6,6 +6,7 @@
     "dev": "NEXT_DIST_DIR=.next-dev next dev",
     "build": "bun run typecheck && next build",
     "start": "next start",
+    "test": "vitest run",
     "typecheck": "tsgo --project tsconfig.json --noEmit",
     "kill": "bun ./scripts/kill-port.mjs",
     "clean": "bun ./scripts/clean-next.mjs",
@@ -31,12 +32,13 @@
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
-    "@typescript/native-preview": "7.0.0-dev.20260704.1",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
+    "@typescript/native-preview": "7.0.0-dev.20260704.1",
     "eslint": "^9",
     "eslint-config-next": "16.2.10",
+    "jsdom": "^29.1.1",
     "react-doctor": "^0.6.2",
     "react-grab": "^0.1.48",
     "react-scan": "^0.5.7",
diff --git a/apps/site/public/llms-small.txt b/apps/site/public/llms-small.txt
index 6576144..3833bb1 100644
--- a/apps/site/public/llms-small.txt
+++ b/apps/site/public/llms-small.txt
@@ -4,7 +4,7 @@
 
 Agent fetch order (online): `https://lingo.pascal.app/llms.txt` (index) → `https://lingo.pascal.app/docs/<section>.md` (per-topic) or `https://lingo.pascal.app/llms-full.txt` (complete narrative). Offline: this file (`node_modules/@pascal-app/lingo/llms.txt`) is the compressed self-contained reference. Keep user measurements as strings in tool schemas; call lingo to convert, validate, surface spans, and handle ambiguity.
 
-Entries: `@pascal-app/lingo` (core+units+fuzzy), `@pascal-app/lingo/date`, `@pascal-app/lingo/dom`, `@pascal-app/lingo/element` (`<lingo-input>`), `@pascal-app/lingo/react`, `@pascal-app/lingo/ai` (LLM tool fields), `@pascal-app/lingo/mcp` (MCP tool helper), `@pascal-app/lingo/describe` (rich value/result descriptions), `@pascal-app/lingo/catalog` (query units/kinds/currencies + ISO country codes), `@pascal-app/lingo/complete` (ranked autocomplete completions), `@pascal-app/lingo/schema` (JSON Schema + OpenAPI + enum reference), `@pascal-app/lingo/locales/{en,en-gb,es,fr,pt,zh,ja}` (tree-shakeable language packs), `@pascal-app/lingo/core`.
+Entries: `@pascal-app/lingo` (core+units+fuzzy), `@pascal-app/lingo/date`, `@pascal-app/lingo/dom`, `@pascal-app/lingo/element` (`<lingo-input>`), `@pascal-app/lingo/react`, `@pascal-app/lingo/react-native`, `@pascal-app/lingo/ai` (LLM tool fields), `@pascal-app/lingo/mcp` (MCP tool helper), `@pascal-app/lingo/describe` (rich value/result descriptions), `@pascal-app/lingo/catalog` (query units/kinds/currencies + ISO country codes), `@pascal-app/lingo/complete` (ranked autocomplete completions), `@pascal-app/lingo/schema` (JSON Schema + OpenAPI + enum reference), `@pascal-app/lingo/locales/{en,en-gb,es,fr,pt,zh,ja}` (tree-shakeable language packs), `@pascal-app/lingo/core`.
 
 ## Core (`@pascal-app/lingo`)
 
@@ -41,7 +41,7 @@ const items = completions("10 kg to 16", { kind: "mass", limit: 8 })
 // [{ text, result, confidence, source }] — source: parse|alternative|unit-ambiguity|unit-prefix|implied-unit|range-implied|cross-kind|date
 ```
 
-Distinct from success `alternatives`, failure `candidate`, and issue `suggestions`. Wire into `lingoInput({ complete, onComplete })` for autocomplete dropdowns. Pass `date: (text) => parseDate(text, { now })` to opt into date completions without bundling `@pascal-app/lingo/date` into `@pascal-app/lingo/complete`.
+Distinct from success `alternatives`, failure `candidate`, and issue `suggestions`. Wire into `lingoInput({ complete, onComplete })` or `useLingoInput({ complete })` for autocomplete dropdowns. The React hook exposes `completions`, `highlightedIndex`, `setHighlightedIndex()`, and `selectCompletion()` while keeping popup UI caller-owned. Pass `date: (text) => parseDate(text, { now })` to opt into date completions without bundling `@pascal-app/lingo/date` into `@pascal-app/lingo/complete`.
 
 ## Locales (`@pascal-app/lingo/locales/*`)
 
@@ -110,7 +110,102 @@ field.set("6ft")
 field.commit() // hidden input submits canonical value
 ```
 
-`field.value` · `.quantity` · `.result` · `.state` ('idle'|'incomplete'|'valid'|'invalid') · `.set()` · `.commit()` · `.update()` · `.destroy()`. Never rewrites while typing; canonicalizes on blur/Enter/submit. With `complete`/`onComplete`, the input gets the headless WAI-ARIA combobox attributes (`role="combobox"`, `aria-autocomplete="list"`, `aria-expanded`); pass `listboxId` to set `aria-controls` for your rendered listbox. React: `useLingoInput(opts)` from `@pascal-app/lingo/react`.
+`field.value` · `.quantity` · `.result` · `.state` ('idle'|'incomplete'|'valid'|'invalid') · `.set()` · `.commit()` · `.update()` · `.destroy()`. Never rewrites while typing; canonicalizes on blur/Enter/submit. With `complete`/`onComplete`, the input gets the headless WAI-ARIA combobox attributes (`role="combobox"`, `aria-autocomplete="list"`, `aria-expanded`); pass `listboxId` to set `aria-controls` for your rendered listbox.
+
+## React (`@pascal-app/lingo/react`)
+
+```tsx
+import { completions } from "@pascal-app/lingo/complete"
+import { useLingoInput } from "@pascal-app/lingo/react"
+
+function HeightField() {
+  const field = useLingoInput({
+    kind: "length",
+    unit: "m",
+    name: "height_m",
+    listboxId: "height-options",
+    complete: (text) => completions(text, { kind: "length" }),
+  })
+  return (
+    <>
+      <input ref={field.ref} data-state={field.state} />
+      <ul id="height-options" role="listbox">
+        {field.completions.map((item, index) => (
+          <li
+            key={item.text}
+            role="option"
+            aria-selected={index === field.highlightedIndex}
+            onMouseDown={(e) => {
+              e.preventDefault()
+              field.selectCompletion(index)
+            }}
+          >
+            {item.text}
+          </li>
+        ))}
+      </ul>
+    </>
+  )
+}
+```
+
+- Attach `field.ref` to `<input>` / `<textarea>` (DOM controller underneath).
+- Live state: `state`, `value` (canonical number), `quantity`, `result`.
+- Completions (when `complete` injected): `completions`, `highlightedIndex`, `setHighlightedIndex(i)`, `selectCompletion(i?)`.
+- Imperative: `set(number|string)`, `commit()`. Controlled: `value: number | null` + `onValueChange`.
+- Keyboard: handle Arrow/Enter in **capture phase** (`onKeyDownCapture`) so selection beats the controller's native Enter-to-commit.
+- `'use client'` entry; React is an optional peer. `./complete` stays an explicit import.
+
+## React Native (`@pascal-app/lingo/react-native`)
+
+```tsx
+import { FlatList, Text, TextInput, Pressable, View } from "react-native"
+import { completions } from "@pascal-app/lingo/complete"
+import { useLingoTextInput } from "@pascal-app/lingo/react-native"
+
+function WeightField({ onWeight }: { onWeight: (kg: number | null) => void }) {
+  const field = useLingoTextInput({
+    kind: "mass",
+    unit: "kg",
+    min: 0,
+    max: "500 kg",
+    required: true,
+    complete: (text) => completions(text, { kind: "mass", limit: 6 }),
+    onValueChange: onWeight,
+  })
+
+  return (
+    <View>
+      <TextInput
+        {...field.inputProps}
+        placeholder="165 lb or 75 kg"
+        accessibilityLabel="Package weight"
+      />
+      {field.errorMessage ? <Text>{field.errorMessage}</Text> : null}
+      {!field.errorMessage && field.hint ? <Text>{field.hint}</Text> : null}
+      <FlatList
+        data={[...field.completions]}
+        keyExtractor={(item) => item.text}
+        renderItem={({ item, index }) => (
+          <Pressable onPress={() => field.selectCompletion(index)}>
+            <Text>{item.text}</Text>
+          </Pressable>
+        )}
+      />
+    </View>
+  )
+}
+```
+
+DOM-free headless adapter — same parse/commit semantics as web, no browser APIs:
+
+- `inputProps`: `{ value, onChangeText, onBlur, onSubmitEditing }` — spread onto RN `TextInput`.
+- Display vs canonical: `text` (what the user sees), `value` (number in `unit`), `submitValue` (backend string), `quantity` / `result`.
+- Lifecycle: typing uses `partialState` (`idle`/`incomplete`/`valid`/`invalid`); blur / submit / `commit()` canonicalizes (`display: 'canonical'|'echo'|'preserve'`).
+- Validation: `required`, `min`/`max` (parseable strings or numbers), `errorMessage`, `hint`, `touched`, `dirty`.
+- Completions (injected): `completions`, `highlightedIndex`, `setHighlightedIndex(i)`, `selectCompletion(i?)` — render with `FlatList`; engine is not bundled.
+- Imperative: `set(number|string)`, `commit()`. Controlled: `value` + `onValueChange`.
+- Imports React only (optional peer). Does **not** import `react-native`, DOM, or `./complete`.
 
 ## Element (`@pascal-app/lingo/element`)
 
diff --git a/apps/site/src/app/docs/page.tsx b/apps/site/src/app/docs/page.tsx
index 7f7362f..63957cb 100644
--- a/apps/site/src/app/docs/page.tsx
+++ b/apps/site/src/app/docs/page.tsx
@@ -44,6 +44,7 @@ import {
   formSnippet,
   integrationSnippets,
   localeSnippet,
+  reactNativeSnippet,
   schemaTabs,
   strictnessSnippet,
   typeSafetySnippet,
@@ -487,7 +488,7 @@ export default async function Home() {
           <Section
             explainer="Turn any native input into a natural-language field: parse on input, never rewrite mid-typing, and submit one hidden canonical value on commit."
             id="forms"
-            kicker="DOM + React"
+            kicker="DOM + React + Native"
             title="Inputs"
           >
             <CodeBlock code={formSnippet} filename="dom-field.ts" lang="ts" />
@@ -515,6 +516,21 @@ export default async function Home() {
               </p>
               <CodeBlock code={elementSnippet} filename="lingo-input.html" lang="html" />
             </div>
+            <div className="flex min-w-0 flex-col gap-3">
+              <SubHeading id="forms-react-native">React Native</SubHeading>
+              <p className="text-muted-foreground text-sm">
+                <code className="rounded bg-muted px-[0.3rem] py-[0.2rem] font-mono text-foreground text-sm">
+                  useLingoTextInput
+                </code>{' '}
+                gives React Native{' '}
+                <code className="rounded bg-muted px-[0.3rem] py-[0.2rem] font-mono text-foreground text-sm">
+                  TextInput
+                </code>{' '}
+                the same partial-state parsing and commit canonicalization without importing the DOM
+                controller or React Native runtime.
+              </p>
+              <CodeBlock code={reactNativeSnippet} filename="weight-field.tsx" lang="tsx" />
+            </div>
           </Section>
 
           <Section
diff --git a/apps/site/src/components/site/completions-demo.tsx b/apps/site/src/components/site/completions-demo.tsx
index 320dfeb..dd42847 100644
--- a/apps/site/src/components/site/completions-demo.tsx
+++ b/apps/site/src/components/site/completions-demo.tsx
@@ -9,7 +9,8 @@ import { fr } from '@pascal-app/lingo/locales/fr'
 import { ja } from '@pascal-app/lingo/locales/ja'
 import { pt } from '@pascal-app/lingo/locales/pt'
 import { zh } from '@pascal-app/lingo/locales/zh'
-import { useEffect, useId, useMemo, useState } from 'react'
+import { useLingoInput } from '@pascal-app/lingo/react'
+import { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react'
 
 import { DocsPane, DocsSplitPaneSection } from '@/components/site/docs-split-pane'
 import { LocaleBadge } from '@/components/site/locale-select'
@@ -35,19 +36,6 @@ type UnitPreset = (typeof UNIT_PRESETS)[number]
 
 const localeLingo = createLingo({ locales: [es, fr, pt, zh, ja, enGb] })
 
-function useDebouncedValue<T>(value: T, delayMs: number) {
-  const [debounced, setDebounced] = useState(value)
-
-  useEffect(() => {
-    const timer = window.setTimeout(() => {
-      setDebounced(value)
-    }, delayMs)
-    return () => window.clearTimeout(timer)
-  }, [delayMs, value])
-
-  return { debounced, pending: debounced !== value }
-}
-
 function completionOptions() {
   return {
     date: (text: string) => {
@@ -92,7 +80,7 @@ function RankedList({
   pending = false,
 }: {
   activeIndex: number
-  items: Completion[]
+  items: readonly Completion[]
   listId: string
   onActiveIndexChange: (index: number) => void
   onPick: (item: Completion) => void
@@ -139,17 +127,35 @@ function RankedList({
 
 function RankedAutocompleteDemo() {
   const listId = useId()
-  const [value, setValue] = useState('2 f')
-  const [activeIndex, setActiveIndex] = useState(0)
-  const { debounced: query, pending } = useDebouncedValue(value, DEBOUNCE_MS)
-  const items = useMemo(() => completions(query, completionOptions()), [query])
+  const inputRef = useRef<HTMLInputElement | null>(null)
+  const field = useLingoInput({
+    debounce: DEBOUNCE_MS,
+    listboxId: listId,
+    complete: (text: string) => completions(text, completionOptions()),
+  })
+  const items = field.completions as readonly Completion[]
+  const { highlightedIndex: activeIndex } = field
   const activeId =
-    items.length > 0 ? `${listId}-item-${Math.min(activeIndex, items.length - 1)}` : undefined
+    activeIndex >= 0 && items.length > 0 ? `${listId}-item-${activeIndex}` : undefined
 
-  function updateValue(next: string) {
-    setValue(next)
-    setActiveIndex(0)
-  }
+  const setInputRef = useCallback(
+    (node: HTMLInputElement | null) => {
+      inputRef.current = node
+      field.ref(node)
+    },
+    [field.ref],
+  )
+
+  const updateValue = useCallback((next: string) => {
+    const input = inputRef.current
+    if (!input) {
+      return
+    }
+    input.value = next
+    input.dispatchEvent(new Event('input', { bubbles: true }))
+  }, [])
+
+  useEffect(() => updateValue('2 f'), [updateValue])
 
   return (
     <DocsSplitPaneSection aria-label="Ranked autocomplete example">
@@ -159,47 +165,35 @@ function RankedAutocompleteDemo() {
           title="Autocomplete anything"
         />
         <div className="flex flex-col gap-2">
-          <div className="flex items-end justify-between gap-3">
-            <Label htmlFor={`${listId}-input`}>Type a partial value</Label>
-            <span
-              aria-live="polite"
-              className={cn(
-                'font-mono text-[10px] text-muted-foreground uppercase transition-opacity duration-150',
-                pending ? 'opacity-100' : 'opacity-0',
-              )}
-            >
-              Updating…
-            </span>
-          </div>
+          <Label htmlFor={`${listId}-input`}>Type a partial value</Label>
           <Input
             aria-activedescendant={activeId}
-            aria-autocomplete="list"
-            aria-busy={pending}
-            aria-controls={listId}
-            aria-expanded={items.length > 0}
             autoComplete="off"
             className="rounded-[6px]"
             id={`${listId}-input`}
-            onChange={(event) => updateValue(event.target.value)}
-            onKeyDown={(event) => {
+            onKeyDownCapture={(event) => {
               if (items.length === 0) {
                 return
               }
               if (event.key === 'ArrowDown') {
                 event.preventDefault()
-                setActiveIndex((index) => Math.min(index + 1, items.length - 1))
+                field.setHighlightedIndex(activeIndex + 1)
               }
               if (event.key === 'ArrowUp') {
                 event.preventDefault()
-                setActiveIndex((index) => Math.max(index - 1, 0))
+                field.setHighlightedIndex(activeIndex - 1)
               }
-              if (event.key === 'Enter' && items[activeIndex]) {
+              if (event.key === 'Enter' && activeIndex >= 0) {
                 event.preventDefault()
-                updateValue(items[activeIndex]!.text)
+                event.stopPropagation()
+                field.selectCompletion(activeIndex)
+              }
+              if (event.key === 'Escape') {
+                event.preventDefault()
+                event.currentTarget.blur()
               }
             }}
-            role="combobox"
-            value={value}
+            ref={setInputRef}
           />
         </div>
         <div className="flex flex-wrap items-center gap-x-2 gap-y-1.5 text-xs">
@@ -226,9 +220,8 @@ function RankedAutocompleteDemo() {
           activeIndex={activeIndex}
           items={items}
           listId={listId}
-          onActiveIndexChange={setActiveIndex}
-          onPick={(item) => updateValue(item.text)}
-          pending={pending}
+          onActiveIndexChange={field.setHighlightedIndex}
+          onPick={(item) => field.selectCompletion(items.indexOf(item))}
         />
       </DocsPane>
     </DocsSplitPaneSection>
diff --git a/apps/site/src/lib/code-snippets.ts b/apps/site/src/lib/code-snippets.ts
index 7b52825..b546c99 100644
--- a/apps/site/src/lib/code-snippets.ts
+++ b/apps/site/src/lib/code-snippets.ts
@@ -12,6 +12,7 @@ const range = parseRange("between 5 and 10 kg", { kind: "mass" })`
 export const completionsSnippet = `import { completions } from "@pascal-app/lingo/complete"
 import { parseDate, parseDateRange } from "@pascal-app/lingo/date"
 import { lingoInput } from "@pascal-app/lingo/dom"
+import { useLingoInput } from "@pascal-app/lingo/react"
 
 // Debounce in your UI (~120–150ms) — completions() re-parses on every call
 const items = completions("10 kg to 16", { kind: "mass", limit: 8 })
@@ -33,7 +34,17 @@ lingoInput(input, {
   kind: "mass",
   complete: (text) => completions(text, { kind: "mass", limit: 8 }),
   onComplete: (list) => renderGroupedDropdown(list),
-})`
+})
+
+// React exposes the same injected list plus headless highlight/selection state
+const field = useLingoInput({
+  kind: "mass",
+  listboxId: "mass-options",
+  complete: (text) => completions(text, { kind: "mass", limit: 8 }),
+})
+field.completions
+field.setHighlightedIndex(1)
+field.selectCompletion()`
 
 export const strictnessSnippet = `import { lingo } from "@pascal-app/lingo"
 
@@ -71,6 +82,25 @@ function HeightField() {
   return <input ref={field.ref} placeholder="5'11\\" or 180cm" />
 }`
 
+export const reactNativeSnippet = `import { Text, TextInput, View } from "react-native"
+import { useLingoTextInput } from "@pascal-app/lingo/react-native"
+
+function WeightField() {
+  const field = useLingoTextInput({
+    kind: "mass",
+    unit: "kg",
+    min: 0,
+    max: "500 kg",
+  })
+
+  return (
+    <View>
+      <TextInput {...field.inputProps} placeholder="165 lb or 75 kg" />
+      {field.errorMessage ? <Text>{field.errorMessage}</Text> : null}
+    </View>
+  )
+}`
+
 export const findSnippet = `import { findQuantities } from "@pascal-app/lingo"
 
 const found = findQuantities("ship 2 boxes at 5 kg each by friday")
diff --git a/apps/site/src/lib/docs-catalog.ts b/apps/site/src/lib/docs-catalog.ts
index 9a3b426..f97136e 100644
--- a/apps/site/src/lib/docs-catalog.ts
+++ b/apps/site/src/lib/docs-catalog.ts
@@ -111,6 +111,8 @@ export const docsNavGroups: DocsNavGroup[] = [
       page('forms', 'Inputs', 'Turn any input into a natural-language field.', [
         'dom',
         'react',
+        'react native',
+        'textinput',
         'input',
         'field',
         'validation',
@@ -127,6 +129,13 @@ export const docsNavGroups: DocsNavGroup[] = [
         ['lingo-input', 'web component', 'element', 'defineLingoInput', 'vue', 'svelte', 'angular'],
         { depth: 3, markdownSectionId: 'forms' },
       ),
+      page(
+        'forms-react-native',
+        'React Native',
+        'DOM-free parsing and canonicalization for TextInput.',
+        ['react native', 'textinput', 'mobile', 'useLingoTextInput'],
+        { depth: 3, markdownSectionId: 'forms' },
+      ),
       page(
         'forms-range-slider',
         'Two-way slider',
diff --git a/apps/site/src/lib/docs.md.ts b/apps/site/src/lib/docs.md.ts
index 7491ff9..f26bba8 100644
--- a/apps/site/src/lib/docs.md.ts
+++ b/apps/site/src/lib/docs.md.ts
@@ -9,6 +9,7 @@ import {
   formSnippet,
   integrationSnippets,
   parseSnippet,
+  reactNativeSnippet,
   reactSnippet,
   schemaTabs,
   strictnessSnippet,
@@ -128,6 +129,12 @@ export const docsMarkdown = [
   '',
   fenced('tsx', reactSnippet),
   '',
+  '### React Native',
+  '',
+  '`useLingoTextInput()` is a DOM-free hook for React Native `TextInput`. It returns controlled text handlers, canonical value and submit state, required/bounds issues, hints, and injected completion state without importing `react-native`.',
+  '',
+  fenced('tsx', reactNativeSnippet),
+  '',
   'Caption: Fields never rewrite while typing; commits canonicalize once.',
   '',
   'Form demo rules:',
diff --git a/bun.lock b/bun.lock
index f06ab28..3bed736 100644
--- a/bun.lock
+++ b/bun.lock
@@ -37,6 +37,7 @@
         "@typescript/native-preview": "7.0.0-dev.20260704.1",
         "eslint": "^9",
         "eslint-config-next": "16.2.10",
+        "jsdom": "^29.1.1",
         "react-doctor": "^0.6.2",
         "react-grab": "^0.1.48",
         "react-scan": "^0.5.7",
@@ -46,7 +47,7 @@
     },
     "packages/lingo": {
       "name": "@pascal-app/lingo",
-      "version": "0.2.0",
+      "version": "0.2.1",
       "devDependencies": {
         "@standard-schema/spec": "^1.1.0",
         "@types/react": "^19.2.17",
@@ -757,19 +758,19 @@
 
     "@vercel/analytics": ["@vercel/analytics@2.0.1", "", { "peerDependencies": { "@remix-run/react": "^2", "@sveltejs/kit": "^1 || ^2", "next": ">= 13", "nuxt": ">= 3", "react": "^18 || ^19 || ^19.0.0-rc", "svelte": ">= 4", "vue": "^3", "vue-router": "^4" }, "optionalPeers": ["@remix-run/react", "@sveltejs/kit", "next", "nuxt", "react", "svelte", "vue", "vue-router"] }, "sha512-MTQG6V9qQrt1tsDeF+2Uoo5aPjqbVPys1xvnIftXSJYG2SrwXRHnqEvVoYID7BTruDz4lCd2Z7rM1BdkUehk2g=="],
 
-    "@vitest/expect": ["@vitest/expect@4.1.9", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "@types/chai": "^5.2.2", "@vitest/spy": "4.1.9", "@vitest/utils": "4.1.9", "chai": "^6.2.2", "tinyrainbow": "^3.1.0" } }, "sha512-vl/rYsUKcBr3SnQn166+XR5ZQcgMx3DQhFWdfli/cWpLnLUmbxZvyrJZotLFUryib+LtArYMSTJ5RbQ57ZqrlA=="],
+    "@vitest/expect": ["@vitest/expect@4.1.10", "", { "dependencies": { "@standard-schema/spec": "^1.1.0", "@types/chai": "^5.2.2", "@vitest/spy": "4.1.10", "@vitest/utils": "4.1.10", "chai": "^6.2.2", "tinyrainbow": "^3.1.0" } }, "sha512-YsCn+qAk1GWjQOWFEsEcL2gNQ0zmVmQu3T03qP6UyjhtmdtwtbuI+DASn/7iQB3HGTXkdBwGddzxPlmiql5vlA=="],
 
-    "@vitest/mocker": ["@vitest/mocker@4.1.9", "", { "dependencies": { "@vitest/spy": "4.1.9", "estree-walker": "^3.0.3", "magic-string": "^0.30.21" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" }, "optionalPeers": ["msw", "vite"] }, "sha512-EVkXzBjrPGM+cK8/ANWgBrkUCfJfb38/EfTSO8h7pWvKkyPkpWxvR7BkD2MyItMF62C97zAEoqdpUixwR/e+Rw=="],
+    "@vitest/mocker": ["@vitest/mocker@4.1.10", "", { "dependencies": { "@vitest/spy": "4.1.10", "estree-walker": "^3.0.3", "magic-string": "^0.30.21" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^6.0.0 || ^7.0.0 || ^8.0.0" }, "optionalPeers": ["msw", "vite"] }, "sha512-v0xaezt+DKEmKfaxg133ldzADrwLGd7Ze1MfQQTYfvs8OqZIwbxyxaYURivwV7sWy5fqn3rH5uOrSp07bp44Ow=="],
 
-    "@vitest/pretty-format": ["@vitest/pretty-format@4.1.9", "", { "dependencies": { "tinyrainbow": "^3.1.0" } }, "sha512-s0iufns3iIFitdgm+YR7g1whCAaGtXz459VS9/PqyKDEEFgYIhsHOQmXgIgDuYCt7DeQmiZT0Qe2OA2p4ZPu5A=="],
+    "@vitest/pretty-format": ["@vitest/pretty-format@4.1.10", "", { "dependencies": { "tinyrainbow": "^3.1.0" } }, "sha512-W1HsjSH4MXQ9YfmmhLAoIYf1HRfekQCGngeIgcei6MP5QQGWUe0gkopdZQaVCFO+JDJMrAJGwa5pRpNpvy4P8Q=="],
 
-    "@vitest/runner": ["@vitest/runner@4.1.9", "", { "dependencies": { "@vitest/utils": "4.1.9", "pathe": "^2.0.3" } }, "sha512-KXLMDtc7oe70+3mJfGrPUWPesswH+3sTxAMAMl8DG7I8IUQT4XW718dY5ID3vPUcmlu27CcKfY4P3h3I29SLJg=="],
+    "@vitest/runner": ["@vitest/runner@4.1.10", "", { "dependencies": { "@vitest/utils": "4.1.10", "pathe": "^2.0.3" } }, "sha512-IKI6kpIH+LmpROplyLwBBaCfMgOZOMsygVa6BARD6ahA04VRuJSa6OaVG7kRvSEMD870Vd91rSSw0eegtWyLGg=="],
 
-    "@vitest/snapshot": ["@vitest/snapshot@4.1.9", "", { "dependencies": { "@vitest/pretty-format": "4.1.9", "@vitest/utils": "4.1.9", "magic-string": "^0.30.21", "pathe": "^2.0.3" } }, "sha512-Jc7RKGNBo8Z28WYIm0Niej4xdSPByRf6mU58VpHQkd6Zh05rlnA+twjbK5HyeIGHxrzsc3mJgS43uM0CZKzaIA=="],
+    "@vitest/snapshot": ["@vitest/snapshot@4.1.10", "", { "dependencies": { "@vitest/pretty-format": "4.1.10", "@vitest/utils": "4.1.10", "magic-string": "^0.30.21", "pathe": "^2.0.3" } }, "sha512-xRkfOT1qpTAi/Ti4Y1LtfRc3kEuqxGw59eN2jN9pRWMtS/XDevekhcFSqvQqjUNGksfjMJu3Y+oJ+4Ypn2OaJw=="],
 
-    "@vitest/spy": ["@vitest/spy@4.1.9", "", {}, "sha512-fHpsS6mIi+PiEW+vcRVOMkX1oSaPKne3VOclSFICPcGOmfKgXPU5iAah+wcNcj2xPrCCmfq99IDGf+EojhhvhA=="],
+    "@vitest/spy": ["@vitest/spy@4.1.10", "", {}, "sha512-PLf/Ugvoq5wO/b4rwYCR1h2PSIdXz7wnkQFMiUpLdtM7l6pqVFcQIBEHyT1+l+cj7mNwAfZHzqXqDyjvOuwbDw=="],
 
-    "@vitest/utils": ["@vitest/utils@4.1.9", "", { "dependencies": { "@vitest/pretty-format": "4.1.9", "convert-source-map": "^2.0.0", "tinyrainbow": "^3.1.0" } }, "sha512-A51o8ymO5PpqlWNnBP9ZHPXDIpuMtTLlGSjN7la4US+LJzoUMyhwjA5QXlm39JexgwHKW4Xjs8Z2d3dLCXOeuA=="],
+    "@vitest/utils": ["@vitest/utils@4.1.10", "", { "dependencies": { "@vitest/pretty-format": "4.1.10", "convert-source-map": "^2.0.0", "tinyrainbow": "^3.1.0" } }, "sha512-fy9am/HWxbaGt/Sawrp90vt6Y6jQwf1RX77cz3uwoJwJVMli/e1IEwRPnMNJ7vKfPTwo0diXifkpPvwH9v7nGA=="],
 
     "acorn": ["acorn@8.17.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg=="],
 
@@ -1675,7 +1676,7 @@
 
     "vite": ["vite@8.1.3", "", { "dependencies": { "lightningcss": "^1.32.0", "picomatch": "^4.0.4", "postcss": "^8.5.16", "rolldown": "~1.1.3", "tinyglobby": "^0.2.17" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "@vitejs/devtools": "^0.3.0", "esbuild": "^0.27.0 || ^0.28.0", "jiti": ">=1.21.0", "less": "^4.0.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "@vitejs/devtools", "esbuild", "jiti", "less", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-Ds+gBRbj0lwRO2Y5hwnUBdxSwlAve9LeRyU4sNnAr0ewW0gWF0n5bgXgUzbgZ49MV9BVUAQUFYVcDUcilUExMA=="],
 
-    "vitest": ["vitest@4.1.9", "", { "dependencies": { "@vitest/expect": "4.1.9", "@vitest/mocker": "4.1.9", "@vitest/pretty-format": "4.1.9", "@vitest/runner": "4.1.9", "@vitest/snapshot": "4.1.9", "@vitest/spy": "4.1.9", "@vitest/utils": "4.1.9", "es-module-lexer": "^2.0.0", "expect-type": "^1.3.0", "magic-string": "^0.30.21", "obug": "^2.1.1", "pathe": "^2.0.3", "picomatch": "^4.0.3", "std-env": "^4.0.0-rc.1", "tinybench": "^2.9.0", "tinyexec": "^1.0.2", "tinyglobby": "^0.2.15", "tinyrainbow": "^3.1.0", "vite": "^6.0.0 || ^7.0.0 || ^8.0.0", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@opentelemetry/api": "^1.9.0", "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0", "@vitest/browser-playwright": "4.1.9", "@vitest/browser-preview": "4.1.9", "@vitest/browser-webdriverio": "4.1.9", "@vitest/coverage-istanbul": "4.1.9", "@vitest/coverage-v8": "4.1.9", "@vitest/ui": "4.1.9", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@opentelemetry/api", "@types/node", "@vitest/browser-playwright", "@vitest/browser-preview", "@vitest/browser-webdriverio", "@vitest/coverage-istanbul", "@vitest/coverage-v8", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "./vitest.mjs" } }, "sha512-nE3/LEyc0z87uHYLZebqCUOaJr2hdtuPp7BQ4BosVFnfltxgAvMG08NyrSGlPpOUWvR27c5flSmYFTNr78L9GQ=="],
+    "vitest": ["vitest@4.1.10", "", { "dependencies": { "@vitest/expect": "4.1.10", "@vitest/mocker": "4.1.10", "@vitest/pretty-format": "4.1.10", "@vitest/runner": "4.1.10", "@vitest/snapshot": "4.1.10", "@vitest/spy": "4.1.10", "@vitest/utils": "4.1.10", "es-module-lexer": "^2.0.0", "expect-type": "^1.3.0", "magic-string": "^0.30.21", "obug": "^2.1.1", "pathe": "^2.0.3", "picomatch": "^4.0.3", "std-env": "^4.0.0-rc.1", "tinybench": "^2.9.0", "tinyexec": "^1.0.2", "tinyglobby": "^0.2.15", "tinyrainbow": "^3.1.0", "vite": "^6.0.0 || ^7.0.0 || ^8.0.0", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@opentelemetry/api": "^1.9.0", "@types/node": "^20.0.0 || ^22.0.0 || >=24.0.0", "@vitest/browser-playwright": "4.1.10", "@vitest/browser-preview": "4.1.10", "@vitest/browser-webdriverio": "4.1.10", "@vitest/coverage-istanbul": "4.1.10", "@vitest/coverage-v8": "4.1.10", "@vitest/ui": "4.1.10", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@opentelemetry/api", "@types/node", "@vitest/browser-playwright", "@vitest/browser-preview", "@vitest/browser-webdriverio", "@vitest/coverage-istanbul", "@vitest/coverage-v8", "@vitest/ui", "happy-dom", "jsdom"], "bin": { "vitest": "./vitest.mjs" } }, "sha512-R9jUTe5S4Qb0HCd4TNqpC7oGcrMssMRGXLW80ubjWsW9VH5GF8y1Y0SFLY9AbqSk6nt0PnOx4H4WNJYZ13GUPw=="],
 
     "vscode-jsonrpc": ["vscode-jsonrpc@8.2.0", "", {}, "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA=="],
 
diff --git a/packages/lingo/CHANGELOG.md b/packages/lingo/CHANGELOG.md
index 3200bb0..9316dd9 100644
--- a/packages/lingo/CHANGELOG.md
+++ b/packages/lingo/CHANGELOG.md
@@ -7,12 +7,37 @@ change**, even if the API is untouched.
 
 ## [Unreleased]
 
+### Added
+
+- `@pascal-app/lingo/react-native`: DOM-free `useLingoTextInput()` for React
+  Native `TextInput`, including parse-as-you-type partial states, blur/submit
+  canonicalization, required/bounds validation, backend-ready `submitValue`,
+  and injected ranked completions. The entry imports React only—no
+  `react-native` runtime dependency.
+- `useLingoInput()` now forwards an injected ranked-completion provider and
+  exposes `completions`, `highlightedIndex`, `setHighlightedIndex()`, and
+  `selectCompletion()` for headless React comboboxes. `./complete` remains an
+  explicit, tree-shakeable import; no popup UI or runtime dependency is added.
+
 ### Changed
 
+- Shared field format helpers (`toLingoOptions`, `materialize`, commit/hint
+  formatting) now take a DOM-free `LingoFieldFormatOptions` surface so the React
+  Native adapter reuses them without casting through `LingoInputOptions`.
+- The npm `llms.txt` reference now includes full inline React and React Native
+  adapter recipes (completions, capture-phase keyboard notes, `inputProps`,
+  submit/canonical fields) so offline agents can integrate without fetching the
+  site.
 - The docs autocomplete showcase now separates ranked completions, loaded-locale
   examples, and caller-controlled unit suggestions into three focused,
   keyboard-navigable demos instead of one control-heavy panel.
 
+### Fixed
+
+- The docs autocomplete showcase now handles Enter during React's capture phase,
+  so selecting a highlighted completion wins over the input controller's native
+  primary-parse commit.
+
 ## [0.2.1] - 2026-07-09
 
 ### Added
diff --git a/packages/lingo/README.md b/packages/lingo/README.md
index 7bc5493..02e6003 100644
--- a/packages/lingo/README.md
+++ b/packages/lingo/README.md
@@ -97,6 +97,11 @@ a UX choice, not something the parser needs to survive. Reproduce with
 npm install @pascal-app/lingo
 ```
 
+Coding agents: the package ships an inline reference at
+`node_modules/@pascal-app/lingo/llms.txt` (also at
+[lingo.pascal.app/llms-small.txt](https://lingo.pascal.app/llms-small.txt)).
+Online, start at [lingo.pascal.app/llms.txt](https://lingo.pascal.app/llms.txt).
+
 ## The 5-minute tour
 
 ### Parse
@@ -398,14 +403,55 @@ Style it with attribute selectors:
 ### React: `@pascal-app/lingo/react`
 
 ```tsx
+import { completions } from '@pascal-app/lingo/complete'
 import { useLingoInput } from '@pascal-app/lingo/react'
 
 function HeightField() {
-  const { ref, state, value } = useLingoInput({ kind: 'length', unit: 'm', name: 'height_m' })
-  return <input ref={ref} placeholder={`try 5'11" or 180cm`} />
+  const field = useLingoInput({
+    kind: 'length',
+    unit: 'm',
+    name: 'height_m',
+    listboxId: 'height-options',
+    complete: (text) => completions(text, { kind: 'length' }),
+  })
+  return <input ref={field.ref} placeholder={`try 5'11" or 180cm`} />
 }
 ```
 
+The hook exposes `completions`, `highlightedIndex`,
+`setHighlightedIndex()`, and `selectCompletion()` for a caller-rendered
+listbox. `./complete` stays an injected import; `./react` does not bundle it or
+ship popup UI.
+
+### React Native: `@pascal-app/lingo/react-native`
+
+```tsx
+import { Text, TextInput, View } from 'react-native'
+import { useLingoTextInput } from '@pascal-app/lingo/react-native'
+
+function WeightField() {
+  const field = useLingoTextInput({
+    kind: 'mass',
+    unit: 'kg',
+    min: 0,
+    max: '500 kg',
+  })
+  return (
+    <View>
+      <TextInput {...field.inputProps} placeholder="165 lb or 75 kg" />
+      {field.errorMessage ? <Text>{field.errorMessage}</Text> : null}
+    </View>
+  )
+}
+```
+
+`onChangeText` parses without rewriting, while blur, submit, or `commit()`
+canonicalizes the display. `value` is the canonical number and `submitValue`
+is the backend-ready string. Inject `complete` from `./complete` for ranked
+suggestions (`completions` / `selectCompletion()`); render them with your own
+`FlatList`. The entry imports React only—there is no DOM controller,
+`react-native` runtime dependency, or bundled completion UI.
+
 ### Web components: `@pascal-app/lingo/element`
 
 A form-associated custom element for design systems with no framework
@@ -450,9 +496,9 @@ completions('5', { kind: 'length' }).map((c) => c.text)
 // ['5 m', '5 ft', '5 cm', '5 in', '5 km', '5 mi']
 ```
 
-The DOM field is headless about this too: `lingoInput` accepts injected
-`complete` / `onComplete` hooks, so you render your own dropdown — the library ships
-no UI. When completions are enabled it wires the combobox side of the ARIA
+The DOM field and React hook are headless about this too: inject `complete`,
+render your own dropdown, and use `onComplete` or the hook's completion state.
+When completions are enabled the input gets the combobox side of the ARIA
 contract (`role="combobox"`, `aria-autocomplete="list"`, `aria-expanded`), and
 `listboxId` sets `aria-controls` for your listbox.
 
diff --git a/packages/lingo/docs/recipes.md b/packages/lingo/docs/recipes.md
index fac625e..43adb30 100644
--- a/packages/lingo/docs/recipes.md
+++ b/packages/lingo/docs/recipes.md
@@ -696,6 +696,112 @@ const heightField = quantityField({ kind: 'length', unit: 'm', min: 0.3, max: 2.
 const weightField = quantityField({ kind: 'mass', unit: 'kg', min: 0 })
 ```
 
+### React ranked completions
+
+Inject `completions()` into the hook and render the listbox yourself. The hook
+owns only ranked-list state and selection; popup markup, option ids, styling,
+and keyboard policy stay in your component:
+
+```tsx
+import { completions } from '@pascal-app/lingo/complete'
+import { useLingoInput } from '@pascal-app/lingo/react'
+
+function HeightInput() {
+  const field = useLingoInput({
+    kind: 'length',
+    unit: 'm',
+    listboxId: 'height-options',
+    complete: (text) => completions(text, { kind: 'length', limit: 6 }),
+  })
+
+  return (
+    <>
+      <input
+        ref={field.ref}
+        aria-activedescendant={
+          field.highlightedIndex >= 0
+            ? `height-option-${field.highlightedIndex}`
+            : undefined
+        }
+        onKeyDownCapture={(event) => {
+          if (event.key === 'ArrowDown') {
+            event.preventDefault()
+            field.setHighlightedIndex(field.highlightedIndex + 1)
+          }
+          if (event.key === 'ArrowUp') {
+            event.preventDefault()
+            field.setHighlightedIndex(field.highlightedIndex - 1)
+          }
+          if (event.key === 'Enter' && field.highlightedIndex >= 0) {
+            event.preventDefault()
+            event.stopPropagation()
+            field.selectCompletion(field.highlightedIndex)
+          }
+        }}
+      />
+      <div id="height-options" role="listbox">
+        {field.completions.map((item, index) => (
+          <button
+            aria-selected={index === field.highlightedIndex}
+            id={`height-option-${index}`}
+            key={`${item.source}-${item.text}`}
+            onClick={() => field.selectCompletion(index)}
+            role="option"
+            type="button"
+          >
+            {item.text}
+          </button>
+        ))}
+      </div>
+    </>
+  )
+}
+```
+
+The `Completion` type is shared through the DOM layer, but the completion
+engine is not: importing `./react` alone never pulls in `./complete`.
+Handle Enter in React's capture phase so completion selection runs before the
+controller's native Enter-to-commit listener.
+
+### React Native `TextInput`
+
+The native adapter owns display text and returns the four props `TextInput`
+needs. It does not import React Native or emulate browser validation:
+
+```tsx
+import { Text, TextInput, View } from 'react-native'
+import { useLingoTextInput } from '@pascal-app/lingo/react-native'
+
+function PackageWeight({ onWeight }: { onWeight: (kg: number | null) => void }) {
+  const field = useLingoTextInput({
+    kind: 'mass',
+    unit: 'kg',
+    min: 0,
+    max: '500 kg',
+    onValueChange: onWeight,
+  })
+
+  return (
+    <View>
+      <TextInput
+        {...field.inputProps}
+        accessibilityLabel="Package weight"
+        accessibilityHint="Enter a weight in kilograms or pounds"
+        placeholder="165 lb or 75 kg"
+      />
+      {field.errorMessage ? <Text accessibilityLiveRegion="polite">{field.errorMessage}</Text> : null}
+      {!field.errorMessage && field.hint ? <Text>{field.hint}</Text> : null}
+    </View>
+  )
+}
+```
+
+`field.text` is display text; `field.value` is the canonical number in `unit`;
+`field.submitValue` is the backend-ready string. Typing never rewrites text.
+Blur, `onSubmitEditing`, and `commit()` apply canonical formatting. Inject
+`completions()` exactly as on web and render the returned items with a
+`FlatList`; the completion engine remains an explicit import.
+
 ### React Hook Form
 
 For a whole form, `lingoObject` drops straight into the resolver:
diff --git a/packages/lingo/llms.txt b/packages/lingo/llms.txt
index 6576144..3833bb1 100644
--- a/packages/lingo/llms.txt
+++ b/packages/lingo/llms.txt
@@ -4,7 +4,7 @@
 
 Agent fetch order (online): `https://lingo.pascal.app/llms.txt` (index) → `https://lingo.pascal.app/docs/<section>.md` (per-topic) or `https://lingo.pascal.app/llms-full.txt` (complete narrative). Offline: this file (`node_modules/@pascal-app/lingo/llms.txt`) is the compressed self-contained reference. Keep user measurements as strings in tool schemas; call lingo to convert, validate, surface spans, and handle ambiguity.
 
-Entries: `@pascal-app/lingo` (core+units+fuzzy), `@pascal-app/lingo/date`, `@pascal-app/lingo/dom`, `@pascal-app/lingo/element` (`<lingo-input>`), `@pascal-app/lingo/react`, `@pascal-app/lingo/ai` (LLM tool fields), `@pascal-app/lingo/mcp` (MCP tool helper), `@pascal-app/lingo/describe` (rich value/result descriptions), `@pascal-app/lingo/catalog` (query units/kinds/currencies + ISO country codes), `@pascal-app/lingo/complete` (ranked autocomplete completions), `@pascal-app/lingo/schema` (JSON Schema + OpenAPI + enum reference), `@pascal-app/lingo/locales/{en,en-gb,es,fr,pt,zh,ja}` (tree-shakeable language packs), `@pascal-app/lingo/core`.
+Entries: `@pascal-app/lingo` (core+units+fuzzy), `@pascal-app/lingo/date`, `@pascal-app/lingo/dom`, `@pascal-app/lingo/element` (`<lingo-input>`), `@pascal-app/lingo/react`, `@pascal-app/lingo/react-native`, `@pascal-app/lingo/ai` (LLM tool fields), `@pascal-app/lingo/mcp` (MCP tool helper), `@pascal-app/lingo/describe` (rich value/result descriptions), `@pascal-app/lingo/catalog` (query units/kinds/currencies + ISO country codes), `@pascal-app/lingo/complete` (ranked autocomplete completions), `@pascal-app/lingo/schema` (JSON Schema + OpenAPI + enum reference), `@pascal-app/lingo/locales/{en,en-gb,es,fr,pt,zh,ja}` (tree-shakeable language packs), `@pascal-app/lingo/core`.
 
 ## Core (`@pascal-app/lingo`)
 
@@ -41,7 +41,7 @@ const items = completions("10 kg to 16", { kind: "mass", limit: 8 })
 // [{ text, result, confidence, source }] — source: parse|alternative|unit-ambiguity|unit-prefix|implied-unit|range-implied|cross-kind|date
 ```
 
-Distinct from success `alternatives`, failure `candidate`, and issue `suggestions`. Wire into `lingoInput({ complete, onComplete })` for autocomplete dropdowns. Pass `date: (text) => parseDate(text, { now })` to opt into date completions without bundling `@pascal-app/lingo/date` into `@pascal-app/lingo/complete`.
+Distinct from success `alternatives`, failure `candidate`, and issue `suggestions`. Wire into `lingoInput({ complete, onComplete })` or `useLingoInput({ complete })` for autocomplete dropdowns. The React hook exposes `completions`, `highlightedIndex`, `setHighlightedIndex()`, and `selectCompletion()` while keeping popup UI caller-owned. Pass `date: (text) => parseDate(text, { now })` to opt into date completions without bundling `@pascal-app/lingo/date` into `@pascal-app/lingo/complete`.
 
 ## Locales (`@pascal-app/lingo/locales/*`)
 
@@ -110,7 +110,102 @@ field.set("6ft")
 field.commit() // hidden input submits canonical value
 ```
 
-`field.value` · `.quantity` · `.result` · `.state` ('idle'|'incomplete'|'valid'|'invalid') · `.set()` · `.commit()` · `.update()` · `.destroy()`. Never rewrites while typing; canonicalizes on blur/Enter/submit. With `complete`/`onComplete`, the input gets the headless WAI-ARIA combobox attributes (`role="combobox"`, `aria-autocomplete="list"`, `aria-expanded`); pass `listboxId` to set `aria-controls` for your rendered listbox. React: `useLingoInput(opts)` from `@pascal-app/lingo/react`.
+`field.value` · `.quantity` · `.result` · `.state` ('idle'|'incomplete'|'valid'|'invalid') · `.set()` · `.commit()` · `.update()` · `.destroy()`. Never rewrites while typing; canonicalizes on blur/Enter/submit. With `complete`/`onComplete`, the input gets the headless WAI-ARIA combobox attributes (`role="combobox"`, `aria-autocomplete="list"`, `aria-expanded`); pass `listboxId` to set `aria-controls` for your rendered listbox.
+
+## React (`@pascal-app/lingo/react`)
+
+```tsx
+import { completions } from "@pascal-app/lingo/complete"
+import { useLingoInput } from "@pascal-app/lingo/react"
+
+function HeightField() {
+  const field = useLingoInput({
+    kind: "length",
+    unit: "m",
+    name: "height_m",
+    listboxId: "height-options",
+    complete: (text) => completions(text, { kind: "length" }),
+  })
+  return (
+    <>
+      <input ref={field.ref} data-state={field.state} />
+      <ul id="height-options" role="listbox">
+        {field.completions.map((item, index) => (
+          <li
+            key={item.text}
+            role="option"
+            aria-selected={index === field.highlightedIndex}
+            onMouseDown={(e) => {
+              e.preventDefault()
+              field.selectCompletion(index)
+            }}
+          >
+            {item.text}
+          </li>
+        ))}
+      </ul>
+    </>
+  )
+}
+```
+
+- Attach `field.ref` to `<input>` / `<textarea>` (DOM controller underneath).
+- Live state: `state`, `value` (canonical number), `quantity`, `result`.
+- Completions (when `complete` injected): `completions`, `highlightedIndex`, `setHighlightedIndex(i)`, `selectCompletion(i?)`.
+- Imperative: `set(number|string)`, `commit()`. Controlled: `value: number | null` + `onValueChange`.
+- Keyboard: handle Arrow/Enter in **capture phase** (`onKeyDownCapture`) so selection beats the controller's native Enter-to-commit.
+- `'use client'` entry; React is an optional peer. `./complete` stays an explicit import.
+
+## React Native (`@pascal-app/lingo/react-native`)
+
+```tsx
+import { FlatList, Text, TextInput, Pressable, View } from "react-native"
+import { completions } from "@pascal-app/lingo/complete"
+import { useLingoTextInput } from "@pascal-app/lingo/react-native"
+
+function WeightField({ onWeight }: { onWeight: (kg: number | null) => void }) {
+  const field = useLingoTextInput({
+    kind: "mass",
+    unit: "kg",
+    min: 0,
+    max: "500 kg",
+    required: true,
+    complete: (text) => completions(text, { kind: "mass", limit: 6 }),
+    onValueChange: onWeight,
+  })
+
+  return (
+    <View>
+      <TextInput
+        {...field.inputProps}
+        placeholder="165 lb or 75 kg"
+        accessibilityLabel="Package weight"
+      />
+      {field.errorMessage ? <Text>{field.errorMessage}</Text> : null}
+      {!field.errorMessage && field.hint ? <Text>{field.hint}</Text> : null}
+      <FlatList
+        data={[...field.completions]}
+        keyExtractor={(item) => item.text}
+        renderItem={({ item, index }) => (
+          <Pressable onPress={() => field.selectCompletion(index)}>
+            <Text>{item.text}</Text>
+          </Pressable>
+        )}
+      />
+    </View>
+  )
+}
+```
+
+DOM-free headless adapter — same parse/commit semantics as web, no browser APIs:
+
+- `inputProps`: `{ value, onChangeText, onBlur, onSubmitEditing }` — spread onto RN `TextInput`.
+- Display vs canonical: `text` (what the user sees), `value` (number in `unit`), `submitValue` (backend string), `quantity` / `result`.
+- Lifecycle: typing uses `partialState` (`idle`/`incomplete`/`valid`/`invalid`); blur / submit / `commit()` canonicalizes (`display: 'canonical'|'echo'|'preserve'`).
+- Validation: `required`, `min`/`max` (parseable strings or numbers), `errorMessage`, `hint`, `touched`, `dirty`.
+- Completions (injected): `completions`, `highlightedIndex`, `setHighlightedIndex(i)`, `selectCompletion(i?)` — render with `FlatList`; engine is not bundled.
+- Imperative: `set(number|string)`, `commit()`. Controlled: `value` + `onValueChange`.
+- Imports React only (optional peer). Does **not** import `react-native`, DOM, or `./complete`.
 
 ## Element (`@pascal-app/lingo/element`)
 
diff --git a/packages/lingo/package.json b/packages/lingo/package.json
index d728de1..7271293 100644
--- a/packages/lingo/package.json
+++ b/packages/lingo/package.json
@@ -154,6 +154,16 @@
         "default": "./dist/react/index.cjs"
       }
     },
+    "./react-native": {
+      "import": {
+        "types": "./dist/react-native/index.d.ts",
+        "default": "./dist/react-native/index.js"
+      },
+      "require": {
+        "types": "./dist/react-native/index.d.cts",
+        "default": "./dist/react-native/index.cjs"
+      }
+    },
     "./complete": {
       "import": {
         "types": "./dist/complete/index.d.ts",
diff --git a/packages/lingo/scripts/check-zero-deps.mjs b/packages/lingo/scripts/check-zero-deps.mjs
index b3d2f35..b7153ca 100644
--- a/packages/lingo/scripts/check-zero-deps.mjs
+++ b/packages/lingo/scripts/check-zero-deps.mjs
@@ -2,7 +2,8 @@
 // Two mechanical checks behind the prose rule:
 //   1. package.json declares no `dependencies`.
 //   2. No runtime module under src/ imports a bare specifier. Relative imports
-//      only — the single exception is the optional `react` peer inside src/react/.
+//      only — the single exception is the optional `react` peer inside the
+//      React adapter entries.
 // Test files (*.test.ts) are exempt (they import vitest). TSDoc @example blocks
 // are naturally exempt: their lines start with `*`, not `import`.
 import { readdirSync, readFileSync, statSync } from 'node:fs'
@@ -19,7 +20,12 @@ if (deps.length > 0) {
 }
 
 /** Bare specifiers allowed, keyed to where they may appear. */
-const ALLOWED = [{ specifier: 'react', where: (file) => file.startsWith('react/') }]
+const ALLOWED = [
+  {
+    specifier: 'react',
+    where: (file) => file.startsWith('react/') || file.startsWith('react-native/'),
+  },
+]
 
 function* walk(dir) {
   for (const name of readdirSync(dir)) {
@@ -69,5 +75,5 @@ if (failures.length > 0) {
   process.exit(1)
 }
 console.log(
-  'Zero-dependency gate ok: no dependencies, src imports are relative-only (react peer allowed in src/react).',
+  'Zero-dependency gate ok: no dependencies, src imports are relative-only (react peer allowed in React adapter entries).',
 )
diff --git a/packages/lingo/scripts/size.mjs b/packages/lingo/scripts/size.mjs
index 1c1d668..8f89632 100644
--- a/packages/lingo/scripts/size.mjs
+++ b/packages/lingo/scripts/size.mjs
@@ -353,6 +353,16 @@ if (has('src/dom/index.ts')) {
   }
 }
 
+if (has('src/react-native/index.ts')) {
+  const withReactNative = await bundleStdin(
+    `export * from './src/index.ts'; export * from './src/react-native/index.ts'`,
+    ['react'],
+  )
+  // Plan 034 — DOM-free TextInput state, commit formatting, bounds, and
+  // injected completions. React stays external; react-native is never imported.
+  check('./react-native (marginal over full)', withReactNative - full, 2800)
+}
+
 if (has('src/describe/index.ts')) {
   const withDescribe = await bundleStdin(
     `export * from './src/index.ts'; export * from './src/describe/index.ts'`,
diff --git a/packages/lingo/src/dom/format.ts b/packages/lingo/src/dom/format.ts
index bced65f..3c34f8c 100644
--- a/packages/lingo/src/dom/format.ts
+++ b/packages/lingo/src/dom/format.ts
@@ -14,6 +14,28 @@ import type { LingoInputOptions } from './index'
 
 export type CandidateResult = Exclude<LingoResult, { ok: false }>
 
+/**
+ * Parse/format knobs shared by the DOM controller and the React Native
+ * headless field. Deliberately excludes DOM wiring (`name`, elements, ARIA)
+ * and callback shapes so both adapters can pass options without casting.
+ */
+export type LingoFieldFormatOptions = Pick<
+  LingoInputOptions,
+  | 'accept'
+  | 'display'
+  | 'displayUnit'
+  | 'escalate'
+  | 'kind'
+  | 'messages'
+  | 'numberFormat'
+  | 'profile'
+  | 'registry'
+  | 'strictness'
+  | 'system'
+  | 'tolerance'
+  | 'unit'
+>
+
 export interface Material {
   approximate: boolean
   canonical: string | null
@@ -22,7 +44,7 @@ export interface Material {
   value: number | null
 }
 
-export function toLingoOptions(opts: LingoInputOptions): LingoOptions {
+export function toLingoOptions(opts: LingoFieldFormatOptions): LingoOptions {
   const out: LingoOptions = {}
   if (opts.kind !== undefined) {
     out.kind = opts.kind
@@ -64,7 +86,7 @@ export function toLingoOptions(opts: LingoInputOptions): LingoOptions {
 // pack registered via setDefaultMessages -> the code string) so pack
 // overrides reach DOM-produced RANGE_MIN/RANGE_MAX/REQUIRED issues too.
 export function localIssue<C extends 'RANGE_MIN' | 'RANGE_MAX' | 'REQUIRED'>(
-  opts: LingoInputOptions,
+  opts: LingoFieldFormatOptions,
   code: C,
   data: IssueInputData<C>,
   span: Span,
@@ -120,7 +142,7 @@ export function defaultHiddenValue(q: Quantity | QuantityRange, unit: string | u
   return `${minValue}..${maxValue}`
 }
 
-export function materialize(result: LingoResult | null, opts: LingoInputOptions): Material {
+export function materialize(result: LingoResult | null, opts: LingoFieldFormatOptions): Material {
   if (!result?.ok) {
     return { quantity: null, value: null, kind: null, approximate: false, canonical: null }
   }
@@ -177,7 +199,7 @@ export function materialize(result: LingoResult | null, opts: LingoInputOptions)
   return { quantity: null, value: null, kind: null, approximate: false, canonical: null }
 }
 
-export function acceptedResult(result: LingoResult, opts: LingoInputOptions): LingoResult {
+export function acceptedResult(result: LingoResult, opts: LingoFieldFormatOptions): LingoResult {
   if (!result.ok) {
     return result
   }
@@ -187,7 +209,10 @@ export function acceptedResult(result: LingoResult, opts: LingoInputOptions): Li
   return result
 }
 
-export function formatResultForCommit(result: LingoResult, opts: LingoInputOptions): string | null {
+export function formatResultForCommit(
+  result: LingoResult,
+  opts: LingoFieldFormatOptions,
+): string | null {
   if (!result.ok) {
     return null
   }
@@ -230,7 +255,7 @@ export function formatResultForCommit(result: LingoResult, opts: LingoInputOptio
   return String(result.value)
 }
 
-export function defaultHint(result: LingoResult, opts: LingoInputOptions): string {
+export function defaultHint(result: LingoResult, opts: LingoFieldFormatOptions): string {
   if (!result.ok) {
     return ''
   }
diff --git a/packages/lingo/src/dom/index.ts b/packages/lingo/src/dom/index.ts
index 0e78413..ebe343c 100644
--- a/packages/lingo/src/dom/index.ts
+++ b/packages/lingo/src/dom/index.ts
@@ -201,3 +201,5 @@ export namespace lingoInput {
     return registry.get(el)
   }
 }
+
+export type { CandidateResult, LingoFieldFormatOptions } from './format'
diff --git a/packages/lingo/src/react-native/index.ts b/packages/lingo/src/react-native/index.ts
new file mode 100644
index 0000000..aeb689b
--- /dev/null
+++ b/packages/lingo/src/react-native/index.ts
@@ -0,0 +1,437 @@
+import * as React from 'react'
+import type { Completion } from '../complete/types'
+import {
+  acceptedResult,
+  type CandidateResult,
+  defaultCandidate,
+  defaultHiddenValue,
+  defaultHint,
+  failResult,
+  formatQuantityForDisplay,
+  formatResultForCommit,
+  localIssue,
+  materialize,
+  toLingoOptions,
+} from '../dom/format'
+import type { LingoDisplayMode, LingoFieldState } from '../dom/index'
+import type { LingoIssue, LingoOptions, LingoResult, Quantity, QuantityRange, Span } from '../index'
+import { firstError, lingo, parseQuantity, partialState } from '../index'
+import { optionSignature } from '../react/signature'
+
+/**
+ * Options for `useLingoTextInput()`. Parsing options match the main lingo
+ * entry; the remaining fields control React Native display, commit, and
+ * callback behavior without importing `react-native`.
+ * @example
+ * ```tsx
+ * const field = useLingoTextInput({ kind: 'mass', unit: 'kg', min: 0 })
+ * ```
+ */
+export interface UseLingoTextInputOptions extends LingoOptions {
+  complete?: (text: string) => readonly Completion[]
+  debounce?: number
+  defaultText?: string
+  display?: LingoDisplayMode
+  displayUnit?: string
+  formatCandidate?: (candidate: CandidateResult) => string | undefined
+  formatHint?: (result: LingoResult) => string | undefined
+  hiddenFormat?: (quantity: Quantity | QuantityRange) => string | undefined
+  max?: string | number
+  min?: string | number
+  onCommit?: (result: LingoResult | null) => void
+  onComplete?: (completions: readonly Completion[]) => void
+  onError?: (issues: readonly LingoIssue[]) => void
+  onParse?: (result: LingoResult) => void
+  onStateChange?: (state: LingoFieldState, result: LingoResult | null) => void
+  onValueChange?: (value: number | null, quantity: Quantity | QuantityRange | null) => void
+  required?: boolean
+  value?: number | null
+}
+
+/**
+ * The platform-neutral subset of React Native `TextInput` props returned by
+ * `useLingoTextInput()`.
+ * @example
+ * ```tsx
+ * <TextInput {...field.inputProps} />
+ * ```
+ */
+export interface LingoTextInputProps {
+  onBlur(): void
+  onChangeText(text: string): void
+  onSubmitEditing(): void
+  value: string
+}
+
+/**
+ * Live state returned by `useLingoTextInput()`.
+ * @example
+ * ```tsx
+ * const field = useLingoTextInput({ kind: 'length', unit: 'm' })
+ * field.value // canonical number; field.text is display text
+ * ```
+ */
+export interface UseLingoTextInputResult {
+  commit(): void
+  completions: readonly Completion[]
+  dirty: boolean
+  errorMessage: string | null
+  highlightedIndex: number
+  hint: string | null
+  inputProps: LingoTextInputProps
+  quantity: Quantity | QuantityRange | null
+  result: LingoResult | null
+  selectCompletion(index?: number): void
+  set(value: number | string): void
+  setHighlightedIndex(index: number): void
+  state: LingoFieldState
+  submitValue: string
+  text: string
+  touched: boolean
+  value: number | null
+}
+
+interface NativeView {
+  errorMessage: string | null
+  hint: string | null
+  quantity: Quantity | QuantityRange | null
+  result: LingoResult | null
+  state: LingoFieldState
+  submitValue: string
+  text: string
+  touched: boolean
+  value: number | null
+}
+
+interface ParsedBound {
+  label: string
+  quantity: Quantity
+}
+
+const EMPTY_COMPLETIONS: readonly Completion[] = []
+const CONTROLLED_VALUE_EPSILON = 1e-12
+
+function sameControlledValue(expected: number | null, actual: number | null): boolean {
+  if (Object.is(expected, actual)) {
+    return true
+  }
+  if (expected === null || actual === null) {
+    return false
+  }
+  if (!(Number.isFinite(expected) && Number.isFinite(actual))) {
+    return false
+  }
+  const scale = Math.max(1, Math.abs(expected), Math.abs(actual))
+  return Math.abs(expected - actual) <= CONTROLLED_VALUE_EPSILON * scale
+}
+
+function displayTextForValue(value: number | null, options: UseLingoTextInputOptions): string {
+  if (value === null) {
+    return ''
+  }
+  if (!options.unit) {
+    return String(value)
+  }
+  const parsed = parseQuantity(String(value), toLingoOptions(options))
+  return parsed.ok
+    ? formatQuantityForDisplay(parsed.quantity, options.displayUnit ?? options.unit)
+    : String(value)
+}
+
+function parseBound(
+  value: string | number | undefined,
+  options: UseLingoTextInputOptions,
+): ParsedBound | null {
+  if (value === undefined) {
+    return null
+  }
+  const parsed = parseQuantity(String(value), toLingoOptions(options))
+  if (!parsed.ok) {
+    return null
+  }
+  const unit = options.unit ?? parsed.quantity.unit
+  const quantity = parsed.quantity.to(unit)
+  return { quantity, label: formatQuantityForDisplay(quantity, unit) }
+}
+
+function boundsIssue(
+  result: LingoResult,
+  text: string,
+  options: UseLingoTextInputOptions,
+): LingoIssue | null {
+  const quantity = materialize(result, options).quantity
+  if (!quantity) {
+    return null
+  }
+  const minBound = parseBound(options.min, options)
+  const maxBound = parseBound(options.max, options)
+  const span: Span = { start: 0, end: text.length }
+  const min = 'base' in quantity ? quantity : quantity.min()
+  const max = 'base' in quantity ? quantity : quantity.max()
+  if (minBound && min && min.base < minBound.quantity.base) {
+    return localIssue(options, 'RANGE_MIN', { min: minBound.label }, span)
+  }
+  if (maxBound && max && max.base > maxBound.quantity.base) {
+    return localIssue(options, 'RANGE_MAX', { max: maxBound.label }, span)
+  }
+  return null
+}
+
+function viewFor(
+  text: string,
+  state: LingoFieldState,
+  result: LingoResult | null,
+  touched: boolean,
+  options: UseLingoTextInputOptions,
+): NativeView {
+  const material = state === 'valid' ? materialize(result, options) : null
+  const error = state === 'invalid' && touched ? firstError(result) : null
+  const candidate = state === 'invalid' && result && !result.ok ? result.candidate : undefined
+  const hint = candidate
+    ? (options.formatCandidate?.(candidate) ?? defaultCandidate(candidate))
+    : state === 'valid' && result?.ok
+      ? (options.formatHint?.(result) ?? defaultHint(result, options))
+      : null
+  return {
+    text,
+    state,
+    result,
+    touched,
+    value: material?.value ?? null,
+    quantity: material?.quantity ?? null,
+    errorMessage: error?.message ?? null,
+    hint,
+    submitValue: material?.quantity
+      ? (options.hiddenFormat?.(material.quantity) ??
+        defaultHiddenValue(material.quantity, options.unit))
+      : '',
+  }
+}
+
+/**
+ * Upgrade React Native `TextInput` with lingo parsing and commit semantics.
+ * Spread `inputProps` onto the input; render errors, hints, and completions
+ * however your native design system requires.
+ * @example
+ * ```tsx
+ * import { Text, TextInput, View } from 'react-native'
+ * import { useLingoTextInput } from '@pascal-app/lingo/react-native'
+ *
+ * function HeightField() {
+ *   const field = useLingoTextInput({ kind: 'length', unit: 'm' })
+ *   return (
+ *     <View>
+ *       <TextInput {...field.inputProps} />
+ *       {field.errorMessage ? <Text>{field.errorMessage}</Text> : null}
+ *     </View>
+ *   )
+ * }
+ * ```
+ */
+export function useLingoTextInput(options: UseLingoTextInputOptions = {}): UseLingoTextInputResult {
+  const initialText =
+    options.value === undefined
+      ? (options.defaultText ?? '')
+      : displayTextForValue(options.value, options)
+  const initialTextRef = React.useRef(initialText)
+  const optionsRef = React.useRef(options)
+  const timerRef = React.useRef<ReturnType<typeof setTimeout> | null>(null)
+  const viewRef = React.useRef(viewFor(initialText, 'idle', null, false, options))
+  const [view, setView] = React.useState(viewRef.current)
+  const [completions, setCompletions] = React.useState<readonly Completion[]>(EMPTY_COMPLETIONS)
+  const [highlightedIndex, setHighlightedIndexState] = React.useState(-1)
+
+  optionsRef.current = options
+
+  const clearTimer = React.useCallback(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current)
+      timerRef.current = null
+    }
+  }, [])
+
+  const updateCompletions = React.useCallback((next: readonly Completion[]) => {
+    setCompletions(next)
+    setHighlightedIndexState(next.length ? 0 : -1)
+    optionsRef.current.onComplete?.(next)
+  }, [])
+
+  const publish = React.useCallback((next: NativeView) => {
+    const previous = viewRef.current
+    viewRef.current = next
+    setView(next)
+    if (previous.state !== next.state) {
+      optionsRef.current.onStateChange?.(next.state, next.result)
+    }
+    if (!sameControlledValue(previous.value, next.value)) {
+      optionsRef.current.onValueChange?.(next.value, next.quantity)
+    }
+  }, [])
+
+  const parseNow = React.useCallback(
+    (text: string, committed: boolean, touched: boolean): LingoResult | null => {
+      clearTimer()
+      const current = optionsRef.current
+      if (committed) {
+        updateCompletions(EMPTY_COMPLETIONS)
+      } else {
+        const next = text.trim() && current.complete ? current.complete(text) : EMPTY_COMPLETIONS
+        updateCompletions(next)
+      }
+
+      const partial = partialState(text, toLingoOptions(current))
+      if (partial === 'empty') {
+        if (committed && current.required) {
+          const issue = localIssue(current, 'REQUIRED', {}, { start: 0, end: text.length })
+          const failed = failResult(text, [issue])
+          publish(viewFor(text, 'invalid', failed, touched, current))
+          current.onError?.(failed.issues)
+          current.onCommit?.(failed)
+          return failed
+        }
+        publish(viewFor(text, 'idle', null, touched, current))
+        if (committed) {
+          current.onCommit?.(null)
+        }
+        return null
+      }
+      if (partial === 'incomplete') {
+        publish(viewFor(text, 'incomplete', null, touched, current))
+        if (committed) {
+          current.onCommit?.(null)
+        }
+        return null
+      }
+
+      const parsed = acceptedResult(lingo(text, toLingoOptions(current)), current)
+      current.onParse?.(parsed)
+      if (!parsed.ok) {
+        publish(viewFor(text, 'invalid', parsed, touched, current))
+        if (committed) {
+          current.onError?.(parsed.issues)
+          current.onCommit?.(parsed)
+        }
+        return parsed
+      }
+
+      if (committed) {
+        const issue = boundsIssue(parsed, text, current)
+        if (issue) {
+          const failed = failResult(text, [issue])
+          publish(viewFor(text, 'invalid', failed, touched, current))
+          current.onError?.(failed.issues)
+          current.onCommit?.(failed)
+          return failed
+        }
+      }
+
+      const formatted = committed ? formatResultForCommit(parsed, current) : null
+      publish(viewFor(formatted ?? text, 'valid', parsed, touched, current))
+      if (committed) {
+        current.onCommit?.(parsed)
+      }
+      return parsed
+    },
+    [clearTimer, publish, updateCompletions],
+  )
+
+  const onChangeText = React.useCallback(
+    (text: string) => {
+      clearTimer()
+      const current = { ...viewRef.current, text }
+      viewRef.current = current
+      setView(current)
+      timerRef.current = setTimeout(
+        () => parseNow(text, false, viewRef.current.touched),
+        optionsRef.current.debounce ?? 150,
+      )
+    },
+    [clearTimer, parseNow],
+  )
+
+  const commit = React.useCallback(() => {
+    parseNow(viewRef.current.text, true, true)
+  }, [parseNow])
+
+  const set = React.useCallback(
+    (value: number | string) => {
+      const text =
+        typeof value === 'number' ? displayTextForValue(value, optionsRef.current) : value
+      parseNow(text, true, viewRef.current.touched)
+    },
+    [parseNow],
+  )
+
+  const setHighlightedIndex = React.useCallback(
+    (index: number) => {
+      setHighlightedIndexState(
+        completions.length ? Math.min(Math.max(index, 0), completions.length - 1) : -1,
+      )
+    },
+    [completions.length],
+  )
+
+  const selectCompletion = React.useCallback(
+    (index?: number) => {
+      const selected = completions[index ?? highlightedIndex]
+      if (selected) {
+        set(selected.text)
+      }
+    },
+    [completions, highlightedIndex, set],
+  )
+
+  const signature = optionSignature(options)
+  React.useEffect(() => {
+    if (viewRef.current.text) {
+      parseNow(viewRef.current.text, false, viewRef.current.touched)
+    }
+  }, [parseNow, signature])
+
+  React.useEffect(() => {
+    if (options.value === undefined) {
+      return
+    }
+    if (options.value === null) {
+      if (viewRef.current.text) {
+        parseNow('', true, viewRef.current.touched)
+      }
+      return
+    }
+    if (!sameControlledValue(options.value, viewRef.current.value)) {
+      set(options.value)
+    }
+  }, [options.value, parseNow, set])
+
+  React.useEffect(() => clearTimer, [clearTimer])
+
+  const inputProps = React.useMemo<LingoTextInputProps>(
+    () => ({
+      value: view.text,
+      onChangeText,
+      onBlur: commit,
+      onSubmitEditing: commit,
+    }),
+    [commit, onChangeText, view.text],
+  )
+
+  return {
+    inputProps,
+    text: view.text,
+    state: view.state,
+    value: view.value,
+    quantity: view.quantity,
+    result: view.result,
+    touched: view.touched,
+    dirty: view.text !== initialTextRef.current,
+    errorMessage: view.errorMessage,
+    hint: view.hint,
+    submitValue: view.submitValue,
+    completions,
+    highlightedIndex,
+    setHighlightedIndex,
+    selectCompletion,
+    set,
+    commit,
+  }
+}
diff --git a/packages/lingo/src/react-native/use-lingo-text-input.test.tsx b/packages/lingo/src/react-native/use-lingo-text-input.test.tsx
new file mode 100644
index 0000000..1d04772
--- /dev/null
+++ b/packages/lingo/src/react-native/use-lingo-text-input.test.tsx
@@ -0,0 +1,158 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act } from 'react'
+import { createRoot, type Root } from 'react-dom/client'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { Completion } from '../complete/types'
+import { lingo } from '../index'
+import {
+  type UseLingoTextInputOptions,
+  type UseLingoTextInputResult,
+  useLingoTextInput,
+} from './index'
+
+let container: HTMLDivElement
+let root: Root
+
+beforeEach(() => {
+  container = document.createElement('div')
+  document.body.appendChild(container)
+  root = createRoot(container)
+})
+
+afterEach(() => {
+  act(() => root.unmount())
+  container.remove()
+})
+
+function Harness({
+  onApi,
+  options,
+}: {
+  onApi: (api: UseLingoTextInputResult) => void
+  options: UseLingoTextInputOptions
+}) {
+  onApi(useLingoTextInput(options))
+  return null
+}
+
+function mount(options: UseLingoTextInputOptions) {
+  let latest: UseLingoTextInputResult | null = null
+  const render = (next: UseLingoTextInputOptions) => {
+    act(() => root.render(<Harness onApi={(api) => (latest = api)} options={next} />))
+  }
+  const api = () => {
+    if (!latest) {
+      throw new Error('native hook did not render')
+    }
+    return latest
+  }
+  render(options)
+  return { api, rerender: render }
+}
+
+async function change(api: UseLingoTextInputResult, text: string) {
+  await act(async () => {
+    api.inputProps.onChangeText(text)
+    await new Promise((resolve) => setTimeout(resolve, 1))
+  })
+}
+
+function completion(text: string): Completion {
+  const result = lingo(text)
+  if (!result.ok || result.type === 'number') {
+    throw new Error(`invalid completion fixture: ${text}`)
+  }
+  return { text, result, confidence: result.confidence, source: 'parse' }
+}
+
+describe('useLingoTextInput', () => {
+  it('parses while typing and canonicalizes on blur', async () => {
+    const onValueChange = vi.fn()
+    const hook = mount({
+      kind: 'length',
+      unit: 'm',
+      debounce: 0,
+      onValueChange,
+    })
+
+    await change(hook.api(), '72 in')
+    expect(hook.api().text).toBe('72 in')
+    expect(hook.api().state).toBe('valid')
+    expect(hook.api().value).toBeCloseTo(1.8288)
+    expect(hook.api().dirty).toBe(true)
+
+    act(() => hook.api().inputProps.onBlur())
+    expect(hook.api().text).toBe('1.83 m')
+    expect(hook.api().touched).toBe(true)
+    expect(hook.api().submitValue).toBe('1.8288')
+    expect(onValueChange).toHaveBeenCalled()
+  })
+
+  it('returns required and bound issues with original-input spans', async () => {
+    const required = mount({ kind: 'mass', unit: 'kg', required: true })
+    act(() => required.api().commit())
+    expect(required.api().state).toBe('invalid')
+    expect(required.api().result?.issues[0]).toMatchObject({
+      code: 'REQUIRED',
+      span: { start: 0, end: 0 },
+    })
+
+    const bounded = mount({ kind: 'mass', unit: 'kg', max: '10 kg', debounce: 0 })
+    await change(bounded.api(), '20 kg')
+    expect(bounded.api().state).toBe('valid')
+    act(() => bounded.api().inputProps.onSubmitEditing())
+    expect(bounded.api().state).toBe('invalid')
+    expect(bounded.api().result?.issues[0]).toMatchObject({
+      code: 'RANGE_MAX',
+      span: { start: 0, end: 5 },
+    })
+    expect(bounded.api().errorMessage).toContain('10 kg')
+  })
+
+  it('surfaces and selects injected completions', async () => {
+    const items = [completion('2 ft'), completion('3 ft')]
+    const hook = mount({
+      kind: 'length',
+      unit: 'm',
+      debounce: 0,
+      complete: () => items,
+    })
+
+    await change(hook.api(), '2 f')
+    expect(hook.api().state).toBe('incomplete')
+    expect(hook.api().completions).toEqual(items)
+    expect(hook.api().highlightedIndex).toBe(0)
+
+    act(() => hook.api().setHighlightedIndex(99))
+    expect(hook.api().highlightedIndex).toBe(1)
+    act(() => hook.api().selectCompletion())
+    expect(hook.api().value).toBeCloseTo(0.9144)
+    expect(hook.api().text).toBe('0.914 m')
+    expect(hook.api().completions).toEqual([])
+  })
+
+  it('syncs a controlled canonical value', () => {
+    const hook = mount({ kind: 'length', unit: 'm', value: 2 })
+    expect(hook.api().value).toBe(2)
+    expect(hook.api().text).toBe('2 m')
+
+    hook.rerender({ kind: 'length', unit: 'm', value: 3 })
+    expect(hook.api().value).toBe(3)
+    expect(hook.api().text).toBe('3 m')
+
+    hook.rerender({ kind: 'length', unit: 'm', value: null })
+    expect(hook.api().state).toBe('idle')
+    expect(hook.api().text).toBe('')
+  })
+
+  it('clears pending parsing work on unmount', async () => {
+    const onParse = vi.fn()
+    const hook = mount({ kind: 'length', debounce: 50, onParse })
+    act(() => hook.api().inputProps.onChangeText('5 ft'))
+    act(() => root.render(<div />))
+    await new Promise((resolve) => setTimeout(resolve, 60))
+    expect(onParse).not.toHaveBeenCalled()
+  })
+})
diff --git a/packages/lingo/src/react/index.ts b/packages/lingo/src/react/index.ts
index 0b0c02a..335a166 100644
--- a/packages/lingo/src/react/index.ts
+++ b/packages/lingo/src/react/index.ts
@@ -1,6 +1,7 @@
 'use client'
 
 import * as React from 'react'
+import type { Completion } from '../complete/types'
 import {
   type LingoField,
   type LingoFieldState,
@@ -26,10 +27,18 @@ export interface UseLingoInputResult<
   T extends HTMLInputElement | HTMLTextAreaElement = HTMLInputElement,
 > {
   commit(): void
+  /** Ranked completions from the injected provider; empty while collapsed. */
+  completions: readonly Completion[]
+  /** Ranked completion currently highlighted, or `-1` when collapsed. */
+  highlightedIndex: number
   quantity: Quantity | QuantityRange | null
   ref: (node: T | null) => void
   result: LingoResult | null
+  /** Select a completion by index, defaulting to `highlightedIndex`. */
+  selectCompletion(index?: number): void
   set(v: number | string): void
+  /** Move the highlight, clamped to the current completion list. */
+  setHighlightedIndex(index: number): void
   /** Mirrors the underlying `LingoField.state` — see `LingoFieldState`. */
   state: LingoFieldState
   value: number | null
@@ -121,6 +130,7 @@ function updateOptions(o: UseLingoInputOptions): Partial<LingoInputOptions> {
     errorElement: o.errorElement,
     hintElement: o.hintElement,
     inputmode: o.inputmode,
+    listboxId: o.listboxId,
     debounce: o.debounce,
   }
 }
@@ -134,18 +144,33 @@ function sameSnapshot(a: Snapshot, b: Snapshot): boolean {
   )
 }
 
+interface CompletionView {
+  completions: readonly Completion[]
+  highlightedIndex: number
+}
+
+const EMPTY_COMPLETION_VIEW: CompletionView = {
+  completions: [],
+  highlightedIndex: -1,
+}
+
 /**
  * React hook wrapping `lingoInput()`: attach `ref` to your `<input>`/
- * `<textarea>` and get back live `state`/`value`/`quantity`/`result`.
+ * `<textarea>` and get back live parse and injected completion state.
  * Options are live-read on every render (see the option-signature note
  * below) so inline objects/callbacks are safe to pass without memoizing.
  * @example
  * ```tsx
+ * import { completions } from '@pascal-app/lingo/complete'
  * import { useLingoInput } from '@pascal-app/lingo/react'
  *
  * function HeightField() {
- *   const { ref, state, value } = useLingoInput({ kind: 'length', unit: 'm', name: 'height_m' })
- *   return <input ref={ref} placeholder={`try 5'11" or 180cm`} data-state={state} />
+ *   const field = useLingoInput({
+ *     kind: 'length',
+ *     unit: 'm',
+ *     complete: (text) => completions(text, { kind: 'length' }),
+ *   })
+ *   return <input ref={field.ref} data-state={field.state} />
  * }
  * ```
  */
@@ -153,9 +178,11 @@ export function useLingoInput<T extends HTMLInputElement | HTMLTextAreaElement =
   opts: UseLingoInputOptions = {},
 ): UseLingoInputResult<T> {
   const fieldRef = React.useRef<LingoField | null>(null)
+  const elementRef = React.useRef<T | null>(null)
   const optsRef = React.useRef(opts)
   const appliedSigRef = React.useRef<string | null>(null)
   const [view, setView] = React.useState<Snapshot>(() => snapshot(null))
+  const [completionView, setCompletionView] = React.useState<CompletionView>(EMPTY_COMPLETION_VIEW)
 
   optsRef.current = opts
 
@@ -164,18 +191,43 @@ export function useLingoInput<T extends HTMLInputElement | HTMLTextAreaElement =
     setView((prev) => (sameSnapshot(prev, next) ? prev : next))
   }, [])
 
+  const updateCompletionView = React.useCallback((completions: readonly Completion[]) => {
+    const next: CompletionView = {
+      completions,
+      highlightedIndex: completions.length ? 0 : -1,
+    }
+    setCompletionView(next)
+  }, [])
+
+  const liveComplete = React.useCallback(
+    (text: string) => optsRef.current.complete?.(text) ?? [],
+    [],
+  )
+
+  const handleCompletions = React.useCallback(
+    (completions: readonly Completion[], field: LingoField) => {
+      const expanded = elementRef.current?.getAttribute('aria-expanded') === 'true'
+      updateCompletionView(expanded ? completions : [])
+      optsRef.current.onComplete?.(completions, field)
+    },
+    [updateCompletionView],
+  )
+
   const ref = React.useCallback(
     (node: T | null) => {
       if (fieldRef.current) {
         fieldRef.current.destroy()
         fieldRef.current = null
       }
+      elementRef.current = node
       if (!node) {
         appliedSigRef.current = null
         setView(snapshot(null))
+        updateCompletionView([])
         return
       }
       const current = optsRef.current
+      const completionEnabled = Boolean(current.complete || current.onComplete)
       appliedSigRef.current = optionSignature(current)
       fieldRef.current = lingoInput(node, {
         ...updateOptions(current),
@@ -204,17 +256,22 @@ export function useLingoInput<T extends HTMLInputElement | HTMLTextAreaElement =
           optsRef.current.onCommit?.(field)
           syncView()
         },
+        ...(completionEnabled && {
+          complete: current.complete ? liveComplete : undefined,
+          onComplete: handleCompletions,
+        }),
         onError: (issues, field) => optsRef.current.onError?.(issues, field),
       })
       syncView()
     },
-    [syncView],
+    [handleCompletions, liveComplete, syncView, updateCompletionView],
   )
 
   React.useEffect(
     () => () => {
       fieldRef.current?.destroy()
       fieldRef.current = null
+      elementRef.current = null
     },
     [],
   )
@@ -257,15 +314,39 @@ export function useLingoInput<T extends HTMLInputElement | HTMLTextAreaElement =
   const set = React.useCallback(
     (value: number | string) => {
       fieldRef.current?.set(typeof value === 'number' ? String(value) : value)
+      updateCompletionView([])
       syncView()
     },
-    [syncView],
+    [syncView, updateCompletionView],
   )
 
   const commit = React.useCallback(() => {
     fieldRef.current?.commit()
+    updateCompletionView([])
     syncView()
-  }, [syncView])
+  }, [syncView, updateCompletionView])
+
+  const setHighlightedIndex = React.useCallback((index: number) => {
+    setCompletionView((current) => ({
+      ...current,
+      highlightedIndex: current.completions.length
+        ? Math.min(Math.max(index, 0), current.completions.length - 1)
+        : -1,
+    }))
+  }, [])
+
+  const selectCompletion = React.useCallback(
+    (index?: number) => {
+      const selected = completionView.completions[index ?? completionView.highlightedIndex]
+      if (!selected) {
+        return
+      }
+      fieldRef.current?.set(selected.text)
+      updateCompletionView([])
+      syncView()
+    },
+    [completionView, syncView, updateCompletionView],
+  )
 
   return {
     ref,
@@ -273,6 +354,10 @@ export function useLingoInput<T extends HTMLInputElement | HTMLTextAreaElement =
     value: view.value,
     quantity: view.quantity,
     result: view.result,
+    completions: completionView.completions,
+    highlightedIndex: completionView.highlightedIndex,
+    setHighlightedIndex,
+    selectCompletion,
     set,
     commit,
   }
diff --git a/packages/lingo/src/react/signature.test.ts b/packages/lingo/src/react/signature.test.ts
index ef863ab..0beeab3 100644
--- a/packages/lingo/src/react/signature.test.ts
+++ b/packages/lingo/src/react/signature.test.ts
@@ -40,14 +40,14 @@ describe('React option signatures', () => {
     )
   })
 
-  it('ignores live callback identities but tracks registry and element identity', () => {
+  it('tracks registry and element identity; callbacks stay off the signature type', () => {
     const registryA = {}
     const registryB = {}
     const elementA = {}
     const elementB = {}
 
-    expect(optionSignature({ formatHint: () => 'a' })).toBe(
-      optionSignature({ formatHint: () => 'b' }),
+    expect(optionSignature({ kind: 'length', debounce: 150 })).toBe(
+      optionSignature({ kind: 'length', debounce: 150 }),
     )
     expect(optionSignature({ registry: registryA as never })).toBe(
       optionSignature({ registry: registryA as never }),
@@ -55,11 +55,11 @@ describe('React option signatures', () => {
     expect(optionSignature({ registry: registryA as never })).not.toBe(
       optionSignature({ registry: registryB as never }),
     )
-    expect(elementSignature(elementA as HTMLElement)).toBe(`element:${objectSignature(elementA)}`)
+    expect(elementSignature(elementA as HTMLElement)).toBe(`e:${objectSignature(elementA)}`)
     expect(elementSignature(elementA as HTMLElement)).not.toBe(
       elementSignature(elementB as HTMLElement),
     )
-    expect(elementSignature('#hint')).toBe('selector:#hint')
+    expect(elementSignature('#hint')).toBe('s:#hint')
   })
 
   it('normalizes nested option values and snapshots', () => {
diff --git a/packages/lingo/src/react/signature.ts b/packages/lingo/src/react/signature.ts
index 7d140b6..69ea542 100644
--- a/packages/lingo/src/react/signature.ts
+++ b/packages/lingo/src/react/signature.ts
@@ -1,8 +1,19 @@
+import type { LingoFieldFormatOptions } from '../dom/format'
 import type { LingoInputOptions } from '../dom/index'
 
 const objectIds = new WeakMap<object, number>()
 let nextObjectId = 0
 
+/** Serializable field knobs shared by DOM and React Native option signatures. */
+export type LingoOptionSignatureInput = LingoFieldFormatOptions &
+  Pick<LingoInputOptions, 'debounce' | 'max' | 'min' | 'required'> &
+  Partial<
+    Pick<
+      LingoInputOptions,
+      'errorElement' | 'hintElement' | 'inputmode' | 'listboxId' | 'name' | 'validationBehavior'
+    >
+  >
+
 export function objectSignature(value: unknown): string {
   if ((typeof value !== 'object' && typeof value !== 'function') || value === null) {
     return ''
@@ -16,12 +27,12 @@ export function objectSignature(value: unknown): string {
 }
 
 export function elementSignature(
-  value: LingoInputOptions['errorElement'] | LingoInputOptions['hintElement'],
+  value: LingoInputOptions['errorElement'] | LingoInputOptions['hintElement'] | undefined,
 ): string {
   if (typeof value === 'string') {
-    return `selector:${value}`
+    return `s:${value}`
   }
-  return value ? `element:${objectSignature(value)}` : ''
+  return value ? `e:${objectSignature(value)}` : ''
 }
 
 export function stableOptionValue(value: unknown): unknown {
@@ -39,7 +50,7 @@ export function stableOptionValue(value: unknown): unknown {
     }
     return out
   }
-  return typeof value === 'function' ? 'ƒ' : value
+  return typeof value === 'function' ? 'f' : value
 }
 
 export function messagesSignature(messages: LingoInputOptions['messages']): string {
@@ -48,7 +59,7 @@ export function messagesSignature(messages: LingoInputOptions['messages']): stri
         .sort()
         .map((k) => {
           const v = (messages as Record<string, unknown>)[k]
-          return `${k}:${typeof v === 'function' ? 'ƒ' : String(v)}`
+          return `${k}:${typeof v === 'function' ? 'f' : String(v)}`
         })
         .join('|')
     : ''
@@ -65,7 +76,7 @@ export function structuralSignature(value: unknown): string {
  * (React error #185). Function-typed options are intentionally excluded here
  * and are live-read through refs by the hook.
  */
-export function optionSignature(o: LingoInputOptions): string {
+export function optionSignature(o: LingoOptionSignatureInput): string {
   const messagesSig = messagesSignature(o.messages)
   return JSON.stringify([
     o.kind,
@@ -91,6 +102,7 @@ export function optionSignature(o: LingoInputOptions): string {
     elementSignature(o.errorElement),
     elementSignature(o.hintElement),
     o.inputmode,
+    o.listboxId,
     o.debounce,
   ])
 }
diff --git a/packages/lingo/src/react/use-lingo-input.test.tsx b/packages/lingo/src/react/use-lingo-input.test.tsx
index 4d045fd..30f8ea3 100644
--- a/packages/lingo/src/react/use-lingo-input.test.tsx
+++ b/packages/lingo/src/react/use-lingo-input.test.tsx
@@ -3,7 +3,9 @@
  */
 import { act } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { Completion } from '../complete/types'
+import { lingo } from '../index'
 import { type UseLingoInputResult, useLingoInput } from './index'
 
 // Smoke coverage for the ./react entry: mount the hook against a real DOM
@@ -77,6 +79,14 @@ async function type(input: HTMLInputElement, text: string): Promise<void> {
   })
 }
 
+function completion(text: string): Completion {
+  const result = lingo(text)
+  if (!result.ok || result.type === 'number') {
+    throw new Error(`invalid completion fixture: ${text}`)
+  }
+  return { text, result, confidence: result.confidence, source: 'parse' }
+}
+
 describe('useLingoInput (jsdom smoke)', () => {
   it('parses typed input into state/value/quantity', async () => {
     const h = mount()
@@ -117,4 +127,112 @@ describe('useLingoInput (jsdom smoke)', () => {
     act(() => root.render(<div />))
     expect(container.querySelector('input')).toBeNull()
   })
+
+  it('surfaces, highlights, and selects injected completions', async () => {
+    const items = [completion('2 ft'), completion('3 ft')]
+    const onComplete = vi.fn()
+    let latest: UseLingoInputResult | null = null
+    const api = () => {
+      if (!latest) {
+        throw new Error('completion harness did not render')
+      }
+      return latest
+    }
+
+    function CompletionHarness() {
+      const api = useLingoInput({
+        kind: 'length',
+        unit: 'm',
+        debounce: 0,
+        listboxId: 'height-options',
+        complete: () => items,
+        onComplete,
+      })
+      latest = api
+      return (
+        <input
+          onKeyDownCapture={(event) => {
+            if (event.key === 'ArrowDown') {
+              event.preventDefault()
+              api.setHighlightedIndex(api.highlightedIndex + 1)
+            }
+            if (event.key === 'Enter') {
+              event.preventDefault()
+              event.stopPropagation()
+              api.selectCompletion(api.highlightedIndex)
+            }
+          }}
+          ref={api.ref}
+        />
+      )
+    }
+
+    act(() => root.render(<CompletionHarness />))
+    const input = container.querySelector('input')
+    if (!(input && latest)) {
+      throw new Error('completion harness did not mount')
+    }
+
+    await type(input, '2 f')
+    expect(api().completions).toEqual(items)
+    expect(api().highlightedIndex).toBe(0)
+    expect(input.getAttribute('aria-controls')).toBe('height-options')
+    expect(input.getAttribute('aria-expanded')).toBe('true')
+
+    act(() =>
+      input.dispatchEvent(
+        new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true, cancelable: true }),
+      ),
+    )
+    expect(api().highlightedIndex).toBe(1)
+
+    act(() =>
+      input.dispatchEvent(
+        new KeyboardEvent('keydown', { key: 'Enter', bubbles: true, cancelable: true }),
+      ),
+    )
+    expect(api().value).toBeCloseTo(0.9144)
+    expect(api().completions).toEqual([])
+    expect(api().highlightedIndex).toBe(-1)
+    expect(input.getAttribute('aria-expanded')).toBe('false')
+    expect(onComplete).toHaveBeenCalled()
+  })
+
+  it('live-reads a changed completion provider', async () => {
+    let latest: UseLingoInputResult | null = null
+    const api = () => {
+      if (!latest) {
+        throw new Error('completion harness did not render')
+      }
+      return latest
+    }
+    const first = [completion('2 ft')]
+    const second = [completion('3 ft')]
+
+    function CompletionHarness({ items }: { items: readonly Completion[] }) {
+      const api = useLingoInput({
+        kind: 'length',
+        debounce: 0,
+        complete: () => items,
+      })
+      latest = api
+      return <input ref={api.ref} />
+    }
+
+    act(() => root.render(<CompletionHarness items={first} />))
+    const input = container.querySelector('input')
+    if (!(input && latest)) {
+      throw new Error('completion harness did not mount')
+    }
+    await type(input, '2 f')
+    expect(api().completions).toEqual(first)
+
+    act(() => root.render(<CompletionHarness items={second} />))
+    await type(input, '3 f')
+    expect(api().completions).toEqual(second)
+
+    act(() => input.dispatchEvent(new FocusEvent('blur')))
+    expect(api().completions).toEqual([])
+    expect(api().highlightedIndex).toBe(-1)
+  })
 })
diff --git a/packages/lingo/tsup.config.ts b/packages/lingo/tsup.config.ts
index e78156f..2cc8a15 100644
--- a/packages/lingo/tsup.config.ts
+++ b/packages/lingo/tsup.config.ts
@@ -47,4 +47,12 @@ export default defineConfig((options) => [
       js: "'use client';",
     },
   },
+  {
+    ...shared,
+    entry: {
+      'react-native/index': 'src/react-native/index.ts',
+    },
+    clean: false,
+    treeshake: false,
+  },
 ])
diff --git a/plans/011-packaging-dx-and-release.md b/plans/011-packaging-dx-and-release.md
index 101c676..c86c13b 100644
--- a/plans/011-packaging-dx-and-release.md
+++ b/plans/011-packaging-dx-and-release.md
@@ -3,7 +3,7 @@ id: 011
 title: Packaging, DX & release
 status: approved
 created: 2026-07-03
-updated: 2026-07-07
+updated: 2026-07-21
 ---
 
 # Packaging, DX & release
@@ -11,10 +11,13 @@ updated: 2026-07-07
 ## Package
 
 - `@pascal-app/lingo`, MIT, `type: module`, dual ESM+CJS via tsup, `.d.ts` for every entry,
-  `sideEffects: false`, `files: ["dist"]`, Node ≥ 18, no runtime deps, React optional
-  peer (`./react` only).
+  `sideEffects: false`, `files: ["dist", "llms.txt", "CHANGELOG.md"]`, Node ≥ 18,
+  no runtime deps, React optional peer (`./react` and `./react-native` only).
 - Entries: `.`, `./core`, `./date`, `./describe`, `./catalog`, `./schema`,
-  `./dom`, `./element`, `./react`, `./ai`, `./mcp` (+ `./package.json`).
+  `./dom`, `./element`, `./react`, `./react-native`, `./complete`, `./ai`,
+  `./mcp`, `./locales/*` (+ `./package.json`).
+- `llms.txt` ships in the tarball as the offline agent reference (inline examples
+  per entry); the site mirrors it at `/llms-small.txt`.
 - The IIFE playground build (`demo/lingo.demo.js`, built by `scripts/demo.mjs`)
   is a repo-local artifact for the zero-build demo only — it is not part of
   `files`/`exports` and does not ship in the npm package (D16); CDN/`<script>`
diff --git a/plans/012-agent-and-llm-friendliness.md b/plans/012-agent-and-llm-friendliness.md
index e840cef..aee084a 100644
--- a/plans/012-agent-and-llm-friendliness.md
+++ b/plans/012-agent-and-llm-friendliness.md
@@ -3,7 +3,7 @@ id: 012
 title: Agent & LLM friendliness
 status: done
 created: 2026-07-03
-updated: 2026-07-08
+updated: 2026-07-21
 ---
 
 # Agent & LLM friendliness
@@ -35,7 +35,7 @@ Two roles, split intentionally:
 
 | Surface | Role |
 |---------|------|
-| `packages/lingo/llms.txt` (npm) | Self-contained compressed API reference with nested headings, fenced examples per entry, issue-code remedies, and canonical input→output examples. Shipped in the tarball; also mirrored at `/llms-small.txt`. |
+| `packages/lingo/llms.txt` (npm) | Self-contained compressed API reference with nested headings, fenced examples per entry (including `./react` and `./react-native` adapter recipes), issue-code remedies, and canonical input→output examples. Shipped in the tarball; also mirrored at `/llms-small.txt`. Agents must be able to integrate from this file alone when offline. |
 | `https://lingo.pascal.app/llms.txt` | Spec-compliant index ([llmstxt.org](https://llmstxt.org/)): H1 + blockquote + H2 link lists to `/docs/<section>.md`, `/llms-full.txt`, schema artifacts, and an `## Optional` section. Generated from `docs-catalog.ts` at build time. |
 | `/llms-full.txt` | Complete `/docs` narrative as markdown (from `docs.md.ts`). |
 | `/docs/<section>.md` | Self-contained per-topic slices with context headers (Mintlify-style append-`.md` convention). |
diff --git a/plans/031-completions.md b/plans/031-completions.md
index faf867c..dc1658f 100644
--- a/plans/031-completions.md
+++ b/plans/031-completions.md
@@ -3,13 +3,14 @@ id: 031
 title: Ranked completions (autocomplete anything)
 status: approved
 created: 2026-07-08
-updated: 2026-07-08
+updated: 2026-07-20
 goal: "Ship a ranked completions API that returns all plausible canonical interpretations of a partial or ambiguous quantity input, plus docs/showcase demos — without a library-shipped dropdown."
 success_criteria:
   - "completions('2 f') returns multiple ranked QuantityResult readings -> packages/lingo/tests/complete.test.ts"
   - "Every completion text round-trips through parse -> same test file"
   - "./complete marginal size budget green -> packages/lingo/scripts/size.mjs"
   - "Docs site combobox demo renders ranked completions -> apps/site showcase section"
+  - "useLingoInput exposes injected completions and headless selection state without importing ./complete at runtime -> packages/lingo/src/react/use-lingo-input.test.tsx"
 ---
 
 # Ranked completions (autocomplete anything)
@@ -76,14 +77,40 @@ Dedupe by canonical `text`, sort by `confidence` descending, cap at `limit` (def
 DOM: `LingoInputOptions` gains injected `complete?` and `onComplete?` hooks — no
 bundled dropdown (plan 008 non-goal stands; site builds the combobox demo).
 
+### React bridge (locked-in 2026-07-20)
+
+`useLingoInput()` forwards the same injected completion provider and owns only
+the state that every React combobox would otherwise have to rebuild:
+
+```ts
+interface UseLingoInputResult {
+  completions: readonly Completion[]
+  highlightedIndex: number
+  setHighlightedIndex(index: number): void
+  selectCompletion(index?: number): void
+}
+```
+
+New completion lists reset highlighting to the first ranked result; an empty
+list uses `-1`. `setHighlightedIndex()` clamps to the current list.
+`selectCompletion()` defaults to the highlighted result, writes that
+completion's canonical `text` through the existing controller, commits it, and
+collapses the hook's list.
+
+`Completion` remains a type-only import and the provider remains injected:
+`./react` never imports the `./complete` orchestrator at runtime. Popup markup,
+option ids, styling, and keyboard policy remain caller-owned.
+
 ## Changes
 
 1. `Registry.aliasCompletions(prefix, kind?, limit?)` — ranked prefix expansion.
 2. `packages/lingo/src/complete/` — `completions()` orchestrator.
 3. `packages/lingo/package.json` + `tsup.config.ts` — `./complete` entry.
 4. `packages/lingo/src/dom/` — injected hooks on controller.
-5. `apps/site/` — combobox showcase + docs section.
-6. Tests, bench case, corpus (ADDITIVE only), CHANGELOG, README, llms.txt.
+5. `packages/lingo/src/react/` — injected provider bridge, completion state,
+   and headless selection helpers.
+6. `apps/site/` — combobox showcase + docs section.
+7. Tests, bench case, corpus (ADDITIVE only), CHANGELOG, README, llms.txt.
 
 ## Non-goals
 
@@ -92,4 +119,5 @@ bundled dropdown (plan 008 non-goal stands; site builds the combobox demo).
 
 ## Acceptance
 
-`bun run check` green; bench case for `completions('2 f')`; site demo works.
+`bun run check` green; bench case for `completions('2 f')`; React bridge tests
+green; site demo works with keyboard navigation and the existing ARIA contract.
diff --git a/plans/034-react-native-input.md b/plans/034-react-native-input.md
new file mode 100644
index 0000000..1ddb47f
--- /dev/null
+++ b/plans/034-react-native-input.md
@@ -0,0 +1,120 @@
+---
+id: 034
+title: React Native text input
+status: done — shipped 2026-07-20
+created: 2026-07-20
+updated: 2026-07-21
+goal: "Ship a DOM-free React Native hook that gives TextInput the same parse, commit, validation, and completion semantics as lingo's web fields."
+success_criteria:
+  - "[MET: handler tests] TextInput handlers parse while typing and canonicalize on blur/submit -> src/react-native/use-lingo-text-input.test.tsx"
+  - "[MET: issue-span tests] Required/bounds failures retain original-input spans -> src/react-native/use-lingo-text-input.test.tsx"
+  - "[MET: completion tests + size gate] Injected completions select without bundling ./complete -> src/react-native/use-lingo-text-input.test.tsx + scripts/size.mjs"
+  - "[MET: build + zero-deps gate] ./react-native builds with React as its only optional peer and no react-native import -> build + zero-deps gate"
+---
+
+# React Native text input
+
+Driver: mobile forms need the same forgiving text-to-canonical-value boundary as
+web forms, but `useLingoInput()` is intentionally built on the DOM controller
+and cannot attach to React Native `TextInput`.
+
+## Design principle
+
+**Share parsing semantics, not platform mechanics.** React Native gets a
+separate headless entry over the same parser and commit-format helpers. It does
+not emulate DOM refs, Constraint Validation, hidden inputs, or ARIA.
+
+## Design (locked-in 2026-07-20)
+
+```ts
+export interface UseLingoTextInputOptions extends LingoOptions {
+  defaultText?: string
+  value?: number | null
+  display?: 'canonical' | 'echo' | 'preserve'
+  displayUnit?: string
+  min?: string | number
+  max?: string | number
+  required?: boolean
+  debounce?: number
+  complete?: (text: string) => readonly Completion[]
+  hiddenFormat?: (quantity: Quantity | QuantityRange) => string | undefined
+  formatHint?: (result: LingoResult) => string | undefined
+  formatCandidate?: (candidate: CandidateResult) => string | undefined
+  onValueChange?: (value: number | null, quantity: Quantity | QuantityRange | null) => void
+  onStateChange?: (state: LingoFieldState, result: LingoResult | null) => void
+  onParse?: (result: LingoResult) => void
+  onCommit?: (result: LingoResult | null) => void
+  onError?: (issues: readonly LingoIssue[]) => void
+  onComplete?: (completions: readonly Completion[]) => void
+}
+
+export interface LingoTextInputProps {
+  value: string
+  onChangeText(text: string): void
+  onBlur(): void
+  onSubmitEditing(): void
+}
+
+export interface UseLingoTextInputResult {
+  inputProps: LingoTextInputProps
+  text: string
+  state: LingoFieldState
+  value: number | null
+  quantity: Quantity | QuantityRange | null
+  result: LingoResult | null
+  touched: boolean
+  dirty: boolean
+  errorMessage: string | null
+  hint: string | null
+  submitValue: string
+  completions: readonly Completion[]
+  highlightedIndex: number
+  setHighlightedIndex(index: number): void
+  selectCompletion(index?: number): void
+  set(value: number | string): void
+  commit(): void
+}
+
+export function useLingoTextInput(
+  options?: UseLingoTextInputOptions,
+): UseLingoTextInputResult
+```
+
+`inputProps` is structurally compatible with React Native `TextInput`; the
+entry imports no `react-native` runtime or types. `onChangeText` updates display
+text immediately and debounces parsing. `onBlur`, `onSubmitEditing`, and
+`commit()` parse immediately, apply required/bounds checks, and rewrite valid
+text according to `display`. `set()` and completion selection commit without
+marking the field touched.
+
+`value` is the controlled canonical number in `unit`; `text` is display text.
+`submitValue` is the native equivalent of the DOM controller's hidden value.
+Completion generation remains injected, so importing `./react-native` does not
+pull in `./complete`.
+
+## Changes
+
+1. Add `src/react-native/` with the hook and handler-driven React tests.
+2. Add the `./react-native` package export and independent build/size gate.
+3. Permit the existing optional React peer in both React adapter entries; add
+   no `react-native` dependency or peer.
+4. Update the package guide, architecture, glossary entry list, README,
+   recipes, llms.txt, and changelog.
+
+## Non-goals
+
+- No React Native component, popup, styling, or form-library dependency.
+- No DOM controller or `react-native` runtime import.
+- No ARIA/Constraint Validation emulation; callers use native accessibility
+  props and render `errorMessage`/`hint`.
+- No shared-controller rewrite. The hook reuses DOM-free
+  `LingoFieldFormatOptions` helpers from `dom/format.ts` (parse options,
+  materialize, commit/hint formatting) without casting through DOM callback
+  shapes; broader controller extraction waits for another non-DOM adapter.
+- No date-specific field mode; callers may inject date completions, while this
+  field retains the quantity parser semantics of the DOM controller.
+
+## Acceptance
+
+`bun run check` and `bun run lint` green; corpus diff zero; the new entry's size
+gate green; built output contains no `react-native` import.
diff --git a/plans/README.md b/plans/README.md
index b5ed71c..9ced4b3 100644
--- a/plans/README.md
+++ b/plans/README.md
@@ -11,7 +11,7 @@ and whose content is covered by wiki/code gets deleted, and its number retired
 ## Conventions
 
 - **Filename:** `NNN-kebab-title.md` — three digits, stable once assigned.
-  Next free number: **033**.
+  Next free number: **035**.
 - **Frontmatter:** `id`, `title`, `status`, `created`, `updated`. New plans
   (since 2026-07-04) also carry:
   - `goal:` — one-sentence done state.
@@ -102,6 +102,7 @@ Driver: <the user need, review finding, or decision that motivates this — link
 | 031 | [Ranked completions (autocomplete anything)](031-completions.md) | approved |
 | 031 | [Locale packs](031-locale-packs.md) | in-progress |
 | 032 | [Input calculations (quantity arithmetic)](032-input-calculations.md) | draft |
+| 034 | [React Native text input](034-react-native-input.md) | done |
 
 Retired numbers (plans deleted after shipping; content lives in wiki/code):
 015–017, 022–023.
diff --git a/skills/lingo/SKILL.md b/skills/lingo/SKILL.md
index b910701..64dcc0e 100644
--- a/skills/lingo/SKILL.md
+++ b/skills/lingo/SKILL.md
@@ -61,6 +61,7 @@ Import only what you need; each subpath is tree-shakeable.
 | `@pascal-app/lingo/mcp` | `lingoTool()` — MCP tool with validation before the handler |
 | `@pascal-app/lingo/dom` | headless `lingoInput()` controller for any `<input>` |
 | `@pascal-app/lingo/react` | `useLingoInput()` hook |
+| `@pascal-app/lingo/react-native` | DOM-free `useLingoTextInput()` hook for React Native `TextInput` |
 | `@pascal-app/lingo/element` | `<lingo-input>` form-associated custom element |
 | `@pascal-app/lingo/complete` | ranked autocomplete `completions()` |
 | `@pascal-app/lingo/locales/{en,en-gb,es,fr,pt,zh,ja}` | opt-in parsing language packs |
@@ -110,6 +111,7 @@ field.commit() // hidden <input name="height_m"> submits the canonical value
 
 React: `useLingoInput(opts)` from `@pascal-app/lingo/react`. Framework-agnostic
 element: `defineLingoInput()` then `<lingo-input kind="length" unit="m" name="height_m">`.
+React Native: spread `useLingoTextInput(opts).inputProps` onto `TextInput`.
 
 ## Pattern 3 — safe LLM tool / MCP boundary
 
diff --git a/wiki/architecture.md b/wiki/architecture.md
index ad15cf4..6cefe70 100644
--- a/wiki/architecture.md
+++ b/wiki/architecture.md
@@ -30,7 +30,8 @@ input string
 | `./date` | `src/date/` | NL dates, time-of-day, zones, ranges/slots, reversible humanize, ISO durations |
 | `./dom` | `src/dom/` | headless input controller |
 | `./element` | `src/element/` | `<lingo-input>` form-associated custom element |
-| `./react` | `src/react/` | `useLingoInput` hook (`'use client'`) |
+| `./react` | `src/react/` | `useLingoInput` hook (`'use client'`) over the DOM controller |
+| `./react-native` | `src/react-native/` | DOM-free `useLingoTextInput` for RN `TextInput`; reuses `LingoFieldFormatOptions` helpers from `dom/format.ts`, never imports `react-native` |
 | `./describe` | `src/describe/` | resource views: `describeResource`, `describeResult` |
 | `./catalog` | `src/catalog/` | read-only queries over built-in unit/kind/currency data (D56) |
 | `./schema` | `src/schema/` | machine-readable schema for the v3 wire JSON (pure data) |
diff --git a/wiki/research/utility-opportunities.md b/wiki/research/utility-opportunities.md
new file mode 100644
index 0000000..3f204b2
--- /dev/null
+++ b/wiki/research/utility-opportunities.md
@@ -0,0 +1,166 @@
+# Utility opportunities: forms easier, LLM tools safer
+
+Research synthesis, 2026-07-20. This is a prioritization pass over lingo's
+shipped surface, plans, backlog, and the source-verified ecosystem research in
+this directory. It does not repeat unverified market-size claims. The external
+integration findings were most recently checked between 2026-07-04 and
+2026-07-09; version-sensitive recipes still need a fresh check when implemented.
+
+## Product wedge
+
+Most libraries own one step: natural-language parsing, unit conversion,
+validation, formatting, or tool-schema generation. lingo's defensible value is
+the whole boundary:
+
+`messy text -> parse -> canonicalize -> validate -> store/call -> humanize`
+
+The same options vocabulary drives a human field and a model-facing
+`LingoField`. Spans, explicit ambiguity, two-way output, Standard Schema, and
+zero runtime dependencies make that shared boundary difficult to reproduce with
+a stack of generic validators and conversion helpers.
+
+The useful growth strategy is therefore not "parse every noun." It is:
+
+1. remove integration work around the boundary that already exists;
+2. expose safety information generic adapters discard;
+3. add high-value language coverage as tree-shakeable data;
+4. prove speed and correctness with executable examples.
+
+## Opportunity matrix
+
+Scores are relative: value and differentiation run from 1 (low) to 5 (high);
+cost and bundle risk run from 1 (small) to 5 (large).
+
+| Opportunity | Audience | Value | Differentiation | Cost | Bundle risk | Recommendation |
+|---|---|---:|---:|---:|---:|---|
+| React completion state and selection | Forms, computer-use agents | 5 | 3 | 2 | 1 | Ship first |
+| React Native TextInput adapter | Mobile forms | 4 | 3 | 3 | 1 | Separate headless entry |
+| Strict-schema preflight (`assertStrictSafe`) | Tool authors | 4 | 4 | 2 | 1 | Next safety slice |
+| Warning-preserving direct integrations | Forms, tool authors | 5 | 5 | 2 | 1 | Design after observing adapters |
+| Date/duration wire schemas | APIs, agents | 4 | 3 | 3 | 2 | Finish plan 029 |
+| Date component certainty | Agents, audit pipelines | 5 | 5 | 4 | 3 | Strategic date follow-up |
+| Demo MCP server | Agents, evaluators | 4 | 3 | 2 | 1 | Dogfood `lingoTool` |
+| Localized humanize and issue copy | Global forms | 5 | 4 | 5 | 4 | Pack-owned, staged rollout |
+| Input calculations in `./calc` | Forms | 4 | 3 | 5 | 4 | Resolve plan 032 first |
+| Browser benchmark and comparisons | Evaluators | 3 | 3 | 2 | 1 | Publish proof, not core code |
+
+No new backlog entries result from this pass: every deferred opportunity above
+already appears in a numbered plan or `plans/backlog.md`.
+
+## Shipped first slice: React completions
+
+`@pascal-app/lingo/complete` already returns ranked, fully parsed completions,
+and `lingoInput()` accepts an injected completion provider. `useLingoInput()`
+now forwards that provider and surfaces the resulting list, highlighted index,
+and selection helpers without bundling the completion engine.
+
+The first slice should expose completion list and highlighted-index state from
+`useLingoInput()`, plus a selection helper. The completion engine remains an
+explicit caller import, so React-only consumers do not pay for it. Popup markup,
+option ids, styling, and keyboard policy remain headless and caller-owned.
+
+This closes a real integration gap without changing parser behavior, adding a
+dependency, or turning the library into a component kit. It also improves
+computer-use-agent fields: partial inputs can expose ranked, canonical choices
+before commit, while the existing `data-state` and ARIA attributes remain the
+machine-readable feedback channel.
+
+## High-leverage applications
+
+### One value, one field
+
+Collapse a value and unit selector into one text field, not an entire form into
+a sentence:
+
+- health intake: `5'11"` and `165 lb` into canonical height and mass;
+- shipping and listings: dimensions and weight in the units printed on a label;
+- finance: `25 bps`, `0.25%`, or `a quarter point`;
+- IoT: `68F`, `20 C`, or an approved fuzzy temperature profile;
+- lab and construction: mixed source units canonicalized before storage;
+- cooking: volume-to-volume and mass-to-mass only; ingredient density remains
+  outside lingo's scope.
+
+Completions are especially useful where bare numbers or short aliases would
+otherwise hide an assumption. The UI can show full parsed readings instead of
+inventing a second suggestion vocabulary.
+
+### Progressive enhancement
+
+Use `lingoInput()` on a normal text input, submit the canonical hidden value when
+JavaScript runs, and re-parse server-side either way. A form-associated
+`<lingo-input>` gives design systems the same path without a framework adapter.
+This is a stronger adoption route than shipping a styled field component.
+
+### One field specification on both sides
+
+Keep a shared options object for the browser field and the tool argument:
+
+- the browser gets partial-state UX, commit formatting, bounds, and ARIA;
+- `quantityField()` or `dateField()` gets closed JSON Schema, deterministic
+  reference time, coded issues, and canonical output;
+- the database stores one canonical value and optionally the raw input for
+  audit;
+- `format()` or `humanize*()` renders the value back under the two-way
+  guarantee.
+
+This is the shortest demonstration of the product thesis because it removes
+duplicated validation policy rather than merely sharing types.
+
+### Tool-call firewall
+
+Use `lingoObject()` or `lingoTool()` at the execution boundary even when the
+agent framework only consumes plain JSON Schema. Generic shape validation cannot
+decide whether `"1,234"`, `"next Friday"`, or `"70"` is semantically safe.
+lingo can reject ambiguity, require an explicit `now`, return a candidate, or
+canonicalize locally without another model call.
+
+The next small safety utility should walk a field's emitted schema and fail
+definition-time checks when strict-provider invariants are violated. It should
+not import an AI SDK or provider package.
+
+### Human confirmation as a first-class branch
+
+Candidates and warnings are ready-made inputs for review:
+
+- a form can show the candidate in its hint or description slot;
+- a LangGraph-style workflow can interrupt on ambiguity and resume with the
+  confirmed canonical value;
+- an extraction pipeline can keep full quantity output and route warning-bearing
+  records to review;
+- evals can compare canonical values instead of brittle strings.
+
+Generic Standard Schema adapters intentionally retain only `value` or `issues`,
+so success warnings need a direct-lingo integration path rather than a claim
+that generic resolvers preserve them.
+
+## Recommended sequence
+
+1. Keep the React completion bridge dogfooded in the accessible site combobox.
+2. Ship the separate DOM-free React Native TextInput adapter without importing
+   `react-native`.
+3. Add strict-schema preflight as a tiny, provider-neutral `./ai` helper.
+4. Design a warning-preserving integration pattern using evidence from the DOM,
+   React, form recipes, and tool callbacks; do not mutate validation into a
+   side-effect.
+5. Finish date/duration machine schemas, then add per-component date certainty
+   when the date result shape is next revised.
+6. Publish a demo MCP server and comparative browser benchmarks as executable
+   adoption proof.
+7. Continue locale work through pack-owned humanize templates and message copy,
+   preserving two-way tests and entry budgets.
+
+## Sources in this repository
+
+- `plans/000-vision-and-scope.md`
+- `plans/021-mcp-integration.md`
+- `plans/029-schema-reference-and-adapters.md`
+- `plans/031-completions.md`
+- `plans/031-locale-packs.md`
+- `plans/032-input-calculations.md`
+- `plans/backlog.md`
+- `wiki/research/ai-structured-output.md`
+- `wiki/research/base-ui-headless-patterns.md`
+- `wiki/research/competitive-landscape.md`
+- `wiki/research/ecosystem-agent-frameworks.md`
+- `wiki/research/ecosystem-form-libraries.md`
+- `wiki/research/form-ux-and-database.md`